swiftpy-framework 0.1.0__py3-none-any.whl

swiftpy/console/commands/start.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Any
+
+import uvicorn
+
+from swiftpy.core.config import Config, ConfigurationError
+
+
+def _first_configured(*values: Any) -> Any:
+    """Return the first explicitly configured value, preserving integer 0 and boolean False."""
+    for value in values:
+        if value is not None and value != "":
+            return value
+    return None
+
+
+class StartCommand:
+    @staticmethod
+    def register(
+        subparsers: argparse._SubParsersAction[argparse.ArgumentParser],
+    ) -> None:
+        parser = subparsers.add_parser(
+            "start",
+            help="Boot the application server",
+        )
+
+        parser.add_argument(
+            "target",
+            nargs="?",
+            default=None,
+            help="Application ASGI target (default: from config or 'main:app')",
+        )
+
+        parser.add_argument(
+            "--host",
+            dest="host",
+            default=None,
+            help="Bind socket to this host (default: from config or '127.0.0.1')",
+        )
+
+        parser.add_argument(
+            "--port",
+            dest="port",
+            type=int,
+            default=None,
+            help="Bind socket to this port (default: from config or 8000)",
+        )
+
+        parser.add_argument(
+            "--workers",
+            dest="workers",
+            type=int,
+            default=None,
+            help="Number of worker processes (default: 1)",
+        )
+
+        parser.add_argument(
+            "--reload",
+            dest="reload",
+            action="store_true",
+            default=False,
+            help="Enable auto-reload on code change (default: False)",
+        )
+
+        parser.add_argument(
+            "--env-file",
+            dest="env_file",
+            default=None,
+            help="Environment configuration file path (e.g. '.env')",
+        )
+
+        parser.add_argument(
+            "--access-log",
+            dest="access_log",
+            action=argparse.BooleanOptionalAction,
+            default=None,
+            help="Enable or disable uvicorn access log",
+        )
+
+        parser.add_argument(
+            "--log-level",
+            dest="log_level",
+            default=None,
+            help="Logging level (critical, error, warning, info, debug, trace)",
+        )
+
+        parser.set_defaults(
+            _handler=StartCommand.handle,
+        )
+
+    @staticmethod
+    def handle(args: argparse.Namespace) -> None:
+        try:
+            config = Config.load()
+        except (ConfigurationError, OSError, ValueError, RuntimeError, SyntaxError):
+            config = Config()
+
+        target = (
+            args.target
+            or config.get("server.target")
+            or config.get("app.target")
+            or "main:app"
+        )
+        host = (
+            args.host
+            or config.get("server.host")
+            or config.get("app.host")
+            or "127.0.0.1"
+        )
+        raw_port = _first_configured(
+            args.port,
+            config.get("server.port"),
+            config.get("app.port"),
+            8000,
+        )
+        port = int(raw_port)
+        if port < 0 or port > 65535:
+            sys.stderr.write(
+                f"Error: invalid port {port} (must be between 0 and 65535).\n"
+            )
+            raise SystemExit(1)
+
+        raw_workers = _first_configured(
+            args.workers,
+            config.get("server.workers"),
+            1,
+        )
+        workers = int(raw_workers)
+        if workers < 1:
+            sys.stderr.write(
+                f"Error: invalid worker count {workers} (must be >= 1).\n"
+            )
+            raise SystemExit(1)
+        reload = bool(args.reload)
+        env_file = args.env_file or config.get("server.env_file")
+
+        if reload and workers > 1:
+            sys.stderr.write(
+                "Error: --reload cannot be used with multiple workers (--workers > 1).\n"
+            )
+            raise SystemExit(1)
+
+        uvicorn_kwargs: dict[str, Any] = {
+            "host": host,
+            "port": port,
+            "reload": reload,
+        }
+        if workers > 1:
+            uvicorn_kwargs["workers"] = workers
+        if env_file:
+            uvicorn_kwargs["env_file"] = env_file
+
+        access_log_opt = (
+            args.access_log
+            if getattr(args, "access_log", None) is not None
+            else config.get("server.access_log")
+        )
+        if access_log_opt is not None:
+            uvicorn_kwargs["access_log"] = bool(access_log_opt)
+
+        log_level_opt = getattr(args, "log_level", None) or config.get("server.log_level")
+        if log_level_opt:
+            uvicorn_kwargs["log_level"] = str(log_level_opt).lower()
+
+        uvicorn.run(target, **uvicorn_kwargs)
+
+
+__all__ = ["StartCommand"]

swiftpy/console/commands/storage.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from swiftpy.core.config import Config
+
+
+def _paint(text: str, code: str) -> str:
+    if sys.stdout.isatty() and "NO_COLOR" not in os.environ:
+        return f"\033[{code}m{text}\033[0m"
+    return text
+
+
+class StorageCommand:
+    """Console commands for filesystem and storage management."""
+
+    @staticmethod
+    def register(
+        subparsers: argparse._SubParsersAction[argparse.ArgumentParser],
+    ) -> None:
+        link_parser = subparsers.add_parser(
+            "storage:link",
+            help="Create the symbolic links configured for the application",
+        )
+        link_parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Recreate existing symbolic links",
+        )
+        link_parser.set_defaults(_handler=StorageCommand.handle_link)
+
+        storage_group = subparsers.add_parser(
+            "storage",
+            help="Manage application storage links and operations",
+        )
+        storage_sub = storage_group.add_subparsers(
+            dest="storage_subcommand",
+            required=False,
+        )
+        sub_link = storage_sub.add_parser(
+            "link",
+            help="Create the symbolic links configured for the application",
+        )
+        sub_link.add_argument(
+            "--force",
+            action="store_true",
+            help="Recreate existing symbolic links",
+        )
+        sub_link.set_defaults(_handler=StorageCommand.handle_link)
+
+    @staticmethod
+    def handle_link(args: argparse.Namespace) -> None:
+        force = getattr(args, "force", False)
+        try:
+            cfg = Config.get_instance()
+            target_path = Path(
+                str(cfg.get("filesystems.disks.public.root", "storage/app/public"))
+            ).resolve()
+        except (RuntimeError, ValueError, KeyError):
+            target_path = Path("storage/app/public").resolve()
+
+        link_path = Path("public/storage").resolve()
+
+        target_path.mkdir(parents=True, exist_ok=True)
+        link_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if link_path.is_symlink() or link_path.exists():
+            if force:
+                if link_path.is_symlink():
+                    link_path.unlink()
+                elif link_path.is_dir():
+                    shutil.rmtree(link_path)
+                else:
+                    link_path.unlink()
+            else:
+                msg = _paint(f"The [{link_path.relative_to(Path.cwd())}] link already exists.", "33")
+                print(msg)
+                return
+
+        try:
+            os.symlink(target_path, link_path, target_is_directory=True)
+            rel_link = (
+                link_path.relative_to(Path.cwd())
+                if link_path.is_relative_to(Path.cwd())
+                else link_path
+            )
+            rel_target = (
+                target_path.relative_to(Path.cwd())
+                if target_path.is_relative_to(Path.cwd())
+                else target_path
+            )
+            msg = _paint(
+                f"The [{rel_link}] link has been connected to [{rel_target}].",
+                "32",
+            )
+            print(msg)
+        except OSError as exc:
+            err = _paint(f"Failed to create storage link: {exc}", "31")
+            print(err, file=sys.stderr)
+            sys.exit(1)

swiftpy/console/loader.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+
+from swiftpy.core.application import Application
+
+
+def load_application(target: str = "main:app") -> Application:
+    """Import `module:attribute` from the current project and return the Application."""
+    module_name, _, attribute = target.partition(":")
+    project_root = str(Path.cwd())
+    if project_root not in sys.path:
+        sys.path.insert(0, project_root)
+
+    module = importlib.import_module(module_name)
+    app = getattr(module, attribute or "app")
+    if not isinstance(app, Application):
+        raise TypeError(f"{target!r} is not a SwiftPY Application")
+    return app

swiftpy/console/stubs/__init__.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+STUBS_DIR = Path(__file__).resolve().parent
+
+
+def get_stub(name: str) -> str:
+    """
+    Load a stub template string by name from the stubs directory.
+    Supports both dotted and underscore conventions (e.g. 'migration.create' or 'migration_create').
+    """
+    cleaned = name.removesuffix(".stub")
+    candidates = (
+        STUBS_DIR / f"{cleaned}.stub",
+        STUBS_DIR / f"{cleaned.replace('_', '.')}.stub",
+        STUBS_DIR / f"{cleaned.replace('.', '_')}.stub",
+    )
+    for path in candidates:
+        if path.is_file():
+            return path.read_text(encoding="utf-8")
+
+    raise FileNotFoundError(f"Stub file not found for name '{name}' in {STUBS_DIR}")
+
+
+__all__ = ["STUBS_DIR", "get_stub"]

swiftpy/console/stubs/controller.stub

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from swiftpy.http.request import Request
+from swiftpy.http.response import Response, json_response
+
+
+class {class_name}:
+    """
+    HTTP Controller for handling request endpoints.
+    """
+
+    async def index(self, request: Request) -> Response:
+        return json_response({"message": "Hello from {class_name}"})
+

swiftpy/console/stubs/event.stub

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True, frozen=True)
+class {class_name}:
+    """
+    Domain event carrying immutable state.
+    """
+
+    payload: dict[str, Any]
+

swiftpy/console/stubs/job.stub

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any
+
+from swiftpy.queue.job import Job
+
+
+class {class_name}(Job):
+    """
+    Asynchronous queued background job.
+    """
+
+    tries: int = 3
+    backoff: int = 5
+
+    def __init__(self, **payload: Any) -> None:
+        self.payload = payload
+
+    async def handle(self) -> None:
+        """Execute the job's background logic."""
+        pass
+

swiftpy/console/stubs/listener.stub

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class {class_name}:
+    """
+    Asynchronous event listener.
+    """
+
+    async def handle(self, event: Any) -> None:
+        """Handle the dispatched event."""
+        pass
+

swiftpy/console/stubs/mail.stub

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any
+
+from swiftpy.mail import Mailable, MailMessage
+
+
+class {class_name}(Mailable):
+    """{class_name} mailable definition."""
+
+    def __init__(self) -> None:
+        pass
+
+    def build(self) -> MailMessage:
+        return MailMessage(
+            subject="{class_name}",
+            to=[],
+            text_body="Hello from {class_name}!",
+        )
+

swiftpy/console/stubs/middleware.stub

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from swiftpy.http.middleware import Handler, Middleware
+from swiftpy.http.request import Request
+from swiftpy.http.response import Response
+
+
+class {class_name}(Middleware):
+    """
+    ASGI Middleware for request preprocessing and response handling.
+    """
+
+    async def handle(self, request: Request, next_handler: Handler) -> Response:
+        response = await next_handler(request)
+        return response
+

swiftpy/console/stubs/migration.alter.stub

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from swiftpy.database.migrations import Blueprint, Migration, Schema
+
+
+class {class_name}(Migration):
+    async def up(self) -> None:
+        def define(table: Blueprint) -> None:
+            pass  # table.string("column_name").nullable()
+
+        await Schema.table("{table_name}", define)
+
+    async def down(self) -> None:
+        def define(table: Blueprint) -> None:
+            pass  # table.drop_column("column_name")
+
+        await Schema.table("{table_name}", define)

swiftpy/console/stubs/migration.api_keys.stub

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from swiftpy.database.migrations import Blueprint, Migration, Schema
+
+
+class {class_name}(Migration):
+    async def up(self) -> None:
+        def define(table: Blueprint) -> None:
+            table.id()
+            table.string("name")
+            table.string("key_prefix", length=64).unique().index()
+            table.string("key_hash", length=128)
+            table.boolean("is_active").default(True)
+            table.boolean("revoked").default(False)
+            table.timestamp("expires_at").nullable()
+            table.timestamps()
+
+        await Schema.create("{table_name}", define)
+
+    async def down(self) -> None:
+        await Schema.drop_if_exists("{table_name}")
+

swiftpy/console/stubs/migration.blank.stub

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from swiftpy.database.migrations import Migration
+
+
+class {class_name}(Migration):
+    async def up(self) -> None:
+        pass
+
+    async def down(self) -> None:
+        pass

swiftpy/console/stubs/migration.create.stub

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from swiftpy.database.migrations import Blueprint, Migration, Schema
+
+
+class {class_name}(Migration):
+    async def up(self) -> None:
+        def define(table: Blueprint) -> None:
+            table.id()
+            table.timestamps()
+
+        await Schema.create("{table_name}", define)
+
+    async def down(self) -> None:
+        await Schema.drop_if_exists("{table_name}")

swiftpy/console/stubs/migration.stub

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from swiftpy.database.migrations import Migration
+
+
+class {class_name}(Migration):
+    async def up(self) -> None:
+        pass
+
+    async def down(self) -> None:
+        pass

swiftpy/console/stubs/migration.update.stub

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from swiftpy.database.migrations import Blueprint, Migration, Schema
+
+
+class {class_name}(Migration):
+    async def up(self) -> None:
+        def define(table: Blueprint) -> None:
+            pass  # table.string("column_name").nullable()
+
+        await Schema.table("{table_name}", define)
+
+    async def down(self) -> None:
+        def define(table: Blueprint) -> None:
+            pass  # table.drop_column("column_name")
+
+        await Schema.table("{table_name}", define)

swiftpy/console/stubs/model.stub

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import ClassVar
+
+from swiftpy.database.orm import Model
+
+
+class {class_name}(Model):
+    """{class_name} model."""
+
+    __table__ = "{table_name}"
+    __fillable__: ClassVar[list[str]] = []
+
+    id: int
+    created_at: datetime
+    updated_at: datetime

swiftpy/console/stubs/provider.stub

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from swiftpy.core.providers.base import ServiceProvider
+
+
+class {class_name}(ServiceProvider):
+    """
+    Modular application service provider.
+    """
+
+    def register(self) -> None:
+        """Bind services and interfaces into the DI container."""
+        pass
+
+    def boot(self) -> None:
+        """Boot application services, attach listeners, and warm caches."""
+        pass
+

swiftpy/console/stubs/repository.stub

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class {class_name}:
+    """{class_name} data access repository."""
+
+    def __init__(self) -> None:
+        pass

swiftpy/console/stubs/request.stub

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any
+
+from swiftpy.validation.form_request import FormRequest
+
+
+class {class_name}(FormRequest):
+    """{class_name} validation request."""
+
+    def rules(self) -> dict[str, Any]:
+        """Define validation rules for the incoming request."""
+        return {
+            # "email": "required|email",
+            # "password": "required|min:8",
+        }

swiftpy/console/stubs/resource.stub

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class {class_name}:
+    """{class_name} API resource transformer."""
+
+    def __init__(self, resource: Any) -> None:
+        self.resource = resource
+
+    def to_dict(self) -> dict[str, Any]:
+        """Transform the resource into an array/dict."""
+        return {
+            "id": getattr(self.resource, "id", None),
+        }
+
+    @classmethod
+    def collection(cls, items: list[Any]) -> list[dict[str, Any]]:
+        """Transform a collection of resources."""
+        return [cls(item).to_dict() for item in items]

swiftpy/console/stubs/schema.stub

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class {class_name}:
+    """{class_name} data schema."""
+
+    schema: dict[str, Any] = {
+        # "id": int,
+        # "name": str,
+    }

swiftpy/console/stubs/seeder.stub

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from swiftpy.database.seeder import Seeder
+
+
+class {class_name}(Seeder):
+    """
+    Database seeder for generating and seeding records.
+    """
+
+    async def run(self) -> None:
+        """Execute the database seed operations."""
+        pass
+

swiftpy/console/stubs/service.stub

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class {class_name}:
+    """{class_name} service."""
+
+    def __init__(self) -> None:
+        pass