walopy 0.2.1__py3-none-any.whl

walopy/__init__.py

@@ -0,0 +1,162 @@
+"""walopy — Queuing theory, operations analysis and KPI trees for Python."""
+from __future__ import annotations
+
+# Queuing
+from .queuing import (
+    QueueResult,
+    littles_law,
+    mm1,
+    mmc,
+    md1,
+    kingman,
+)
+
+# Operations
+from .operations import (
+    OEEResult,
+    UtilizationResult,
+    UnitCostResult,
+    oee,
+    utilization_efficiency,
+    unit_cost,
+)
+
+# Bottleneck
+from .bottleneck import (
+    BottleneckResult,
+    StationResult,
+    bottleneck_analysis,
+)
+
+# KPI trees
+from .kpi import (
+    KPINode,
+    oee_kpi_tree,
+    throughput_kpi_tree,
+    roi_kpi_tree,
+)
+
+# Solvers
+from .solver import (
+    SolverResult,
+    OptimizeResult,
+    solve_lam,
+    solve_mu,
+    solve_servers,
+    optimize_servers,
+    sensitivity,
+    batch_model,
+    compare,
+)
+
+# Advanced models
+from .advanced import (
+    SimulationResult,
+    LineBalanceResult,
+    BreakEvenResult,
+    PriorityQueueResult,
+    erlang_b,
+    mm1k,
+    mmck,
+    mm1_priority,
+    monte_carlo_gg1,
+    takt_time,
+    line_balance,
+    break_even,
+    queue_length_pmf,
+    sojourn_cdf,
+)
+
+# Fitting
+from .fitting import (
+    FitResult,
+    fit_from_data,
+)
+
+# Inventory
+from .inventory import (
+    EOQResult,
+    ReorderResult,
+    NewsvendorResult,
+    eoq,
+    reorder_point,
+    newsvendor,
+)
+
+# Network
+from .network import (
+    StationMetrics,
+    JacksonResult,
+    jackson_network,
+)
+
+from importlib.metadata import version, PackageNotFoundError
+try:
+    __version__: str = version("walopy")
+except PackageNotFoundError:
+    __version__ = "0.2.0"  # fallback when running from source without install
+
+__all__ = [
+    # queuing
+    "QueueResult",
+    "littles_law",
+    "mm1",
+    "mmc",
+    "md1",
+    "kingman",
+    # operations
+    "OEEResult",
+    "UtilizationResult",
+    "UnitCostResult",
+    "oee",
+    "utilization_efficiency",
+    "unit_cost",
+    # bottleneck
+    "BottleneckResult",
+    "StationResult",
+    "bottleneck_analysis",
+    # kpi
+    "KPINode",
+    "oee_kpi_tree",
+    "throughput_kpi_tree",
+    "roi_kpi_tree",
+    # solver
+    "SolverResult",
+    "OptimizeResult",
+    "solve_lam",
+    "solve_mu",
+    "solve_servers",
+    "optimize_servers",
+    "sensitivity",
+    "batch_model",
+    "compare",
+    # advanced
+    "SimulationResult",
+    "LineBalanceResult",
+    "BreakEvenResult",
+    "PriorityQueueResult",
+    "erlang_b",
+    "mm1k",
+    "mmck",
+    "mm1_priority",
+    "monte_carlo_gg1",
+    "takt_time",
+    "line_balance",
+    "break_even",
+    "queue_length_pmf",
+    "sojourn_cdf",
+    # fitting
+    "FitResult",
+    "fit_from_data",
+    # inventory
+    "EOQResult",
+    "ReorderResult",
+    "NewsvendorResult",
+    "eoq",
+    "reorder_point",
+    "newsvendor",
+    # network
+    "StationMetrics",
+    "JacksonResult",
+    "jackson_network",
+]

walopy/__main__.py

@@ -0,0 +1,101 @@
+"""CLI entry point: python -m walopy [--version] <model> [params]"""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from . import __version__
+
+
+def _add_lam_mu(p: argparse.ArgumentParser) -> None:
+    p.add_argument("--lam", type=float, required=True, metavar="LAM",
+                   help="Arrival rate λ")
+    p.add_argument("--mu", type=float, required=True, metavar="MU",
+                   help="Service rate μ per server")
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="walopy",
+        description="Queuing theory and operations analysis toolkit.",
+    )
+    parser.add_argument("--version", action="version", version=f"walopy {__version__}")
+
+    sub = parser.add_subparsers(dest="model", metavar="MODEL")
+
+    # --- mm1 ---
+    p1 = sub.add_parser("mm1", help="M/M/1 single-server queue")
+    _add_lam_mu(p1)
+
+    # --- mmc ---
+    pc = sub.add_parser("mmc", help="M/M/c multi-server queue")
+    _add_lam_mu(pc)
+    pc.add_argument("--c", type=int, required=True, metavar="C", help="Number of servers")
+
+    # --- md1 ---
+    pd1 = sub.add_parser("md1", help="M/D/1 deterministic service queue")
+    _add_lam_mu(pd1)
+
+    # --- gg1 ---
+    pg = sub.add_parser("gg1", help="G/G/1 Kingman approximation")
+    _add_lam_mu(pg)
+    pg.add_argument("--ca2", type=float, required=True, metavar="CA2",
+                    help="Squared CV of inter-arrival times")
+    pg.add_argument("--cs2", type=float, required=True, metavar="CS2",
+                    help="Squared CV of service times")
+
+    # --- littles ---
+    pl = sub.add_parser("littles", help="Solve Little's Law for the missing variable")
+    pl.add_argument("--L",   type=float, default=None, metavar="L")
+    pl.add_argument("--lam", type=float, default=None, metavar="LAM")
+    pl.add_argument("--W",   type=float, default=None, metavar="W")
+
+    # --- eoq ---
+    pe = sub.add_parser("eoq", help="Economic Order Quantity")
+    pe.add_argument("--demand",   type=float, required=True, metavar="D",
+                    help="Demand rate (units/period)")
+    pe.add_argument("--ordering", type=float, required=True, metavar="K",
+                    help="Fixed cost per order")
+    pe.add_argument("--holding",  type=float, required=True, metavar="H",
+                    help="Holding cost per unit per period")
+
+    args = parser.parse_args(argv)
+
+    if args.model is None:
+        parser.print_help()
+        sys.exit(0)
+
+    try:
+        if args.model == "mm1":
+            from .queuing import mm1
+            print(mm1(args.lam, args.mu).summary())
+
+        elif args.model == "mmc":
+            from .queuing import mmc
+            print(mmc(args.lam, args.mu, args.c).summary())
+
+        elif args.model == "md1":
+            from .queuing import md1
+            print(md1(args.lam, args.mu).summary())
+
+        elif args.model == "gg1":
+            from .queuing import kingman
+            print(kingman(args.lam, args.mu, args.ca2, args.cs2).summary())
+
+        elif args.model == "littles":
+            from .queuing import littles_law
+            result = littles_law(L=args.L, lam=args.lam, W=args.W)
+            missing = [k for k, v in {"L": args.L, "lam": args.lam, "W": args.W}.items() if v is None]
+            print(f"{missing[0]} = {result:.6g}")
+
+        elif args.model == "eoq":
+            from .inventory import eoq
+            print(eoq(args.demand, args.ordering, args.holding).summary())
+
+    except (ValueError, TypeError) as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

walopy/_utils.py

@@ -0,0 +1,67 @@
+"""Internal validation helpers."""
+from __future__ import annotations
+
+import numpy as np
+
+
+def as_positive(value: float, name: str) -> float:
+    """Validate that a scalar is finite and strictly positive."""
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        raise TypeError(f"'{name}' must be a number, got {type(value).__name__!r}.")
+    if not np.isfinite(v) or v <= 0:
+        raise ValueError(f"'{name}' must be a finite positive number, got {value!r}.")
+    return v
+
+
+def as_nonneg(value: float, name: str) -> float:
+    """Validate that a scalar is finite and non-negative."""
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        raise TypeError(f"'{name}' must be a number, got {type(value).__name__!r}.")
+    if not np.isfinite(v) or v < 0:
+        raise ValueError(f"'{name}' must be finite and >= 0, got {value!r}.")
+    return v
+
+
+def as_fraction(value: float, name: str) -> float:
+    """Validate that a scalar is in [0, 1]."""
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        raise TypeError(f"'{name}' must be a number, got {type(value).__name__!r}.")
+    if not np.isfinite(v) or not (0.0 <= v <= 1.0):
+        raise ValueError(f"'{name}' must be a finite value in [0, 1], got {value!r}.")
+    return v
+
+
+def as_int_positive(value: int, name: str) -> int:
+    """Validate that a value is a positive integer (accepts numpy integer types)."""
+    # Accept Python int and numpy integer scalars; reject float (even 2.0)
+    if not isinstance(value, (int, np.integer)):
+        raise TypeError(
+            f"'{name}' must be a positive integer, got {type(value).__name__!r} = {value!r}."
+        )
+    v = int(value)
+    if v < 1:
+        raise ValueError(f"'{name}' must be >= 1, got {value!r}.")
+    return v
+
+
+def as_nonempty(seq: list, name: str) -> None:
+    """Raise ValueError if sequence is empty."""
+    if len(seq) == 0:
+        raise ValueError(f"'{name}' must contain at least one element.")
+
+
+def as_finite_scalar(value: float, name: str) -> float:
+    """Accept any finite real number (positive, zero, or negative)."""
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        raise TypeError(f"'{name}' must be a number, got {type(value).__name__!r}.")
+    if not np.isfinite(v):
+        raise ValueError(f"'{name}' must be a finite number, got {value!r}.")
+    return v