loaderup 0.1.0__py3-none-any.whl

loaderup/cli.py

@@ -0,0 +1,219 @@
+# loaderup/cli.py
+
+import argparse
+import importlib
+import os
+import sys
+import threading
+import uvicorn
+import webbrowser
+
+try:
+    from rich.console import Console
+except ImportError:  # pragma: no cover - fallback for minimal environments
+    Console = None
+
+from loaderup.importer import discover_target_modules, import_target_modules
+from loaderup.registry import get_registry, clear_registry
+
+
+console = Console() if Console else None
+
+
+def ensure_working_dir_on_sys_path() -> None:
+    cwd = os.getcwd()
+    if cwd and cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+    current_pythonpath = os.environ.get("PYTHONPATH", "")
+    pythonpath_parts = [part for part in current_pythonpath.split(os.pathsep) if part]
+    if cwd and cwd not in pythonpath_parts:
+        os.environ["PYTHONPATH"] = os.pathsep.join([cwd, *pythonpath_parts])
+
+
+def print_banner():
+    banner = r"""
+██╗      ██████╗  █████╗ ██████╗ ███████╗██████╗ ██╗   ██╗██████╗
+██║     ██╔═══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗██║   ██║██╔══██╗
+██║     ██║   ██║███████║██║  ██║█████╗  ██████╔╝██║   ██║██████╔╝
+██║     ██║   ██║██╔══██║██║  ██║██╔══╝  ██╔══██╗██║   ██║██╔═══╝
+███████╗╚██████╔╝██║  ██║██████╔╝███████╗██║  ██║╚██████╔╝██║
+╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚═════╝ ╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═╝
+"""
+    if console:
+        console.print(f"[bold cyan]{banner}[/bold cyan]")
+        console.print("[bold white]AI-native load testing[/bold white]\n")
+    else:
+        print(banner)
+        print("AI-native load testing\n")
+
+
+def resolve_app_import_string(app: str) -> str:
+    if ":" not in app:
+        return app
+
+    module_name, app_name = app.split(":", 1)
+    if "." in module_name:
+        return app
+
+    try:
+        importlib.import_module(module_name)
+        return app
+    except ModuleNotFoundError as exc:
+        if exc.name != module_name:
+            raise
+
+    fallback_module = f"loader.{module_name}"
+    importlib.import_module(fallback_module)
+    resolved = f"{fallback_module}:{app_name}"
+    print(f"[loaderup] Resolved app '{app}' -> '{resolved}'")
+    return resolved
+
+
+def cmd_up(args):
+    print_banner()
+    print("[loaderup] Discovering targets...")
+
+    clear_registry()
+
+    modules = []
+    if args.targets:
+        modules = [m.strip() for m in args.targets.split(",") if m.strip()]
+
+    if modules:
+        print(f"[loaderup] Importing target modules: {modules}")
+        import_target_modules(modules)
+        os.environ["LOADERUP_TARGET_MODULES"] = ",".join(modules)
+    else:
+        modules = discover_target_modules(".")
+        if modules:
+            print(f"[loaderup] Auto-discovered modules: {modules}")
+            import_target_modules(modules)
+            os.environ["LOADERUP_TARGET_MODULES"] = ",".join(modules)
+        else:
+            print("[loaderup] No target modules provided")
+            os.environ.pop("LOADERUP_TARGET_MODULES", None)
+
+    registry = get_registry()
+    print(f"[loaderup] Registered targets: {len(registry)}")
+
+    for i, target in enumerate(registry, start=1):
+        print(
+            f"  {i}. {target['method']} {target['path']} "
+            f"(name={target['name']}, tags={target.get('tags', [])})"
+        )
+
+    app_import = resolve_app_import_string(args.app)
+    print("[loaderup] Starting backend...")
+    print(f"[loaderup] Starting server: {app_import}")
+
+    if args.open_browser:
+        browser_host = "127.0.0.1" if args.host in {"0.0.0.0", "::"} else args.host
+        dashboard_url = f"http://{browser_host}:{args.port}/"
+        print("[loaderup] Opening dashboard...")
+        print(f"[loaderup] Opening dashboard: {dashboard_url}")
+        threading.Timer(1.0, lambda: webbrowser.open(dashboard_url)).start()
+
+    uvicorn.run(app_import, host=args.host, port=args.port, reload=args.reload)
+
+
+def cmd_discover(args):
+    clear_registry()
+
+    modules = []
+    if args.targets:
+        modules = [m.strip() for m in args.targets.split(",") if m.strip()]
+
+    if modules:
+        print(f"[loaderup] Importing target modules: {modules}")
+        import_target_modules(modules)
+    else:
+        modules = discover_target_modules(args.path)
+        if modules:
+            print(f"[loaderup] Auto-discovered modules: {modules}")
+            loaded = []
+            skipped = []
+            for module_name in modules:
+                try:
+                    import_target_modules([module_name])
+                    loaded.append(module_name)
+                except ModuleNotFoundError as exc:
+                    skipped.append((module_name, str(exc)))
+            if skipped:
+                for module_name, reason in skipped:
+                    print(f"[loaderup] Skipping '{module_name}': {reason}")
+            if loaded:
+                print(f"[loaderup] Loaded modules: {loaded}")
+        else:
+            print("[loaderup] No target modules found by auto-discovery")
+
+    registry = get_registry()
+    print(f"[loaderup] Registered targets: {len(registry)}")
+
+    for i, target in enumerate(registry, start=1):
+        print(
+            f"  {i}. {target['method']} {target['path']} "
+            f"(name={target['name']}, expected={target.get('expected_status', 200)}, "
+            f"tags={target.get('tags', [])})"
+        )
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(prog="loaderup")
+    subparsers = parser.add_subparsers(dest="command")
+
+    up_parser = subparsers.add_parser("up", help="Start LoaderUp backend")
+    up_parser.add_argument(
+        "--app",
+        default="loader.main:app",
+        help="ASGI app import string, e.g. loader.main:app",
+    )
+    up_parser.add_argument(
+        "--targets",
+        default="",
+        help="Comma-separated Python modules to import for decorators, e.g. demo_registry_targets",
+    )
+    up_parser.add_argument("--host", default="127.0.0.1")
+    up_parser.add_argument("--port", type=int, default=8000)
+    up_parser.add_argument("--reload", action="store_true")
+    up_parser.add_argument(
+        "--open-browser",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Open dashboard in your default browser (default: enabled)",
+    )
+    up_parser.set_defaults(func=cmd_up)
+
+    discover_parser = subparsers.add_parser(
+        "discover", help="Import modules and list registered targets"
+    )
+    discover_parser.add_argument(
+        "--targets",
+        default="",
+        help="Comma-separated Python modules to import for decorators",
+    )
+    discover_parser.add_argument(
+        "--path",
+        default=".",
+        help="Directory root for auto-discovery when --targets is not provided",
+    )
+    discover_parser.set_defaults(func=cmd_discover)
+
+    return parser
+
+
+def main():
+    ensure_working_dir_on_sys_path()
+
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        sys.exit(1)
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

loaderup/collector.py

@@ -0,0 +1,11 @@
+# loaderup/collector.py
+
+from typing import List
+
+from loader.models import LoadTarget
+from loaderup.registry import get_registry
+
+
+def collect_load_targets() -> List[LoadTarget]:
+    raw_targets = get_registry()
+    return [LoadTarget(**target) for target in raw_targets]

loaderup/decorators.py

@@ -0,0 +1,34 @@
+# loaderup/decorators.py
+
+from typing import Optional, Dict, Any, List
+from loaderup.registry import register_target
+
+
+def load_target(
+    name: str,
+    method: str,
+    path: str,
+    headers: Optional[Dict[str, str]] = None,
+    payload_example: Optional[Dict[str, Any]] = None,
+    weight: float = 1.0,
+    tags: Optional[List[str]] = None,
+    expected_status: int = 200,
+):
+    def decorator(func):
+        target = {
+            "name": name,
+            "method": method.upper(),
+            "path": path,
+            "headers": headers or {},
+            "payload_example": payload_example,
+            "weight": weight,
+            "tags": tags or [],
+            "expected_status": expected_status,
+        }
+
+        register_target(target)
+
+        func.__loaderup_target__ = target
+        return func
+
+    return decorator

loaderup/importer.py

@@ -0,0 +1,120 @@
+# loaderup/importer.py
+
+import ast
+import importlib
+from pathlib import Path
+from typing import Iterable
+
+
+def _module_candidates(module_name: str) -> list[str]:
+    candidates: list[str] = [module_name]
+
+    if module_name.endswith("s"):
+        candidates.append(module_name[:-1])
+    else:
+        candidates.append(f"{module_name}s")
+
+    if "." not in module_name:
+        candidates.extend([f"loader.{name}" for name in list(candidates)])
+
+    deduped: list[str] = []
+    seen: set[str] = set()
+    for candidate in candidates:
+        if candidate and candidate not in seen:
+            seen.add(candidate)
+            deduped.append(candidate)
+
+    return deduped
+
+
+def _import_with_fallback(module_name: str) -> None:
+    candidates = _module_candidates(module_name)
+
+    for candidate in candidates:
+        try:
+            importlib.import_module(candidate)
+            return
+        except ModuleNotFoundError as exc:
+            if exc.name != candidate:
+                raise
+
+    tried = ", ".join(candidates)
+    raise ModuleNotFoundError(f"No module named '{module_name}'. Tried: {tried}")
+
+
+def import_target_modules(module_names: Iterable[str]) -> None:
+    for module_name in module_names:
+        module_name = module_name.strip()
+        if not module_name:
+            continue
+        _import_with_fallback(module_name)
+
+
+def _is_target_file(path: Path) -> bool:
+    try:
+        source = path.read_text(encoding="utf-8")
+    except OSError:
+        return False
+
+    if "load_target" not in source:
+        return False
+
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return False
+
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        for decorator in node.decorator_list:
+            target = decorator.func if isinstance(decorator, ast.Call) else decorator
+            if isinstance(target, ast.Name) and target.id == "load_target":
+                return True
+            if isinstance(target, ast.Attribute) and target.attr == "load_target":
+                return True
+
+    return False
+
+
+def _path_to_module(root: Path, path: Path) -> str:
+    relative = path.relative_to(root)
+    parts = list(relative.parts)
+
+    if not parts:
+        return ""
+
+    if parts[-1].endswith(".py"):
+        parts[-1] = parts[-1][:-3]
+
+    if parts[-1] == "__init__":
+        parts = parts[:-1]
+
+    return ".".join(part for part in parts if part)
+
+
+def discover_target_modules(search_root: str = ".") -> list[str]:
+    root = Path(search_root).resolve()
+    if not root.exists():
+        return []
+
+    ignored_dirs = {".git", ".venv", "venv", "__pycache__", "artifacts", ".ruff_cache"}
+    modules: list[str] = []
+    seen: set[str] = set()
+
+    for path in root.rglob("*.py"):
+        if any(part in ignored_dirs for part in path.parts):
+            continue
+        if path.name.startswith("test_"):
+            continue
+        if "tests" in path.parts:
+            continue
+        if not _is_target_file(path):
+            continue
+
+        module_name = _path_to_module(root, path)
+        if module_name and module_name not in seen:
+            seen.add(module_name)
+            modules.append(module_name)
+
+    return sorted(modules)

loaderup/models.py

@@ -0,0 +1,36 @@
+from typing import List
+from pydantic import BaseModel, Field, model_validator
+from typing import Literal, Dict, Any, Optional
+
+
+class LoadTarget(BaseModel):
+    name: str
+    method: Literal["GET", "POST", "PUT", "PATCH", "DELETE"]
+    path: str
+    headers: Dict[str, str] = Field(default_factory=dict)
+    payload_example: Optional[Dict[str, Any]] = None
+    weight: float = 1.0
+    tags: List[str] = Field(default_factory=list)
+    expected_status: int = 200
+
+    @model_validator(mode="after")
+    def validate_target(self):
+        if not self.path.startswith("/"):
+            raise ValueError("path must start with '/'")
+        return self
+
+
+class RunRegistryRequest(BaseModel):
+    base_url: str
+    vus: int = 10
+    duration_seconds: int = 30
+
+    @model_validator(mode="after")
+    def validate_request(self):
+        if not self.base_url.startswith(("http://", "https://")):
+            raise ValueError("base_url must start with http:// or https://")
+        if self.vus < 1:
+            raise ValueError("vus must be >= 1")
+        if self.duration_seconds < 1:
+            raise ValueError("duration_seconds must be >= 1")
+        return self

loaderup/registry.py

@@ -0,0 +1,31 @@
+# loaderup/registry.py
+
+from typing import List, Dict, Any, Tuple
+
+_REGISTRY: List[Dict[str, Any]] = []
+_SEEN: set[Tuple[str, str, str]] = set()
+
+
+def _make_key(target: Dict[str, Any]) -> Tuple[str, str, str]:
+    return (
+        str(target.get("name", "")),
+        str(target.get("method", "")).upper(),
+        str(target.get("path", "")),
+    )
+
+
+def register_target(target: Dict[str, Any]):
+    key = _make_key(target)
+    if key in _SEEN:
+        return
+    _SEEN.add(key)
+    _REGISTRY.append(target)
+
+
+def get_registry() -> List[Dict[str, Any]]:
+    return list(_REGISTRY)
+
+
+def clear_registry():
+    _REGISTRY.clear()
+    _SEEN.clear()

loaderup-0.1.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: loaderup
+Version: 0.1.0
+Summary: Lightweight load-testing API and CLI built around FastAPI, k6, and decorator-based target registration.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.135.3
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-multipart>=0.0.24
+Requires-Dist: uvicorn>=0.44.0
+Requires-Dist: rich>=13.10.0
+
+# LoaderUp
+
+Lightweight load-testing API and CLI built around FastAPI, k6, and decorator-based target registration.
+
+## Requirements
+
+- Python `>=3.12`
+- `uv` (recommended package manager)
+- `k6` (optional but recommended for real load runs)
+
+## Install
+
+```bash
+uv pip install -e .
+```
+
+## Run API directly
+
+```bash
+python -m loader.main
+```
+
+Server starts on `http://127.0.0.1:8000` by default.
+
+## Run via CLI
+
+```bash
+python -m loaderup.cli up --app loader.main:app --targets loader.demo_registry_target --reload
+```
+
+This command opens the dashboard automatically at `http://127.0.0.1:8000/`.
+Use `--no-open-browser` if you want to disable auto-open.
+
+You can also use fallback-friendly forms like:
+
+```bash
+python -m loaderup.cli up --app main:app --targets demo_registry_targets --reload
+```
+
+## Health check
+
+```bash
+curl http://127.0.0.1:8000/health
+```
+
+## Dashboard
+
+Open:
+
+```bash
+http://127.0.0.1:8000/
+```
+
+Dashboard includes:
+
+- live status + progress stream
+- metrics cards + quick chart bars
+- saved run history (persisted in `artifacts/history/runs.jsonl`)
+- React-based multi-tab control center (`Run Now`, `Live`, `Registered Targets`, `History`)
+
+## Notes
+
+- Registry targets are loaded when the module is imported.
+- Use `/run/targets` to submit explicit targets.
+- Use `/run/registry` to run all decorator-registered targets.

loaderup-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+agents/analyzer.py,sha256=8O7Lv5miYeeiIzwc0fzZ8jKiaKw-dkySW4w4Sfw-6UE,2539
+agents/generator.py,sha256=vDh32x4fdQdOJdRK2VE4Vggmaf9ABKfk0bnh621-0JA,2833
+agents/runner.py,sha256=5m5KHhfI5GjW5jLYjFvKGDvtalnYFkaPpfaO8OfT8ow,1060
+loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loader/demo_registry_target.py,sha256=aIY2DPWJpgvOMbOPSJ-XFuLklAwUtS33wu1d_g4TcWI,354
+loader/history.py,sha256=TiCejCocJqhk3FvsgGYn4PwAF1chJkAhy2qWhdo78a8,964
+loader/main.py,sha256=OH0uk_fNYVQCe62VZ8tsOelMdcQQ7kGfzLoVadCcOjs,4005
+loader/models.py,sha256=_65c5lSiXuPK_m2_jbgnphGLlY7fzxzgPeC-fjb1qMw,2751
+loader/pipeline.py,sha256=JqYqM1hX7yFUtYD8gk15Q0J7eD4ztM67yf62wazNe8s,3417
+loader/settings.py,sha256=oSWO8hyRmZveBTo0ITqDMSOfJmOjeaHPCJ8aq5rDdSo,108
+loader/store.py,sha256=3yAPn50eV-NGeLmBjAAbiz62wNH2M4q2AHG4mie0Z1g,864
+loader/web/index.html,sha256=t4CaoP0_60niDvVIVAbw_PWTt_sCMbF9zfZg8G4W8i4,651
+loader/web/assets/app.js,sha256=mbReOOF_xHYz4JnT0RiLBmRiAnsdmlxE-C80m99293Q,30106
+loader/web/assets/styles.css,sha256=BY2MTh4CWyfsYgr6qc8_KFk4wMjT_nYcm8lEY6gCImg,9981
+loaderup/__init__.py,sha256=rXWZxpd_NCOGjpuC7V2uoM3qGapXcPKEcX5V3kYIeY0,234
+loaderup/autodiscovery.py,sha256=Dai7o7jd8PyWKAHQAl-Nm0wmLqUbbA8CXMZHPfiVXAY,1500
+loaderup/cli.py,sha256=q1KvtNYerpgSdaRP5DTcXdPY-T609OwNxO4c5CcjGhs,7567
+loaderup/collector.py,sha256=vgmWzZAY1VoUDugEkzw2TLrEUVPY9LqBdj-JxcWiwyU,273
+loaderup/decorators.py,sha256=mjdvv75Y_OlbtfpYui-hBohEH_zpCOjGIuXg83LWndg,839
+loaderup/importer.py,sha256=SWqoqQ5FnLTDpfuJPIWrbDf99NeazrO7aiMj7O3a00k,3269
+loaderup/models.py,sha256=yeE6fKIhxZddd3qckKwf_JB2QJPSA6CrKUhuP-LzFzU,1160
+loaderup/registry.py,sha256=XNMq8fWRgzAoWmh11nWvoBgpDpgn6z5BamzfUxYEeqU,645
+loaderup-0.1.0.dist-info/METADATA,sha256=cqjhOZxdbyG0eAOugxO3Zx3SucCoulv7MDn-zKv9v-4,1772
+loaderup-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+loaderup-0.1.0.dist-info/entry_points.txt,sha256=TaY9uODKo4jWT2SM63Cm_aW5Q4MLBdy6E3ADaxJqUPo,47
+loaderup-0.1.0.dist-info/top_level.txt,sha256=jsXHKBeHgZQi9d24qixIifziH5MP9KWH4iNgXgxOG9Q,23
+loaderup-0.1.0.dist-info/RECORD,,

loaderup-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

loaderup-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+loaderup = loaderup.cli:main

loaderup-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+agents
+loader
+loaderup