yaafcli 2026.2.4.180929__tar.gz

yaafcli-2026.2.4.180929/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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.

yaafcli-2026.2.4.180929/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: yaafcli
+Version: 2026.2.4.180929
+Summary: Minimal ASGI app scaffold
+License: MIT License
+        
+        Copyright (c) 2026
+        
+        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.
+        
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: AsyncIO
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: uvicorn>=0.23
+Provides-Extra: test
+Requires-Dist: pytest>=7.4; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Dynamic: license-file
+
+# yaaf
+
+YAAF stands for "Yet Another ASGI Framework".
+
+A minimal Python ASGI app scaffold that discovers routes from the filesystem. It includes a tiny router and a CLI wrapper around `uvicorn`.
+
+## Design Goals and Opinions
+
+- **Filesystem-first routing.** Routes are inferred from the directory structure under `consumers/**/api` rather than declared with decorators. This keeps routing discoverable by looking at the tree.
+- **Explicit endpoint files.** Each route has `_server.py` and `_service.py` to separate request handling from domain logic.
+- **Dependency injection without wiring.** Services are registered automatically and injected by name/type, so handlers and services focus on behavior, not setup.
+- **Static-first routing precedence.** Static routes always win over dynamic segments, with warnings when a dynamic route would overlap a static route.
+- **Minimal core.** The framework is intentionally small and opinionated, leaving room for you to add auth, middleware, validation, etc.
+
+## Quickstart
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+
+# Run the built-in example routes
+yaaf --reload
+```
+
+Example routes:
+
+- `GET /api/hello`
+- `GET /api/<name>` (dynamic segment)
+
+## Routing Model
+
+Routes are inferred from the directory structure under any `consumers/**/api` directory.
+
+- Every route directory must contain `_server.py` and `_service.py`.
+- The route path is `/api/...` plus the sub-path after `api/`.
+- Dynamic segments use `[param]` directory names and are exposed as `params`/`path_params`.
+
+Example layout:
+
+```text
+consumers/
+  api/
+    users/
+      _server.py
+      _service.py
+    hello/
+      _server.py
+      _service.py
+    [name]/
+      _server.py
+      _service.py
+```
+
+## Handlers and Services
+
+In `_server.py`, export functions named after HTTP methods (lowercase): `get`, `post`, etc. The function signature is resolved via dependency injection:
+
+- `request` gives you the `yaaf.Request` object.
+- `params` or `path_params` provides dynamic route parameters.
+- Services are injected by type annotations.
+
+Example `_server.py`:
+
+```python
+from consumers.services import HelloService
+from yaaf import Request
+from yaaf.types import Params
+
+
+async def get(request: Request, service: HelloService, params: Params):
+    return {"message": service.message(), "path": request.path, "params": params}
+```
+
+In `_service.py`, expose a module-level `service` instance (or a callable like `Service` or `get_service`). Services are registered and can be injected into other services or handlers:
+
+```python
+from consumers.services import UsersService
+
+
+class Service:
+    def __init__(self, users: UsersService) -> None:
+        self._users = users
+
+    def message(self) -> str:
+        user = self._users.get_user("1")
+        return f"Hello from yaaf, {user['name']}"
+
+service = Service
+```
+
+## Service-to-Service Injection
+
+Services can depend on other services via type annotations. Example layout:
+
+```text
+consumers/
+  api/
+    users/
+      _service.py
+      _server.py
+    hello/
+      _service.py
+      _server.py
+```
+
+`consumers/api/users/_service.py`
+```python
+class Service:
+    def get_user(self, user_id: str) -> dict:
+        return {"id": user_id, "name": "Austin"}
+
+service = Service()
+```
+
+`consumers/api/hello/_service.py`
+```python
+from yaaf.services import UsersService
+
+
+class Service:
+    def __init__(self, users: UsersService) -> None:
+        self._users = users
+
+    def message(self) -> str:
+        user = self._users.get_user("1")
+        return f"Hello from yaaf, {user['name']}"
+
+service = Service
+```
+
+`consumers/api/hello/_server.py`
+```python
+from consumers.services import HelloService
+from yaaf import Request
+
+
+async def get(request: Request, service: HelloService):
+    return {"message": service.message(), "path": request.path}
+```
+
+## Running Another App
+
+```bash
+yaaf --app your_package.app:app
+```
+
+## Versioning
+
+This project uses calendar-based versions with a timestamp (UTC). To bump the version:
+
+```bash
+python scripts/bump_version.py
+```
+
+## Service Type Generation
+
+Every `yaaf` command regenerates `consumers/services.py` for type-checking. You can also run it explicitly:
+
+```bash
+yaaf gen-services
+```
+
+Dynamic route segments like `[name]` get Protocol stubs in the generated file since they are not valid import paths.

yaafcli-2026.2.4.180929/README.md

@@ -0,0 +1,164 @@
+# yaaf
+
+YAAF stands for "Yet Another ASGI Framework".
+
+A minimal Python ASGI app scaffold that discovers routes from the filesystem. It includes a tiny router and a CLI wrapper around `uvicorn`.
+
+## Design Goals and Opinions
+
+- **Filesystem-first routing.** Routes are inferred from the directory structure under `consumers/**/api` rather than declared with decorators. This keeps routing discoverable by looking at the tree.
+- **Explicit endpoint files.** Each route has `_server.py` and `_service.py` to separate request handling from domain logic.
+- **Dependency injection without wiring.** Services are registered automatically and injected by name/type, so handlers and services focus on behavior, not setup.
+- **Static-first routing precedence.** Static routes always win over dynamic segments, with warnings when a dynamic route would overlap a static route.
+- **Minimal core.** The framework is intentionally small and opinionated, leaving room for you to add auth, middleware, validation, etc.
+
+## Quickstart
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+
+# Run the built-in example routes
+yaaf --reload
+```
+
+Example routes:
+
+- `GET /api/hello`
+- `GET /api/<name>` (dynamic segment)
+
+## Routing Model
+
+Routes are inferred from the directory structure under any `consumers/**/api` directory.
+
+- Every route directory must contain `_server.py` and `_service.py`.
+- The route path is `/api/...` plus the sub-path after `api/`.
+- Dynamic segments use `[param]` directory names and are exposed as `params`/`path_params`.
+
+Example layout:
+
+```text
+consumers/
+  api/
+    users/
+      _server.py
+      _service.py
+    hello/
+      _server.py
+      _service.py
+    [name]/
+      _server.py
+      _service.py
+```
+
+## Handlers and Services
+
+In `_server.py`, export functions named after HTTP methods (lowercase): `get`, `post`, etc. The function signature is resolved via dependency injection:
+
+- `request` gives you the `yaaf.Request` object.
+- `params` or `path_params` provides dynamic route parameters.
+- Services are injected by type annotations.
+
+Example `_server.py`:
+
+```python
+from consumers.services import HelloService
+from yaaf import Request
+from yaaf.types import Params
+
+
+async def get(request: Request, service: HelloService, params: Params):
+    return {"message": service.message(), "path": request.path, "params": params}
+```
+
+In `_service.py`, expose a module-level `service` instance (or a callable like `Service` or `get_service`). Services are registered and can be injected into other services or handlers:
+
+```python
+from consumers.services import UsersService
+
+
+class Service:
+    def __init__(self, users: UsersService) -> None:
+        self._users = users
+
+    def message(self) -> str:
+        user = self._users.get_user("1")
+        return f"Hello from yaaf, {user['name']}"
+
+service = Service
+```
+
+## Service-to-Service Injection
+
+Services can depend on other services via type annotations. Example layout:
+
+```text
+consumers/
+  api/
+    users/
+      _service.py
+      _server.py
+    hello/
+      _service.py
+      _server.py
+```
+
+`consumers/api/users/_service.py`
+```python
+class Service:
+    def get_user(self, user_id: str) -> dict:
+        return {"id": user_id, "name": "Austin"}
+
+service = Service()
+```
+
+`consumers/api/hello/_service.py`
+```python
+from yaaf.services import UsersService
+
+
+class Service:
+    def __init__(self, users: UsersService) -> None:
+        self._users = users
+
+    def message(self) -> str:
+        user = self._users.get_user("1")
+        return f"Hello from yaaf, {user['name']}"
+
+service = Service
+```
+
+`consumers/api/hello/_server.py`
+```python
+from consumers.services import HelloService
+from yaaf import Request
+
+
+async def get(request: Request, service: HelloService):
+    return {"message": service.message(), "path": request.path}
+```
+
+## Running Another App
+
+```bash
+yaaf --app your_package.app:app
+```
+
+## Versioning
+
+This project uses calendar-based versions with a timestamp (UTC). To bump the version:
+
+```bash
+python scripts/bump_version.py
+```
+
+## Service Type Generation
+
+Every `yaaf` command regenerates `consumers/services.py` for type-checking. You can also run it explicitly:
+
+```bash
+yaaf gen-services
+```
+
+Dynamic route segments like `[name]` get Protocol stubs in the generated file since they are not valid import paths.

yaafcli-2026.2.4.180929/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yaafcli"
+version = "2026.02.04.180929"
+description = "Minimal ASGI app scaffold"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = ["uvicorn>=0.23"]
+license = { file = "LICENSE" }
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.13",
+  "Operating System :: OS Independent",
+  "Framework :: AsyncIO",
+  "Topic :: Internet :: WWW/HTTP",
+  "Topic :: Software Development :: Libraries",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=7.4", "pytest-asyncio>=0.23"]
+
+[project.scripts]
+yaaf = "yaaf.cli:main"
+
+[tool.setuptools]
+packages = ["yaaf"]
+
+[tool.setuptools.package-data]
+yaaf = ["py.typed"]
+
+[tool.mypy]
+python_version = "3.13"
+warn_return_any = true
+warn_unused_configs = true
+no_implicit_optional = true
+check_untyped_defs = true

yaafcli-2026.2.4.180929/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

yaafcli-2026.2.4.180929/tests/test_app_integration.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from yaaf.app import App
+from yaaf.gen_services import generate_services
+
+
+class DummySend:
+    def __init__(self) -> None:
+        self.messages: list[dict] = []
+
+    async def __call__(self, message: dict) -> None:
+        self.messages.append(message)
+
+
+class DummyReceive:
+    def __init__(self, body: bytes = b"") -> None:
+        self.body = body
+        self.sent = False
+
+    async def __call__(self) -> dict:
+        if self.sent:
+            return {"type": "http.request", "body": b"", "more_body": False}
+        self.sent = True
+        return {"type": "http.request", "body": self.body, "more_body": False}
+
+
+def _write_service(path: Path, code: str) -> None:
+    (path / "_service.py").write_text(code)
+
+
+def _write_server(path: Path, code: str) -> None:
+    (path / "_server.py").write_text(code)
+
+
+@pytest.mark.asyncio
+async def test_app_routes_and_params(tmp_path: Path) -> None:
+    base = tmp_path / "consumers" / "api"
+    hello = base / "hello"
+    dynamic = base / "[name]"
+    hello.mkdir(parents=True)
+    dynamic.mkdir(parents=True)
+    (tmp_path / "consumers" / "__init__.py").write_text("# package\n")
+
+    _write_service(
+        hello,
+        "class Service:\n"
+        "    def message(self) -> str:\n"
+        "        return 'hi'\n\n"
+        "service = Service()\n",
+    )
+    _write_server(
+        hello,
+        "from consumers.services import HelloService\n"
+        "from yaaf import Request\n\n"
+        "async def get(request: Request, service: HelloService):\n"
+        "    return {'message': service.message(), 'path': request.path}\n",
+    )
+
+    _write_service(
+        dynamic,
+        "class Service:\n"
+        "    def greet(self, name: str) -> str:\n"
+        "        return f'hello {name}'\n\n"
+        "service = Service()\n",
+    )
+    _write_server(
+        dynamic,
+        "from consumers.services import NameService\n"
+        "from yaaf.types import Params\n\n"
+        "async def get(params: Params, service: NameService):\n"
+        "    return {'message': service.greet(params['name'])}\n",
+    )
+
+    generate_services(consumers_dir=str(tmp_path / "consumers"))
+    app = App(consumers_dir=str(tmp_path / "consumers"))
+
+    send = DummySend()
+    scope = {"type": "http", "method": "GET", "path": "/api/hello", "headers": []}
+    await app(scope, DummyReceive(), send)
+    assert send.messages[0]["status"] == 200
+    assert b"hi" in send.messages[1]["body"]
+
+    send = DummySend()
+    scope = {"type": "http", "method": "GET", "path": "/api/austin", "headers": []}
+    await app(scope, DummyReceive(), send)
+    assert send.messages[0]["status"] == 200
+    assert b"austin" in send.messages[1]["body"]
+
+
+@pytest.mark.asyncio
+async def test_app_not_found(tmp_path: Path) -> None:
+    base = tmp_path / "consumers" / "api" / "hello"
+    base.mkdir(parents=True)
+    (tmp_path / "consumers" / "__init__.py").write_text("# package\n")
+    _write_service(base, "class Service:...\nservice = Service()\n")
+    _write_server(base, "async def get():...\n")
+
+    generate_services(consumers_dir=str(tmp_path / "consumers"))
+    app = App(consumers_dir=str(tmp_path / "consumers"))
+
+    send = DummySend()
+    scope = {"type": "http", "method": "GET", "path": "/api/missing", "headers": []}
+    await app(scope, DummyReceive(), send)
+    assert send.messages[0]["status"] == 404

yaafcli-2026.2.4.180929/tests/test_di.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import pytest
+
+from yaaf.di import DependencyResolver, ServiceRegistry
+
+
+class AlphaService:
+    def __init__(self) -> None:
+        self.value = "alpha"
+
+
+def test_registry_resolves_by_type_and_name() -> None:
+    class AlphaAlias:
+        pass
+
+    registry = ServiceRegistry(by_type={}, by_alias={})
+    alpha = registry.register(AlphaService(), aliases=["AlphaAlias"])
+
+    assert registry.resolve(AlphaService) is alpha
+    assert registry.resolve(AlphaAlias) is alpha
+
+
+def test_dependency_resolver_injects_context_and_services() -> None:
+    registry = ServiceRegistry(by_type={}, by_alias={})
+    alpha = registry.register(AlphaService(), aliases=[])
+    resolver = DependencyResolver(registry)
+
+    def handler(alpha: AlphaService, extra: str) -> tuple[str, str]:
+        return alpha.value, extra
+
+    result = resolver.call(handler, {"extra": "context"})
+    assert result == ("alpha", "context")
+
+
+def test_dependency_resolver_errors_on_missing_dependency() -> None:
+    registry = ServiceRegistry(by_type={}, by_alias={})
+    resolver = DependencyResolver(registry)
+
+    def handler(missing: AlphaService) -> str:
+        return missing.value
+
+    with pytest.raises(TypeError):
+        resolver.call(handler, {})

yaafcli-2026.2.4.180929/tests/test_loader.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from yaaf.loader import build_pattern, discover_routes
+
+
+def test_build_pattern_static_and_dynamic() -> None:
+    pattern, params, static_count, segment_count = build_pattern(["users", "[id]"] , prefix="api")
+    assert params == ["id"]
+    assert static_count == 1
+    assert segment_count == 2
+    assert pattern.startswith("^/api/")
+
+
+def test_discover_routes_missing_dir(tmp_path: Path) -> None:
+    routes, registry = discover_routes(str(tmp_path / "missing"))
+    assert routes == []
+    assert registry.by_type == {}
+    assert registry.by_alias == {}
+
+
+def test_discover_routes_dynamic_shadow_warning(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    base = tmp_path / "consumers" / "api"
+    hello = base / "hello"
+    dynamic = base / "[name]"
+    hello.mkdir(parents=True)
+    dynamic.mkdir(parents=True)
+
+    (hello / "_service.py").write_text("class Service:...\nservice = Service()\n")
+    (hello / "_server.py").write_text("async def get():...\n")
+    (dynamic / "_service.py").write_text("class Service:...\nservice = Service()\n")
+    (dynamic / "_server.py").write_text("async def get():...\n")
+
+    discover_routes(str(tmp_path / "consumers"))
+    captured = capsys.readouterr()
+    assert "dynamic route /api/[name] matches static route /api/hello" in captured.out

yaafcli-2026.2.4.180929/tests/test_responses.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from yaaf.responses import Response, as_response
+
+
+def test_as_response_string() -> None:
+    response = as_response("hello")
+    assert response.body == b"hello"
+    assert response.status == 200
+
+
+def test_as_response_bytes() -> None:
+    response = as_response(b"data")
+    assert response.body == b"data"
+    assert response.status == 200
+
+
+def test_as_response_dict_json() -> None:
+    response = as_response({"ok": True})
+    assert response.status == 200
+    assert b"\"ok\"" in response.body
+
+
+def test_as_response_tuple_status() -> None:
+    response = as_response(("nope", 404))
+    assert response.status == 404
+    assert response.body == b"nope"
+
+
+def test_response_with_status() -> None:
+    base = Response.text("hi")
+    updated = base.with_status(201)
+    assert updated.status == 201
+    assert updated.body == base.body

yaafcli-2026.2.4.180929/yaaf/__init__.py

@@ -0,0 +1,23 @@
+"""yaaf package exports with lazy loading to avoid circular imports."""
+
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+__all__ = ["App", "Request", "Response", "app"]
+
+
+def __getattr__(name: str) -> Any:
+    if name in {"App", "Request", "app"}:
+        app_module = importlib.import_module(f"{__name__}.app")
+        return getattr(app_module, name)
+    if name == "Response":
+        from .responses import Response
+
+        return Response
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+def __dir__() -> list[str]:
+    return sorted(__all__)

yaafcli-2026.2.4.180929/yaaf/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()