Api Arrival generator migration complete with tests

Author: GioeleB00

asyncflow_queue_limit/asyncflow_mm1.ipynb

@@ -20,33 +20,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "b8a94d93",
    "metadata": {},
    "outputs": [],
    "source": [
     "import sys, importlib\n",
     "\n",
-    "# 1) Svuota tutto ciò che inizia con 'asyncflow' da sys.modules\n",
+    "\n",
     "for m in list(sys.modules):\n",
     "    if m.startswith(\"asyncflow\"):\n",
     "        del sys.modules[m]\n",
     "\n",
-    "# 2) Re-importa SOLO le facciate pubbliche (niente import profondi)\n",
+    "\n",
     "from asyncflow import AsyncFlow, SimulationRunner\n",
     "from asyncflow.analysis import MMc, ResultsAnalyzer\n",
     "from asyncflow.components import (\n",
-    "    Client, Server, Edge, Endpoint, LoadBalancer\n",
+    "    Client, Server, Edge, Endpoint, LoadBalancer, ArrivalsGenerator\n",
     ")\n",
     "from asyncflow.settings import SimulationSettings\n",
-    "from asyncflow.workload import RqsGenerator\n",
+    "\n",
     "import simpy\n",
     "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "d1b7ad7d",
    "metadata": {},
    "outputs": [
@@ -64,10 +64,10 @@
     "\n",
     "# Public AsyncFlow API\n",
     "from asyncflow import AsyncFlow, SimulationRunner, Sweep\n",
-    "from asyncflow.components import Client, Server, Edge, Endpoint, LoadBalancer\n",
+    "from asyncflow.components import Client, Server, Edge, Endpoint, LoadBalancer, ArrivalsGenerator\n",
     "from asyncflow.settings import SimulationSettings\n",
-    "from asyncflow.workload import RqsGenerator\n",
-    "from asyncflow.analysis import MM1, ResultsAnalyzer, SweepAnalyzer, MMc\n",
+    "from asyncflow.analysis import  ResultsAnalyzer, SweepAnalyzer, MMc\n",
+    "from asyncflow.enums import Distribution\n",
     "\n",
     "print(\"Imports OK.\")"
    ]
@@ -128,17 +128,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "ba93587a",
    "metadata": {},
    "outputs": [],
    "source": [
     "def build_payload():\n",
-    "    generator = RqsGenerator(\n",
+    "    generator = ArrivalsGenerator(\n",
     "        id=\"rqs-1\",\n",
-    "        avg_active_users={\"mean\": 120},\n",
-    "        avg_request_per_minute_per_user={\"mean\": 20},\n",
-    "        user_sampling_window=60,\n",
+    "        lambda_rps=30,\n",
+    "        model=Distribution.POISSON\n",
     "    )\n",
     "\n",
     "    client = Client(id=\"client-1\")\n",
@@ -189,7 +188,7 @@
     "\n",
     "    payload = (\n",
     "        AsyncFlow()\n",
-    "        .add_generator(generator)\n",
+    "        .add_arrivals_generator(generator)\n",
     "        .add_client(client)\n",
     "        .add_servers(srv1, srv2)\n",
     "        .add_load_balancer(lb)\n",

asyncflow_queue_limit/asyncflow_mmc_split.ipynb

@@ -2,7 +2,6 @@
 
 from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
 from asyncflow.metrics.sweep_analyzer import SweepAnalyzer
-from asyncflow.queue_theory_analysis.mm1 import MM1
 from asyncflow.queue_theory_analysis.mmc import MMc
 
-__all__ = ["MM1", "MMc", "ResultsAnalyzer", "SweepAnalyzer"]
+__all__ = ["MMc", "ResultsAnalyzer", "SweepAnalyzer"]

src/asyncflow/analysis/__init__.py

@@ -173,7 +173,7 @@ def build_payload(self) -> SimulationPayload:
         )
 
         return SimulationPayload.model_validate({
-            "rqs_input": self._generator,
+            "arrivals": self._arrivals,
             "topology_graph": graph,
             "sim_settings": self._sim_settings,
             "events": self._events or None,

src/asyncflow/builder/asyncflow_builder.py

@@ -1,6 +1,7 @@
 """Public components: re-exports Pydantic schemas (topology)."""
 from __future__ import annotations
 
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.schemas.events.injection import EventInjection
 from asyncflow.schemas.topology.edges import Edge
 from asyncflow.schemas.topology.endpoint import Endpoint
@@ -12,6 +13,7 @@
 )
 
 __all__ = [
+    "ArrivalsGenerator",
     "Client",
     "Edge",
     "Endpoint",

src/asyncflow/components/__init__.py

@@ -1,6 +1,6 @@
 """Public enums used in scenario definitions."""
 
-from asyncfow.config.enums import (
+from asyncflow.config.enums import (
     Distribution,
     EndpointStepCPU,
     EndpointStepIO,

src/asyncflow/enums/__init__.py

@@ -1,5 +1,5 @@
 """
-SweepAnalyzer — build plots from a sweep over *mean concurrent users*.
+SweepAnalyzer — build plots from a sweep over *mean rps*.
 
 Global
 ------
@@ -70,7 +70,7 @@ class ServerPoint:
 
 class SweepAnalyzer:
     """
-    Build plots from a sweep over *mean concurrent users*.
+    Build plots from a sweep over *mean rps*.
 
     Input
     -----
@@ -246,39 +246,39 @@ def _collect_servers(self) -> None:
     # ──────────────────────────────────────────────────────────────────
 
     def plot_global_throughput(self, ax: Axes) -> None:
-        """Plot mean throughput (RPS) vs. mean concurrent users."""
+        """Plot mean throughput (RPS) vs. mean rps."""
         self._ensure_global_collected()
         pts = self._global_points
         xs = [p.users for p in pts]
         ys = [p.lambda_rps for p in pts]
         ax.plot(xs, ys, marker="o")
-        ax.set_title("Throughput (mean RPS) vs. concurrent users")
-        ax.set_xlabel("Mean concurrent users")
+        ax.set_title("Throughput (mean RPS) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
         ax.set_ylabel("RPS")
         ax.grid(visible=True, alpha=0.3)
 
     def plot_global_latency(self, ax: Axes) -> None:
-        """Plot mean system time (W) vs. mean concurrent users."""
+        """Plot mean system time (W) vs. mean rps."""
         self._ensure_global_collected()
         pts = self._global_points
         xs = [p.users for p in pts]
         ys = [p.W for p in pts]
         ax.plot(xs, ys, marker="o")
-        ax.set_title("Mean system time (W) vs. concurrent users")
-        ax.set_xlabel("Mean concurrent users")
+        ax.set_title("Mean system time (W) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
         ax.set_ylabel("W (seconds)")
         ax.grid(visible=True, alpha=0.3)
 
     def plot_global_latency_percentiles(self, ax: Axes) -> None:
-        """Plot P50, P95, P99 latency vs. mean concurrent users."""
+        """Plot P50, P95, P99 latency vs. mean rps."""
         self._ensure_global_collected()
         pts = self._global_points
         xs = [p.users for p in pts]
         ax.plot(xs, [p.p50 for p in pts], marker="o", label="P50")
         ax.plot(xs, [p.p95 for p in pts], marker="o", label="P95")
         ax.plot(xs, [p.p99 for p in pts], marker="o", label="P99")
-        ax.set_title("Latency percentiles vs. concurrent users")
-        ax.set_xlabel("Mean concurrent users")
+        ax.set_title("Latency percentiles vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
         ax.set_ylabel("Latency (seconds)")
         ax.legend()
         ax.grid(visible=True, alpha=0.3)
@@ -344,8 +344,8 @@ def plot_server_utilization_overlay(
             xs = [p.users for p in pts]
             ys = [p.rho for p in pts]
             ax.plot(xs, ys, marker="o", label=sid)
-        ax.set_title("Server utilization (rho) vs. concurrent users")
-        ax.set_xlabel("Mean concurrent users")
+        ax.set_title("Server utilization (rho) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
         ax.set_ylabel("rho")
         if ids:
             ax.legend()
@@ -366,8 +366,8 @@ def plot_server_waiting_time_overlay(
             xs = [p.users for p in pts]
             ys = [p.Wq for p in pts]
             ax.plot(xs, ys, marker="o", label=sid)
-        ax.set_title("Server waiting time (Wq) vs. concurrent users")
-        ax.set_xlabel("Mean concurrent users")
+        ax.set_title("Server waiting time (Wq) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
         ax.set_ylabel("Wq (seconds)")
         if ids:
             ax.legend()
@@ -388,8 +388,8 @@ def plot_server_service_rate_overlay(
             xs = [p.users for p in pts]
             ys = [p.mu_rps for p in pts]
             ax.plot(xs, ys, marker="o", label=sid)
-        ax.set_title("Server service rate (mu) vs. concurrent users")
-        ax.set_xlabel("Mean concurrent users")
+        ax.set_title("Server service rate (mu) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
         ax.set_ylabel("mu (1/s)")
         if ids:
             ax.legend()
@@ -410,8 +410,8 @@ def plot_server_throughput_overlay(
             xs = [p.users for p in pts]
             ys = [p.lambda_rps for p in pts]
             ax.plot(xs, ys, marker="o", label=sid)
-        ax.set_title("Server throughput (lambda) vs. concurrent users")
-        ax.set_xlabel("Mean concurrent users")
+        ax.set_title("Server throughput (lambda) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
         ax.set_ylabel("lambda (1/s)")
         if ids:
             ax.legend()
@@ -428,8 +428,8 @@ def plot_server_latency_overlay(
             xs = [p.users for p in pts]
             ys = [p.server_latency_mean_s for p in pts]
             ax.plot(xs, ys, marker="o", label=sid)
-        ax.set_title("Server latency (waiting+service) vs. concurrent users")
-        ax.set_xlabel("Mean concurrent users")
+        ax.set_title("Server latency (waiting+service) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
         ax.set_ylabel("Server latency (s)")
         if ids:
             ax.legend()