most-queue 2.7__tar.gz → 2.8__tar.gz

most_queue-2.8/.claude/skills/lit-search/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: lit-search
+description: Поиск научной литературы по теории очередей (arXiv + OpenAlex + Crossref) для работ над most_queue. Use when searching for queueing theory papers, verifying references, or doing gap-analysis of models (EPIC-001 and beyond).
+---
+
+# Поиск литературы для most_queue
+
+## Быстрый поиск по трём базам
+
+```bash
+python .claude/skills/lit-search/lit_search.py "<запрос>" --max 10
+```
+
+Опрашивает arXiv API, OpenAlex и Crossref (все бесплатные, без ключей), дедуплицирует по
+названию и печатает markdown-таблицу, отсортированную по цитируемости. Опции:
+`--source arxiv|openalex|crossref|all`, `--abstracts` (аннотации, только arXiv).
+
+## Что чем искать
+
+- **OpenAlex** — основной источник: покрывает журналы (Operations Research, Queueing Systems,
+  Performance Evaluation), даёт цитируемость и DOI. Классика теории очередей — здесь.
+- **Crossref** — проверка/уточнение DOI и метаданных, широкий охват.
+- **arXiv** — свежие препринты (категории math.PR, cs.PF); единственный источник с аннотациями
+  и бесплатными PDF: `https://arxiv.org/pdf/<id>`.
+- **WebSearch/WebFetch** — обзорный поиск, страницы авторов, лекционные заметки
+  (например, Harchol-Balter публикует главы книг у себя на сайте).
+- **Semantic Scholar API** — без ключа почти всегда 429, не использовать.
+
+## Куда складывать найденное
+
+- PDF первоисточников → `docs/статьи/` (используемые в документации) или `works/articles/`.
+- Конспекты → `works/queueing_systems_review/<тема>/`.
+- Ссылки в roadmap/эпике оформлять как «Автор, Название, Журнал, Год, DOI».
+
+## Чтение PDF
+
+arXiv PDF скачивать в scratchpad (`curl -L -o`), читать инструментом Read (постранично) или
+скиллом pdf. Платные журнальные PDF недоступны — искать препринт на arXiv/author page через
+WebSearch или опираться на конспекты в `works/`.

most_queue-2.8/.claude/skills/lit-search/lit_search.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Literature search helper: queries arXiv, OpenAlex and Crossref, prints a markdown table.
+
+Usage:
+    python lit_search.py "retrial queue M/G/1" [--max 10] [--source arxiv|openalex|crossref|all]
+    python lit_search.py "MAP/PH/1" --max 5 --abstracts
+
+Only stdlib is used. All APIs are free and keyless.
+"""
+
+import argparse
+import json
+import sys
+import time
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+
+UA = {"User-Agent": "most-queue-lit-search/1.0 (mailto:xabarov1985@gmail.com)"}
+
+
+def _get(url: str) -> bytes:
+    req = urllib.request.Request(url, headers=UA)
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        return resp.read()
+
+
+def search_arxiv(query: str, limit: int) -> list[dict]:
+    """Search arXiv Atom API, return normalized result dicts."""
+    q = urllib.parse.quote(f'all:"{query}"' if " " in query else f"all:{query}")
+    url = f"https://export.arxiv.org/api/query?search_query={q}&start=0&max_results={limit}&sortBy=relevance"
+    ns = {"a": "http://www.w3.org/2005/Atom"}
+    root = ET.fromstring(_get(url))
+    out = []
+    for e in root.findall("a:entry", ns):
+        out.append(
+            {
+                "source": "arxiv",
+                "title": " ".join((e.findtext("a:title", "", ns) or "").split()),
+                "year": (e.findtext("a:published", "", ns) or "")[:4],
+                "venue": "arXiv",
+                "citations": None,
+                "id": (e.findtext("a:id", "", ns) or "").replace("http://arxiv.org/abs/", "arXiv:"),
+                "abstract": " ".join((e.findtext("a:summary", "", ns) or "").split()),
+            }
+        )
+    return out
+
+
+def search_openalex(query: str, limit: int) -> list[dict]:
+    """Search OpenAlex works API, return normalized result dicts."""
+    q = urllib.parse.quote(query)
+    url = (
+        f"https://api.openalex.org/works?search={q}&per-page={limit}"
+        "&select=title,publication_year,doi,cited_by_count,primary_location&sort=relevance_score:desc"
+    )
+    data = json.loads(_get(url))
+    out = []
+    for w in data.get("results", []):
+        loc = w.get("primary_location") or {}
+        src = (loc.get("source") or {}).get("display_name") or ""
+        out.append(
+            {
+                "source": "openalex",
+                "title": w.get("title") or "",
+                "year": str(w.get("publication_year") or ""),
+                "venue": src,
+                "citations": w.get("cited_by_count"),
+                "id": (w.get("doi") or "").replace("https://doi.org/", "doi:"),
+                "abstract": "",
+            }
+        )
+    return out
+
+
+def search_crossref(query: str, limit: int) -> list[dict]:
+    """Search Crossref works API, return normalized result dicts."""
+    q = urllib.parse.quote(query)
+    url = (
+        f"https://api.crossref.org/works?query={q}&rows={limit}"
+        "&select=title,DOI,is-referenced-by-count,container-title,published"
+    )
+    data = json.loads(_get(url))
+    out = []
+    for w in data.get("message", {}).get("items", []):
+        pub = w.get("published", {}).get("date-parts", [[None]])
+        out.append(
+            {
+                "source": "crossref",
+                "title": (w.get("title") or [""])[0],
+                "year": str(pub[0][0] or ""),
+                "venue": (w.get("container-title") or [""])[0],
+                "citations": w.get("is-referenced-by-count"),
+                "id": "doi:" + w.get("DOI", ""),
+                "abstract": "",
+            }
+        )
+    return out
+
+
+SOURCES = {"arxiv": search_arxiv, "openalex": search_openalex, "crossref": search_crossref}
+
+
+def main() -> None:
+    """CLI entry point: query sources, dedup, print markdown table."""
+    ap = argparse.ArgumentParser(description=(__doc__ or "").splitlines()[0])
+    ap.add_argument("query")
+    ap.add_argument("--max", type=int, default=10, dest="limit", help="results per source")
+    ap.add_argument("--source", default="all", choices=[*SOURCES, "all"])
+    ap.add_argument("--abstracts", action="store_true", help="print abstracts (arXiv only)")
+    args = ap.parse_args()
+
+    names = list(SOURCES) if args.source == "all" else [args.source]
+    rows = []
+    for name in names:
+        try:
+            rows += SOURCES[name](args.query, args.limit)
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            print(f"[warn] {name} failed: {exc}", file=sys.stderr)
+        time.sleep(0.5)
+
+    # dedup by normalized title, prefer entries with citation counts
+    seen: dict[str, dict] = {}
+    for r in rows:
+        key = "".join(ch for ch in r["title"].lower() if ch.isalnum())[:80]
+        if key not in seen or (r["citations"] or 0) > (seen[key]["citations"] or 0):
+            seen[key] = r
+    rows = sorted(seen.values(), key=lambda r: -(r["citations"] or 0))
+
+    print(f"## Результаты поиска: `{args.query}` ({len(rows)} уникальных)\n")
+    print("| Год | Название | Где | Цит. | ID | Источник |")
+    print("|-----|----------|-----|------|----|----------|")
+    for r in rows:
+        cit = "" if r["citations"] is None else str(r["citations"])
+        print(f"| {r['year']} | {r['title'][:100]} | {r['venue'][:40]} | {cit} | {r['id']} | {r['source']} |")
+
+    if args.abstracts:
+        for r in rows:
+            if r["abstract"]:
+                print(f"\n### {r['title']}\n{r['abstract']}")
+
+
+if __name__ == "__main__":
+    main()

most_queue-2.8/.cursor/rules/pytest-quality.mdc

@@ -0,0 +1,45 @@
+---
+description: Pytest quality standards � run after major edits, zero-tolerance failures, no silencing tricks
+globs: **/*.py
+alwaysApply: false
+---
+
+# Pytest Quality Standards
+
+## Run pytest after every significant code change
+
+After editing simulation core, theory calculators, or utils, run:
+
+```bash
+.venv/bin/pytest tests/ -q --tb=short
+```
+
+For quick feedback on a single changed file:
+
+```bash
+.venv/bin/pytest tests/units/test_<module>.py -q --tb=short
+```
+
+## Passing threshold
+
+All tests must pass. A session with any failures or errors is not acceptable.
+
+## Forbidden workarounds
+
+Never silence test failures with:
+
+- `# noqa`
+- `# type: ignore` (unless suppressing a genuine 3rd-party stub gap, not your code)
+- `@pytest.mark.skip` / `@pytest.mark.xfail` without an explanation comment and a linked issue
+- `filterwarnings = error` exceptions added silently
+- Lowering tolerances (`rtol`, `atol`) below what the theory supports just to make a test pass
+
+Fix the root cause instead.
+
+## Tolerance conventions (`default_params.yaml`)
+
+Simulation results are stochastic. Use the project tolerances from `tests/default_params.yaml`:
+- `MOMENTS_RTOL` � relative tolerance for moment comparisons
+- `MOMENTS_ATOL` � absolute tolerance fallback
+
+Do **not** tighten tolerances below these values without justifying with sample-size analysis.

most_queue-2.8/.cursor/rules/python-quality.mdc

@@ -0,0 +1,98 @@
+---
+description: Python code quality standards — pylint 10/10, docstrings, ASCII, type hints, no lazy imports
+globs: most_queue/**/*.py
+alwaysApply: false
+---
+
+# Python Code Quality Standards
+
+## Pylint target: 10.00/10
+
+After every substantive edit run pylint on changed files:
+
+```bash
+.venv/bin/pylint <changed_file_or_package> --score=yes
+```
+
+If score drops below 10.00, fix all reported issues before finishing.
+
+## Docstrings — required everywhere public
+
+Every public module, class, and method must have a docstring.
+Private helpers (`_name`) are exempt but encouraged.
+
+```python
+# BAD — missing docstring on public method
+def run(self) -> QueueResults:
+    ...
+
+# GOOD
+def run(self) -> QueueResults:
+    """Compute E[T] and E[W] averaged over the job-size distribution."""
+    ...
+```
+
+## ASCII-only source files
+
+Python source files must contain only ASCII characters.
+Use ASCII equivalents in docstrings and comments — never paste Unicode math symbols:
+
+| Instead of | Write |
+|---|---|
+| `ρ_x`, `λ`, `∫` | `rho_x`, `lam`, `int` |
+| `≥`, `≤` | `>=`, `<=` |
+| `→`, `—` | `->`, `--` |
+
+## No imports inside functions
+
+Lazy imports (`import` inside a function body) are forbidden.
+Move all imports to the module top level.
+
+```python
+# BAD
+def get_pdf(t):
+    from scipy.stats import norm  # C0415
+    return norm.pdf(t)
+
+# GOOD — import at module level
+from scipy.stats import norm
+
+def get_pdf(t):
+    return norm.pdf(t)
+```
+
+## Type hints on all public signatures
+
+```python
+# BAD
+def conditional_mean_response(self, x):
+    ...
+
+# GOOD
+def conditional_mean_response(self, x: float) -> float:
+    ...
+```
+
+## Distribution API consistency
+
+All `Distribution` subclasses in `most_queue.random.distributions` must
+expose `get_pdf(params, t: float) -> float` and `get_cdf(params, t: float) -> float`
+as static methods. Do **not** add private PDF/CDF helpers elsewhere — extend
+the distribution class instead.
+
+## No nested quadrature for repeated inner integrals
+
+When an inner integral appears inside an outer `quad` call, precompute it
+on a grid with `cumulative_trapezoid` + `np.interp` instead of calling
+`quad` again for every outer evaluation point.
+
+```python
+# BAD — O(n²) nested quad
+def outer(x_max):
+    quad(lambda x: f(x) * quad(lambda t: ..., 0, x)[0], 0, x_max)
+
+# GOOD — precompute grid, look up with np.interp
+grid_xs = np.linspace(0, x_max, 2000)
+grid_int = cumulative_trapezoid(integrand(grid_xs), grid_xs, initial=0)
+quad(lambda x: f(x) * np.interp(x, grid_xs, grid_int), 0, x_max)
+```

most_queue-2.8/.cursor/skills/add-theory-calculator/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: add-theory-calculator
+description: >-
+  Add a new analytical/numerical queueing-theory calculator to most-queue:
+  subclass BaseQueue, wire set_sources / set_servers, return QueueResults from
+  run(), reuse shared utilities, expose via theory/__init__.py. Use whenever the
+  user asks to implement a new theoretical model (M/G/1 variant, priority,
+  network, fork-join, vacations, �).
+---
+
+# Adding a Theory Calculator
+
+All analytical models in this repo follow the same contract. Stick to it so
+the calculator interoperates with `io.tables`, the test pattern (see skill
+`theory-vs-sim-test`), and downstream tooling.
+
+## Where to put the file
+
+| Model type | Directory |
+|------------|-----------|
+| Single class FIFO (M/G/1, GI/M/n, �) | `most_queue/theory/fifo/` |
+| Priorities | `most_queue/theory/priority/` |
+| Vacations / warm-up / cooling | `most_queue/theory/vacations/` |
+| Negative customers / disasters | `most_queue/theory/negative/` |
+| Fork�join | `most_queue/theory/fork_join/` |
+| Closed networks | `most_queue/theory/closed/` |
+| Open networks | `most_queue/theory/networks/` |
+| Impatience | `most_queue/theory/impatience/` |
+| Batch arrivals | `most_queue/theory/batch/` |
+| Size-based scheduling (SRPT/SJF/SPJF/�) | `most_queue/theory/srpt/` |
+
+## Required class skeleton
+
+```python
+from most_queue.structs import QueueResults
+from most_queue.theory.base_queue import BaseQueue
+
+
+class MyModelCalc(BaseQueue):
+    """One-line summary. Cite the source paper / formula in the docstring."""
+
+    def __init__(self, n: int = 1, calc_params=None, buffer=None):
+        super().__init__(n=n, calc_params=calc_params, buffer=buffer)
+        # model-specific state
+
+    def set_sources(self, ...):                   # accept ?, or (params, kendall)
+        ...
+        self.is_sources_set = True                # MUST set the flag
+
+    def set_servers(self, ...):                   # accept moments b, or (params, kendall)
+        ...
+        self.is_servers_set = True                # MUST set the flag
+
+    def get_w(self, num_of_moments: int = 4) -> list[float]: ...
+    def get_v(self, num_of_moments: int = 4) -> list[float]: ...
+    def get_p(self) -> list[float]: ...
+
+    def run(self, num_of_moments: int = 4) -> QueueResults:
+        self._check_if_servers_and_sources_set()
+        start = self._measure_time()
+
+        w = self.get_w(num_of_moments)
+        v = self.get_v(num_of_moments)
+        p = self.get_p()
+
+        result = QueueResults(v=v, w=w, p=p, utilization=<your ?>)
+        self._set_duration(result, start)
+        return result
+```
+
+## Conventions to follow
+
+1. **Set the flags.** `is_sources_set` / `is_servers_set` must be set to
+   `True` at the end of the corresponding setter � `_check_if_servers_and_sources_set`
+   relies on them.
+2. **Return RAW moments.** `w` and `v` are raw (non-central) moments; the test
+   pattern compares raw. If you compute centrals internally, convert via
+   `most_queue.theory.utils.moments`.
+3. **Always set `utilization`** on `QueueResults` � the standard test asserts
+   `abs(UTILIZATION_FACTOR - result.utilization) < PROBS_ATOL`.
+4. **Time the run.** Use `start = self._measure_time()` and
+   `self._set_duration(result, start)` � `io.tables` printers display this.
+5. **Return the right results dataclass:**
+   - `QueueResults` � single-class FIFO and most special models
+   - `PriorityResults` � priorities
+   - `NetworkResults` � networks
+   - `VacationResults` � vacations / warm-up / cooling
+   - `NegativeArrivalsResults` � negative customers / disasters
+
+## Reuse, don't reinvent
+
+Before writing math, check `most_queue/theory/utils/`:
+
+| Module | Use for |
+|--------|---------|
+| `utils/conv.py` (`conv_moments`) | Convolution of two moment sequences |
+| `utils/moments.py` | Raw ? central moments, factorial moments |
+| `utils/transforms.py` (`lst_exp`, `lst_h2`, `lst_gamma`, �) | Laplace�Stieltjes transforms |
+| `utils/busy_periods.py` | Busy-period moments via numerical differentiation of LST |
+| `utils/residual.py` | Residual service-time distributions |
+| `utils/flow_sum.py` | Combining renewal flows |
+| `utils/q_poisson_arrival_calc.py` | PASTA-style state probabilities |
+| `utils/conditional.py` | Conditional moments (e.g. `min(Exp, H2)`) |
+
+## Distribution interface (when you need a PDF/CDF or to align with sim)
+
+`most_queue.random.distributions` provides classes (Exp, H2, Gamma, Cox,
+Erlang, Pareto, Normal, �) with the contract:
+
+```python
+ClassDist.get_params_by_mean_and_cv(mean, cv)
+ClassDist.calc_theory_moments(params, k)        # first k raw moments
+inst = ClassDist(params, generator)
+inst.generate()                                 # sample one
+```
+
+Use this to keep the simulation and the theory aligned (see skill
+`theory-vs-sim-test`).
+
+## Checklist before opening a PR
+
+- [ ] Subclassed `BaseQueue`; both `is_*_set` flags set in setters
+- [ ] `run()` returns the appropriate dataclass with `utilization` and
+      `duration`
+- [ ] Reused `theory/utils/*` rather than reimplementing convolution / LST
+- [ ] Added `from .<module> import MyModelCalc` to `theory/__init__.py` if
+      the class is part of the public API
+- [ ] New test file in `tests/` following the `theory-vs-sim-test` skill
+- [ ] `pytest tests/` is fully green (see `.cursor/rules/pytest-quality.mdc`)
+- [ ] At least 2 distributions tested (e.g. Exp + H2 or Gamma)

most_queue-2.8/.cursor/skills/theory-vs-sim-test/SKILL.md

@@ -0,0 +1,122 @@
+---
+name: theory-vs-sim-test
+description: >-
+  Author or fix a sim-vs-theory pytest in most-queue: load default_params.yaml,
+  set up matched theory + QsSim, compare moments via np.allclose with shared
+  tolerances, print io.tables for diagnostics. Use whenever a new theory
+  calculator is added, an existing test fails, or simulation/theory results need
+  cross-validation in this repo.
+---
+
+# Theory-vs-Sim Test Pattern
+
+Every numerical model in `most_queue/theory/**` is validated against
+discrete-event simulation (`QsSim` and friends). The pattern below is the
+project-wide convention � follow it for any new test.
+
+## Required imports
+
+```python
+import os
+import numpy as np
+import yaml
+
+from most_queue.io.tables import print_sojourn_moments, print_waiting_moments, probs_print
+from most_queue.sim.base import QsSim                    # or specialised sim
+from most_queue.theory.<area>.<model> import <ModelCalc>  # the theory class
+from most_queue.random.distributions import H2Distribution  # or whichever fits the test
+```
+
+## Load shared tolerances from `tests/default_params.yaml`
+
+Always read these constants � never hard-code tolerances in the test:
+
+```python
+params_path = os.path.join(os.getcwd(), "tests", "default_params.yaml")
+with open(params_path, "r", encoding="utf-8") as f:
+    params = yaml.safe_load(f)
+
+ARRIVAL_RATE       = float(params["arrival"]["rate"])
+SERVICE_TIME_CV    = float(params["service"]["cv"])
+NUM_OF_JOBS        = int(params["num_of_jobs"])
+UTILIZATION_FACTOR = float(params["utilization_factor"])
+MOMENTS_ATOL       = float(params["moments_atol"])
+MOMENTS_RTOL       = float(params["moments_rtol"])
+PROBS_ATOL         = float(params["probs_atol"])
+PROBS_RTOL         = float(params["probs_rtol"])
+ERROR_MSG          = params["error_msg"]
+```
+
+## Standard test body
+
+```python
+def test_<model>():
+    # 1. Match service distribution moments between theory and sim.
+    b1 = UTILIZATION_FACTOR * NUM_OF_CHANNELS / ARRIVAL_RATE
+    h2_params = H2Distribution.get_params_by_mean_and_cv(b1, SERVICE_TIME_CV)
+    b = H2Distribution.calc_theory_moments(h2_params, 5)
+
+    # 2. Theory.
+    calc = <ModelCalc>(...)            # any constructor args your model needs
+    calc.set_sources(ARRIVAL_RATE)     # or (params, kendall) for non-Markovian arrivals
+    calc.set_servers(b)
+    calc_results = calc.run()
+    assert abs(UTILIZATION_FACTOR - calc_results.utilization) < PROBS_ATOL
+
+    # 3. Simulation with the SAME distribution.
+    qs = QsSim(NUM_OF_CHANNELS)
+    qs.set_sources(ARRIVAL_RATE, "M")
+    qs.set_servers(h2_params, "H")
+    sim_results = qs.run(NUM_OF_JOBS)
+
+    # 4. Diagnostics (always print � helps debugging when CI flips).
+    print_waiting_moments(sim_results.w, calc_results.w)
+    print_sojourn_moments(sim_results.v, calc_results.v)
+    probs_print(sim_results.p, calc_results.p, 10)
+
+    # 5. Assertions. Compare RAW moments. Higher moments are noisy at
+    #    NUM_OF_JOBS=100k ? typically validate the first 2 only.
+    assert np.allclose(sim_results.w[:2], calc_results.w[:2],
+                       rtol=MOMENTS_RTOL, atol=MOMENTS_ATOL)
+    assert np.allclose(sim_results.v[:2], calc_results.v[:2],
+                       rtol=MOMENTS_RTOL, atol=MOMENTS_ATOL)
+    assert np.allclose(np.array(sim_results.p[:10]),
+                       np.array(calc_results.p[:10]),
+                       atol=PROBS_ATOL, rtol=PROBS_RTOL), ERROR_MSG
+```
+
+## Why each piece is non-negotiable
+
+| Step | Reason |
+|------|--------|
+| Same distribution moments on both sides | Otherwise the comparison is meaningless. Use the distribution's `get_params_by_mean_and_cv` + `calc_theory_moments`. |
+| `default_params.yaml` constants | Project-wide tolerances � changing them silently is forbidden (see rule `pytest-quality.mdc`). |
+| Compare only first 2 moments by default | Sample 3rd/4th moments require >1M jobs to converge; doing fewer means false negatives. |
+| Always print `io.tables` | When a test fails in CI you need the actual numbers, not just the assertion. |
+
+## When defaults are not enough
+
+- **High utilization (? ? 0.9)** or **heavy-tailed service (Pareto, large CV)**:
+  raise `NUM_OF_JOBS` to 500k�1M *in the test only*. Do **not** lower
+  `MOMENTS_RTOL` instead.
+- **Multi-channel (n > 1)** with priorities or vacations: prefer the
+  specialised simulator (`QsSim` subclass in `most_queue/sim/`) over composing
+  with hooks.
+- **Non-Markovian arrivals**: use `Gamma` for the sim side and pass the same
+  `(mean, cv)` to the theory class.
+
+## Diagnostic helpers (in `most_queue/io/tables`)
+
+- `print_waiting_moments(sim.w, calc.w)`
+- `print_sojourn_moments(sim.v, calc.v)`
+- `print_raw_moments(sim_moments, calc_moments)`
+- `probs_print(sim.p, calc.p, n_states)`
+
+## Reference tests in this repo
+
+| File | What it validates |
+|------|-------------------|
+| `tests/test_mg1_calc.py` | Canonical M/G/1 vs sim � minimal, copy-as-template |
+| `tests/test_gi_m_n_calc.py` | Non-Markovian arrivals (Gamma) |
+| `tests/test_mgn_tt.py` | Takahashi�Takami M/G/n |
+| `tests/test_mg1_warmup.py` | Vacation/warm-up extension to the pattern |

most_queue-2.8/.gitattributes

@@ -0,0 +1,6 @@
+# Keep GitHub's language statistics meaningful: the repo is a Python library,
+# notebooks and research materials are documentation, not source code.
+*.ipynb linguist-documentation
+docs/** linguist-documentation
+works/** linguist-documentation
+tutorials/** linguist-documentation

most_queue-2.8/.github/workflows/tests.yml

@@ -0,0 +1,34 @@
+name: tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  pytest:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install package and test dependencies
+        run: |
+          python -m pip install -U pip
+          python -m pip install -e .
+          python -m pip install pytest pytest-rerunfailures
+
+      - name: Run tests (fast set)
+        # --reruns 1: simulation-vs-theory tests are statistical; a single
+        # rerun absorbs rare unlucky sample paths without hiding real breakage
+        run: pytest tests/ -m "not slow" -q --reruns 1 --only-rerun AssertionError

{most_queue-2.7 → most_queue-2.8}/.gitignore

@@ -162,11 +162,32 @@ cython_debug/
 
 .vscode
 
-works/negative_queues/results/*
+# works/negative_queues (article sources, figures, scripts)
+# keep sources in git, ignore generated artifacts and bulky results
+works/negative_queues/*.zip
+works/negative_queues_takahasi_takami_sources.zip
+works/negative_queues/build/
+works/negative_queues/results/
+works/negative_queues/__pycache__/
+works/negative_queues/*.aux
+works/negative_queues/*.bbl
+works/negative_queues/*.bcf
+works/negative_queues/*.blg
+works/negative_queues/*.fdb_latexmk
+works/negative_queues/*.fls
+works/negative_queues/*.log
+works/negative_queues/*.out
+works/negative_queues/*.run.xml
+works/negative_queues/*.synctex.gz
+works/negative_queues/*.toc
+works/negative_queues/**/*.bkp
 
 # ignore all png files in tests/units folder
 tests/units/*.png
 
+# Generated by examples/srpt_table.py (matplotlib)
+examples/srpt_table.png
+
 # ignore all files in works/vacations/results
 works/vacations/results/*
 
@@ -174,3 +195,7 @@ works/vacations/results/*
 docs/negative_queues_takahasi_takami.md
 docs/negative_queues_figures/
 docs/books/
+docs/статьи/
+works/queueing_systems_review/SRPT/pdf/
+works/experiments/rabbitmq_prefetch/
+works/reviews/

{most_queue-2.7 → most_queue-2.8}/.pre-commit-config.yaml

@@ -6,6 +6,7 @@ repos:
     hooks:
       - id: check-yaml
       - id: check-added-large-files
+        args: ['--maxkb', '2048']  # allow assets (banner images up to ~2MB)
       - id: check-json
       - id: check-toml