priorityx 0.1.2__py3-none-any.whl

priorityx/viz/timeline.py

@@ -0,0 +1,302 @@
+"""Transition timeline heatmap visualization."""
+
+from typing import List, Literal, Optional, Tuple
+
+import matplotlib.pyplot as plt
+import pandas as pd
+
+
+def plot_transition_timeline(
+    transitions_df: pd.DataFrame,
+    entity_filter: Optional[List[str]] = None,
+    highlight_risk_levels: List[str] = ["critical", "high"],
+    filter_risk_levels: List[str] = ["critical", "high", "medium"],
+    max_entities: Optional[int] = 20,
+    figsize: Tuple[int, int] = (14, 8),
+    title: Optional[str] = None,
+    x_axis_granularity: Literal["quarterly", "semiannual", "yearly"] = "quarterly",
+    sort_by_risk_first: bool = True,
+    entity_name: str = "Entity",
+    show_all_periods: bool = False,
+    save_plot: bool = False,
+    save_csv: bool = False,
+    output_dir: str = "plot",
+    temporal_granularity: str = "quarterly",
+) -> plt.Figure:
+    """
+    Visualize transition timeline as heatmap.
+
+    Creates a timeline showing when entities transition between quadrants,
+    color-coded by risk level.
+
+    Args:
+        transitions_df: DataFrame from extract_transitions()
+                       Required columns: entity, transition_quarter, from_quadrant,
+                       to_quadrant, risk_level
+        entity_filter: Optional list of entities to include
+        highlight_risk_levels: Risk levels to highlight (default: critical, high)
+        filter_risk_levels: Only show these risk levels (default: critical, high, medium)
+        max_entities: Maximum entities to display (default: 20)
+        figsize: Figure size (width, height)
+        title: Optional custom title
+        x_axis_granularity: Time grouping ('quarterly', 'semiannual', 'yearly')
+        sort_by_risk_first: Sort by risk level first (True) or count first (False)
+        entity_name: Name for y-axis label
+        show_all_periods: Include starting period even if no transitions
+        save_plot: Save plot to file
+        save_csv: Save data to CSV
+        output_dir: Output directory for saved files
+        temporal_granularity: Time granularity for file naming
+
+    Returns:
+        Matplotlib figure
+
+    Examples:
+        >>> # basic timeline
+        >>> fig = plot_transition_timeline(transitions_df, entity_name="Service")
+
+        >>> # focus on critical transitions only
+        >>> fig = plot_transition_timeline(
+        ...     transitions_df,
+        ...     filter_risk_levels=["critical"],
+        ...     max_entities=10
+        ... )
+    """
+    if transitions_df.empty:
+        print("No transitions to visualize")
+        return None
+
+    # filter out invalid entities
+    df = transitions_df[
+        transitions_df["entity"].notna() & (transitions_df["entity"] != "nan")
+    ].copy()
+
+    if df.empty:
+        print("No valid transitions to visualize")
+        return None
+
+    # filter by risk levels
+    if filter_risk_levels:
+        df = df[df["risk_level"].isin(filter_risk_levels)]
+        if df.empty:
+            print(f"No transitions with risk levels: {filter_risk_levels}")
+            return None
+
+    # apply entity filter
+    if entity_filter:
+        df = df[df["entity"].isin(entity_filter)]
+
+    # map risk levels to numeric order
+    risk_order = {"critical": 0, "high": 1, "medium": 2, "low": 3}
+    df["risk_order"] = df["risk_level"].map(risk_order)
+
+    # aggregate quarters based on granularity
+    if x_axis_granularity == "semiannual":
+        def quarter_to_semester(q_str):
+            if "-Q" in q_str:
+                year, quarter = q_str.split("-Q")
+                semester = "H1" if int(quarter) <= 2 else "H2"
+                return f"{year}-{semester}"
+            return q_str
+        df["period"] = df["transition_quarter"].apply(quarter_to_semester)
+    elif x_axis_granularity == "yearly":
+        def quarter_to_year(q_str):
+            if "-Q" in q_str:
+                return q_str.split("-Q")[0]
+            return q_str
+        df["period"] = df["transition_quarter"].apply(quarter_to_year)
+    else:  # quarterly
+        df["period"] = df["transition_quarter"]
+
+    periods = sorted(df["period"].unique())
+
+    # add starting period if requested
+    if show_all_periods and len(periods) > 0:
+        first_period = periods[0]
+        if x_axis_granularity == "semiannual" and "-H" in first_period:
+            year, semester = first_period.split("-H")
+            prev_semester = "H1" if semester == "H2" else "H2"
+            prev_year = str(int(year) - 1) if prev_semester == "H2" else year
+            prev_period = f"{prev_year}-{prev_semester}"
+            if prev_period not in periods:
+                periods = [prev_period] + periods
+        elif x_axis_granularity == "quarterly" and "-Q" in first_period:
+            year, quarter = first_period.split("-Q")
+            prev_q = str((int(quarter) - 2) % 4 + 1)
+            prev_year = year if int(quarter) > 1 else str(int(year) - 1)
+            prev_period = f"{prev_year}-Q{prev_q}"
+            if prev_period not in periods:
+                periods = [prev_period] + periods
+
+    # sort entities by priority
+    if sort_by_risk_first:
+        # sort by: most recent activity, then risk level
+        entity_max_period = df.groupby("entity")["period"].max()
+        period_rank = {p: i for i, p in enumerate(periods)}
+        entity_priority = pd.DataFrame({
+            "latest_period": entity_max_period,
+            "period_rank": entity_max_period.map(period_rank),
+        })
+
+        # get risk level in most recent period
+        def get_latest_risk(entity):
+            latest_p = entity_priority.loc[entity, "latest_period"]
+            entity_trans = df[(df["entity"] == entity) & (df["period"] == latest_p)]
+            return entity_trans["risk_order"].min() if len(entity_trans) > 0 else 99
+
+        entity_priority["risk_order"] = entity_priority.index.map(get_latest_risk)
+        entity_priority = entity_priority.sort_values(
+            ["period_rank", "risk_order"],
+            ascending=[False, True]
+        )
+    else:
+        # sort by count/volume
+        entity_priority = df.groupby("entity").agg({"risk_order": "min"})
+        entity_priority = entity_priority.sort_values("risk_order")
+
+    # limit to top N entities
+    if max_entities and len(entity_priority) > max_entities:
+        top_entities = entity_priority.head(max_entities).index.tolist()
+        df = df[df["entity"].isin(top_entities)]
+        entity_priority = entity_priority.loc[top_entities]
+
+    # get entities in priority order
+    entities = [e for e in entity_priority.index if e in df["entity"].values]
+
+    # create y-axis positions
+    y_positions = {entity: i for i, entity in enumerate(entities)}
+
+    # color map for risk levels
+    risk_colors = {
+        "critical": "#d62728",  # red
+        "high": "#ff7f0e",      # orange
+        "medium": "#ffdd57",    # yellow
+        "low": "#2ca02c",       # green
+    }
+
+    # create figure
+    fig, ax = plt.subplots(figsize=figsize)
+
+    # plot transitions
+    for _, transition in df.iterrows():
+        y_pos = y_positions[transition["entity"]]
+        x_pos = periods.index(transition["period"])
+
+        color = risk_colors.get(transition["risk_level"], "#95a5a6")
+
+        # plot circle
+        ax.scatter(x_pos, y_pos, s=100, c=color, alpha=0.8, zorder=2)
+
+        # add transition label
+        label = f"{transition['from_quadrant']}->{transition['to_quadrant']}"
+        ax.annotate(
+            label,
+            (x_pos, y_pos),
+            xytext=(8, 0),
+            textcoords="offset points",
+            fontsize=9,
+            color="black",
+            va="center",
+            alpha=0.8,
+        )
+
+    # customize plot
+    ax.set_yticks(range(len(entities)))
+    ax.set_yticklabels(entities)
+    ax.invert_yaxis()  # highest priority at top
+
+    # x-axis labels
+    if x_axis_granularity == "quarterly":
+        quarter_to_month = {"Q1": "Mar", "Q2": "Jun", "Q3": "Sep", "Q4": "Dec"}
+        period_labels = []
+        for p in periods:
+            if "-Q" in p:
+                year, quarter = p.split("-Q")
+                month = quarter_to_month.get(f"Q{quarter}", quarter)
+                period_labels.append(f"{month} {year}")
+            else:
+                period_labels.append(p)
+    elif x_axis_granularity == "semiannual":
+        period_labels = []
+        for p in periods:
+            if "-H" in p:
+                year, semester = p.split("-H")
+                period_labels.append(f"H{semester} {year}")
+            else:
+                period_labels.append(p)
+    else:  # yearly
+        period_labels = periods
+
+    ax.set_xticks(range(len(periods)))
+    ax.set_xticklabels(period_labels, rotation=45, ha="right")
+    ax.set_xlim(-0.5, len(periods) - 0.5)
+
+    # clean up borders
+    ax.spines["left"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    ax.spines["top"].set_visible(False)
+
+    # build legend
+    legend_elements = []
+    for risk_level in ["critical", "high", "medium", "low"]:
+        if risk_level in df["risk_level"].values:
+            legend_elements.append(
+                plt.scatter([], [], s=100, c=risk_colors[risk_level],
+                           alpha=0.8, label=risk_level.capitalize())
+            )
+
+    if legend_elements:
+        ax.legend(
+            handles=legend_elements,
+            loc="center left",
+            bbox_to_anchor=(1.02, 0.5),
+            title="Risk Level",
+            fontsize=10,
+            title_fontsize=11,
+            frameon=False,
+        )
+
+    # set labels
+    xlabel_map = {"quarterly": "Quarter", "semiannual": "Semester", "yearly": "Year"}
+    ax.set_xlabel(xlabel_map.get(x_axis_granularity, "Period"), fontsize=13)
+    ax.set_ylabel(entity_name, fontsize=13)
+
+    if title:
+        ax.set_title(title, fontsize=14, fontweight="bold", pad=20)
+
+    ax.tick_params(axis='both', which='major', labelsize=10)
+    plt.tight_layout()
+
+    # save plot if requested
+    if save_plot:
+        import os
+        from datetime import datetime
+
+        os.makedirs(output_dir, exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d")
+        granularity_suffix = {
+            "quarterly": "Q",
+            "yearly": "Y",
+            "semiannual": "S",
+        }.get(temporal_granularity, "Q")
+        plot_path = f"{output_dir}/transitions-{entity_name.lower()}-{granularity_suffix}-{timestamp}.png"
+        plt.savefig(plot_path, dpi=300, bbox_inches="tight", format="png")
+        print(f"Transition plot saved: {plot_path}")
+
+    # save CSV if requested
+    if save_csv:
+        import os
+        from datetime import datetime
+
+        os.makedirs(f"{output_dir}/../results", exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d")
+        granularity_suffix = {
+            "quarterly": "Q",
+            "yearly": "Y",
+            "semiannual": "S",
+        }.get(temporal_granularity, "Q")
+        csv_path = f"{output_dir}/../results/transitions-{entity_name.lower()}-{granularity_suffix}-{timestamp}.csv"
+        df.to_csv(csv_path, index=False)
+        print(f"Transitions CSV saved: {csv_path}")
+
+    return fig

priorityx/viz/trajectory.py

@@ -0,0 +1,231 @@
+"""Entity movement trajectory plots."""
+
+from typing import List, Optional, Tuple
+
+import matplotlib.pyplot as plt
+import pandas as pd
+
+
+def plot_movement_trajectories(
+    movement_df: pd.DataFrame,
+    entity_name: str = "Entity",
+    highlight_entities: Optional[List[str]] = None,
+    max_entities: int = 10,
+    figsize: Tuple[int, int] = (14, 10),
+    title: Optional[str] = None,
+    save_plot: bool = True,
+    output_dir: str = "plot",
+    temporal_granularity: str = "quarterly",
+) -> plt.Figure:
+    """
+    Visualize entity trajectories through priority space.
+
+    Shows how entities move through (X, Y) coordinates over time,
+    with arrows indicating direction and markers for start/end points.
+
+    Args:
+        movement_df: DataFrame from track_cumulative_movement()
+                    Required columns: entity, quarter, period_x, period_y,
+                    period_quadrant, global_quadrant
+        entity_name: Name for entity type (default: "Entity")
+        highlight_entities: Specific entities to highlight (default: None = auto-select)
+        max_entities: Maximum entities to show (default: 10)
+        figsize: Figure size (width, height)
+        title: Optional custom title
+        save_plot: Save plot to file
+        output_dir: Output directory for saved files
+        temporal_granularity: Time granularity for file naming
+
+    Returns:
+        Matplotlib figure
+
+    Examples:
+        >>> # auto-select top movers
+        >>> fig = plot_movement_trajectories(movement_df, entity_name="Service")
+
+        >>> # highlight specific entities
+        >>> fig = plot_movement_trajectories(
+        ...     movement_df,
+        ...     highlight_entities=["Service A", "Service B"],
+        ...     max_entities=5
+        ... )
+    """
+    if movement_df.empty:
+        print("No movement data to visualize")
+        return None
+
+    # select entities to plot
+    if highlight_entities:
+        entities_to_plot = [
+            e for e in highlight_entities if e in movement_df["entity"].values
+        ]
+    else:
+        # select entities with largest movements
+        entity_movement = movement_df.groupby("entity").agg({
+            "x_delta": lambda x: abs(x).sum(),
+            "y_delta": lambda x: abs(x).sum(),
+        })
+        entity_movement["total_movement"] = (
+            entity_movement["x_delta"] + entity_movement["y_delta"]
+        )
+        top_movers = entity_movement.nlargest(max_entities, "total_movement")
+        entities_to_plot = top_movers.index.tolist()
+
+    # filter movement data
+    df_plot = movement_df[movement_df["entity"].isin(entities_to_plot)].copy()
+
+    if df_plot.empty:
+        print("No entities to plot")
+        return None
+
+    # create figure
+    fig, ax = plt.subplots(figsize=figsize)
+
+    # define colors for quadrants
+    colors = {
+        "Q1": "#c2104b",  # red - crisis
+        "Q2": "#FF9636",  # orange - investigate
+        "Q3": "#5cb85c",  # green - monitor
+        "Q4": "#792f88",  # purple - low priority
+    }
+
+    # plot trajectories for each entity
+    for entity in entities_to_plot:
+        entity_data = df_plot[df_plot["entity"] == entity].sort_values("quarter")
+
+        if len(entity_data) < 2:
+            continue
+
+        # get trajectory coordinates
+        x = entity_data["period_x"].values
+        y = entity_data["period_y"].values
+
+        # get color from global quadrant
+        global_quad = entity_data.iloc[0]["global_quadrant"]
+        color = colors.get(global_quad, "#95a5a6")
+
+        # plot trajectory line
+        ax.plot(x, y, color=color, alpha=0.5, linewidth=2, zorder=1)
+
+        # add arrows
+        for i in range(len(x) - 1):
+            dx = x[i + 1] - x[i]
+            dy = y[i + 1] - y[i]
+            ax.arrow(
+                x[i], y[i], dx * 0.9, dy * 0.9,
+                head_width=0.1,
+                head_length=0.1,
+                fc=color,
+                ec=color,
+                alpha=0.6,
+                zorder=2,
+            )
+
+        # mark start point (circle)
+        ax.scatter(
+            x[0], y[0],
+            s=150,
+            c=color,
+            marker='o',
+            edgecolors='black',
+            linewidth=2,
+            alpha=0.8,
+            zorder=3,
+        )
+
+        # mark end point (square)
+        ax.scatter(
+            x[-1], y[-1],
+            s=150,
+            c=color,
+            marker='s',
+            edgecolors='black',
+            linewidth=2,
+            alpha=0.8,
+            zorder=3,
+        )
+
+        # add entity label at end point
+        ax.annotate(
+            entity,
+            (x[-1], y[-1]),
+            xytext=(5, 5),
+            textcoords="offset points",
+            fontsize=10,
+            color=color,
+            fontweight='bold',
+            alpha=0.9,
+        )
+
+    # add quadrant dividers
+    ax.axhline(0, color='grey', linestyle='--', alpha=0.7, linewidth=1, zorder=0)
+    ax.axvline(0, color='grey', linestyle='--', alpha=0.7, linewidth=1, zorder=0)
+
+    # add quadrant labels
+    xlim = ax.get_xlim()
+    ylim = ax.get_ylim()
+
+    quadrant_labels = {
+        "Q1": ("Q1: Critical", (xlim[1] * 0.9, ylim[1] * 0.9)),
+        "Q2": ("Q2: Investigate", (xlim[0] * 0.9, ylim[1] * 0.9)),
+        "Q3": ("Q3: Monitor", (xlim[0] * 0.9, ylim[0] * 0.9)),
+        "Q4": ("Q4: Low Priority", (xlim[1] * 0.9, ylim[0] * 0.9)),
+    }
+
+    for label, (x_pos, y_pos) in quadrant_labels.values():
+        ax.text(
+            x_pos, y_pos,
+            label,
+            ha="center",
+            va="center",
+            fontsize=12,
+            color="gray",
+            alpha=0.3,
+            fontweight="bold",
+            zorder=0,
+        )
+
+    # set labels
+    ax.set_xlabel(f"{entity_name} Volume (Relative)", fontsize=13)
+    ax.set_ylabel(f"{entity_name} Growth Rate (Relative)", fontsize=13)
+
+    if title:
+        ax.set_title(title, fontsize=16, fontweight="bold", pad=20)
+    else:
+        ax.set_title(f"{entity_name} Movement Trajectories", fontsize=16,
+                    fontweight="bold", pad=20)
+
+    # add legend for markers
+    from matplotlib.lines import Line2D
+    marker_legend = [
+        Line2D([0], [0], marker='o', color='w', markerfacecolor='gray',
+               markersize=10, label='Start', markeredgecolor='black', markeredgewidth=2),
+        Line2D([0], [0], marker='s', color='w', markerfacecolor='gray',
+               markersize=10, label='End', markeredgecolor='black', markeredgewidth=2),
+    ]
+    ax.legend(
+        handles=marker_legend,
+        loc='upper left',
+        frameon=False,
+        fontsize=10,
+    )
+
+    plt.tight_layout()
+
+    # save plot if requested
+    if save_plot:
+        import os
+        from datetime import datetime
+
+        os.makedirs(output_dir, exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d")
+        granularity_suffix = {
+            "quarterly": "Q",
+            "yearly": "Y",
+            "semiannual": "S",
+        }.get(temporal_granularity, "Q")
+        plot_path = f"{output_dir}/cumulative_movement-{entity_name.lower()}-{granularity_suffix}-{timestamp}.png"
+        plt.savefig(plot_path, dpi=300, bbox_inches="tight", format="png")
+        print(f"Movement plot saved: {plot_path}")
+
+    return fig

priorityx-0.1.2.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: priorityx
+Version: 0.1.2
+Summary: Entity prioritization and escalation detection using GLMM statistical models
+Project-URL: Homepage, https://github.com/okkymabruri/priorityx
+Project-URL: Repository, https://github.com/okkymabruri/priorityx
+Project-URL: Issues, https://github.com/okkymabruri/priorityx/issues
+Author-email: Okky Mabruri <okkymbrur@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: escalation-detection,glmm,prioritization,risk-analysis,statistical-modeling
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: adjusttext>=1.3.0
+Requires-Dist: matplotlib>=3.9.4
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: polars>=1.35.1
+Requires-Dist: pyarrow>=21.0.0
+Requires-Dist: statsmodels>=0.14.5
+Description-Content-Type: text/markdown
+
+# Priorityx: Entity prioritization and escalation detection using GLMM statistical models
+
+## Installation
+
+```bash
+pip install priorityx
+```
+
+## Quick Start
+
+```python
+import polars as pl
+from priorityx.core.glmm import fit_priority_matrix
+from priorityx.viz.matrix import plot_priority_matrix
+
+df = pl.read_csv("data.csv")
+
+results, stats = fit_priority_matrix(
+    df,
+    entity_col="service",
+    timestamp_col="date",
+    temporal_granularity="quarterly"
+)
+
+plot_priority_matrix(results, entity_name="Service", save_plot=True)
+```
+
+## Features
+
+- GLMM-based priority classification (Q1-Q4 quadrants)
+- Transition detection over time
+- Movement tracking
+- Visualization
+
+## Use Cases
+
+IT incidents, software bugs, compliance violations, performance monitoring.
+
+## Documentation
+
+- [Quick Start](docs/quickstart.md)
+- [API Reference](docs/api-reference.md)
+- [Methodology](docs/methodology.md)

priorityx-0.1.2.dist-info/RECORD

@@ -0,0 +1,20 @@
+priorityx/__init__.py,sha256=oaQkbWhGBsq0j9arjJdAF14BPe9Jm2dUEyDm3Sgnlko,169
+priorityx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+priorityx/core/filters.py,sha256=RH6bqep8sFIQ346s77Hm-vyJ3Z4lya5qRjXRUcAOXpU,7329
+priorityx/core/glmm.py,sha256=x-qdCdz2Hp4C8FVGO_Or_CBh6n06h2bCFSVaGMyXhNY,13603
+priorityx/core/quadrants.py,sha256=BuHxeD6k-_6GJkbvU59eoW81UzVi1YnMl6evLyf38ks,1910
+priorityx/drivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+priorityx/tracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+priorityx/tracking/drivers.py,sha256=f3-ia36uCFWn4yLDFAqi5re6STmJNXF15luBP1hwH1k,19045
+priorityx/tracking/movement.py,sha256=bqFq0kJjuqxCNkyp1Vr9b2Ed62JVzxaSKOfV7u0iDD0,16580
+priorityx/tracking/transitions.py,sha256=b6r8Bj8i1_N_iUomn-8K162i0k_xdlnNZV48uMKj1Iw,8668
+priorityx/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+priorityx/utils/helpers.py,sha256=yA5mgCCv34MwLSec72PrX1PJY5jt8kN3oZVu6DHKhtQ,7380
+priorityx/viz/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+priorityx/viz/matrix.py,sha256=s5WZ0UWirlau7CpQctVhTNVqd7DXvL5nr3ekZUmuXUs,10413
+priorityx/viz/timeline.py,sha256=-KZ3VM5URRspQbP77HGeLfvV9aEzji8ar2EGN-FxDNo,11039
+priorityx/viz/trajectory.py,sha256=EQ42W5XyFwq7LcCTiWSDZzdW4t5FiDXAWbHD2_K6-Ic,7218
+priorityx-0.1.2.dist-info/METADATA,sha256=bEYIgPOuJWqOZe5XsdaQdro6kTozvA5zCltp5WCOsHg,2167
+priorityx-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+priorityx-0.1.2.dist-info/licenses/LICENSE,sha256=653HZgD9wm-uBS8gPWzbTbA4BYPoApwTdRNK-0tbagw,1069
+priorityx-0.1.2.dist-info/RECORD,,

priorityx-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

priorityx-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Okky Mabruri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.