astris-python 0.1.0__py3-none-any.whl

astris/kernel.py

@@ -0,0 +1,230 @@
+import importlib
+import inspect
+import pkgutil
+import sys
+from collections.abc import Callable, Coroutine, Sequence
+from pathlib import Path
+from typing import Any, Literal
+
+from fastapi import APIRouter, FastAPI, HTTPException
+from fastapi.exceptions import RequestValidationError
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import ValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.middleware.sessions import SessionMiddleware
+from starlette.staticfiles import StaticFiles
+
+from astris.config import Settings, settings
+from astris.database import db
+from astris.http.static import PublicStaticMiddleware
+from astris.inertia import share
+from astris.inertia.exceptions import (
+    inertia_http_exception_handler,
+    inertia_validation_exception_handler,
+)
+from astris.inertia.shared import FlashMiddleware
+from astris.security import CSRFMiddleware
+
+
+class Astris:
+    """Core framework application class."""
+
+    def __init__(
+        self,
+        base_path: Path | None = None,
+        config: Settings | None = None,
+        title: str | None = None,
+        cors_origins: Sequence[str] | None = None,
+        enable_csrf: bool | None = None,
+        csrf_exempt_paths: Sequence[str] | None = None,
+        shared_props: dict[str, Any] | None = None,
+        database_url: str | None = None,
+        auto_create_tables: bool | None = None,
+        db_echo: bool | None = None,
+        secret_key: str | None = None,
+        session_cookie_name: str | None = None,
+        session_max_age: int | None = None,
+        session_https_only: bool | None = None,
+        session_same_site: Literal["lax", "strict", "none"] | None = None,
+        **fastapi_kwargs: Any,
+    ):
+        self.base_path = base_path or Path.cwd()
+        self.config = config or settings
+
+        self.cors_origins: Sequence[str] = (
+            cors_origins if cors_origins is not None else self.config.cors_origins
+        )
+        self.enable_csrf = (
+            enable_csrf if enable_csrf is not None else self.config.enable_csrf
+        )
+        self.csrf_exempt_paths: Sequence[str] = (
+            csrf_exempt_paths
+            if csrf_exempt_paths is not None
+            else self.config.csrf_exempt_paths
+        )
+        self.auto_create_tables = (
+            auto_create_tables
+            if auto_create_tables is not None
+            else self.config.auto_create_tables
+        )
+        self.secret_key = secret_key or self.config.app_key
+        self.session_cookie_name = (
+            session_cookie_name or self.config.session_cookie_name
+        )
+        self.session_max_age = (
+            session_max_age
+            if session_max_age is not None
+            else self.config.session_max_age
+        )
+        self.session_https_only = (
+            session_https_only
+            if session_https_only is not None
+            else self.config.session_https_only
+        )
+        self.session_same_site = (
+            session_same_site or self.config.session_same_site  # type: ignore[assignment]
+        )
+
+        # Configure database engine
+        db.configure(
+            url=database_url or self.config.database_url,
+            echo=db_echo if db_echo is not None else self.config.db_echo,
+            base_path=self.base_path,
+        )
+
+        if shared_props:
+            share(shared_props)
+
+        # Ensure project root is in sys.path for dynamic imports
+        base_path_str = str(self.base_path)
+        if base_path_str not in sys.path:
+            sys.path.insert(0, base_path_str)
+
+        app_title = title or self.config.app_name
+        app_debug = self.config.app_debug
+        self.app = FastAPI(title=app_title, debug=app_debug, **fastapi_kwargs)
+        self._boot()
+
+    def _boot(self) -> None:
+        self._configure_middleware()
+        self._configure_exception_handlers()
+        self._mount_static()
+        self._discover_modules()
+        if self.auto_create_tables:
+            db.create_all()
+
+    def _configure_exception_handlers(self) -> None:
+        """Register Inertia validation and HTTP exception handlers."""
+        self.app.add_exception_handler(
+            RequestValidationError,
+            inertia_validation_exception_handler,
+        )
+        self.app.add_exception_handler(
+            ValidationError,
+            inertia_validation_exception_handler,
+        )
+        self.app.add_exception_handler(
+            HTTPException,
+            inertia_http_exception_handler,
+        )
+        self.app.add_exception_handler(
+            StarletteHTTPException,
+            inertia_http_exception_handler,
+        )
+
+    def _configure_middleware(self) -> None:
+        """Register middleware stack (configured innermost to outermost)."""
+        # 1. CSRF protection (innermost HTTP security)
+        if self.enable_csrf:
+            self.app.add_middleware(
+                CSRFMiddleware,
+                exempt_paths=self.csrf_exempt_paths,
+            )
+
+        # 2. Flash message persistence
+        self.app.add_middleware(FlashMiddleware)
+
+        # 3. Encrypted/signed cookie sessions
+        if self.secret_key:
+            self.app.add_middleware(
+                SessionMiddleware,
+                secret_key=self.secret_key,
+                session_cookie=self.session_cookie_name,
+                max_age=self.session_max_age,
+                https_only=self.session_https_only,
+                same_site=self.session_same_site,
+            )
+
+        # 4. Public static assets (serves /favicon.ico, /robots.txt, and public/ files directly)
+        public_dir = self.base_path / "public"
+        if public_dir.exists():
+            self.app.add_middleware(PublicStaticMiddleware, public_dir=public_dir)
+
+        # 5. CORS configuration (outermost to handle preflight)
+        self.app.add_middleware(
+            CORSMiddleware,
+            allow_origins=list(self.cors_origins),
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+            expose_headers=["X-Inertia", "X-XSRF-TOKEN"],
+        )
+
+    def _mount_static(self) -> None:
+        """Mount compiled Vite frontend assets."""
+        build_dir = self.base_path / "public" / "build"
+        build_dir.mkdir(parents=True, exist_ok=True)
+        self.app.mount(
+            "/build",
+            StaticFiles(directory=str(build_dir), check_dir=False),
+            name="build",
+        )
+
+    def _discover_modules(self) -> None:
+        modules_dir = self.base_path / "app" / "modules"
+        if not modules_dir.exists():
+            return
+
+        registered_routers: set[int] = set()
+
+        for _, modname, ispkg in pkgutil.walk_packages(
+            [str(modules_dir)], prefix="app.modules."
+        ):
+            if ispkg:
+                continue
+
+            last_part = modname.split(".")[-1]
+
+            # Auto-import models to register SQLModel table metadata
+            if last_part.endswith(("_model", "_models")) or last_part in (
+                "models",
+                "model",
+            ):
+                try:
+                    importlib.import_module(modname)
+                except ImportError:
+                    pass
+
+            # Only scan controller files
+            if not last_part.endswith("_controller") and not last_part.startswith(
+                "controller"
+            ):
+                continue
+
+            module = importlib.import_module(modname)
+            for _, member in inspect.getmembers(module):
+                if (
+                    isinstance(member, APIRouter)
+                    and id(member) not in registered_routers
+                ):
+                    self.app.include_router(member)
+                    registered_routers.add(id(member))
+
+    async def __call__(
+        self,
+        scope: Any,
+        receive: Callable[..., Coroutine[Any, Any, Any]],
+        send: Callable[..., Coroutine[Any, Any, None]],
+    ) -> None:
+        """ASGI 3 interface."""
+        await self.app(scope, receive, send)

astris/routing/__init__.py

@@ -0,0 +1,31 @@
+from astris.routing.router import (
+    Body,
+    Controller,
+    Cookie,
+    Depends,
+    File,
+    Form,
+    Header,
+    Path,
+    PathParam,
+    Query,
+    Security,
+    UploadFile,
+    status,
+)
+
+__all__ = [
+    "Body",
+    "Controller",
+    "Cookie",
+    "Depends",
+    "File",
+    "Form",
+    "Header",
+    "Path",
+    "PathParam",
+    "Query",
+    "Security",
+    "UploadFile",
+    "status",
+]

astris/routing/router.py

@@ -0,0 +1,38 @@
+from fastapi import (
+    APIRouter,
+    Body,
+    Cookie,
+    Depends,
+    File,
+    Form,
+    Header,
+    Path,
+    Query,
+    Security,
+    UploadFile,
+    status,
+)
+
+# Alias to avoid name collisions with standard library pathlib.Path
+PathParam = Path
+
+
+class Controller(APIRouter):
+    """Core Astris Controller router."""
+
+
+__all__ = [
+    "Body",
+    "Controller",
+    "Cookie",
+    "Depends",
+    "File",
+    "Form",
+    "Header",
+    "Path",
+    "PathParam",
+    "Query",
+    "Security",
+    "UploadFile",
+    "status",
+]

astris/security/__init__.py

@@ -0,0 +1,3 @@
+from astris.security.csrf import CSRFMiddleware
+
+__all__ = ["CSRFMiddleware"]

astris/security/csrf.py

@@ -0,0 +1,100 @@
+import secrets
+from collections.abc import Sequence
+from typing import ClassVar
+
+from starlette.datastructures import MutableHeaders
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+
+class CSRFMiddleware:
+    """Cookie-to-header CSRF protection middleware.
+
+    Sets an XSRF-TOKEN cookie on responses and validates the incoming
+    X-XSRF-TOKEN (or X-CSRF-TOKEN) header against the cookie on state-changing requests.
+    """
+
+    SAFE_METHODS: ClassVar[frozenset[str]] = frozenset({"GET", "HEAD", "OPTIONS"})
+    COOKIE_NAME: ClassVar[str] = "XSRF-TOKEN"
+    HEADER_NAMES: ClassVar[tuple[str, ...]] = ("x-xsrf-token", "x-csrf-token")
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        cookie_name: str = "XSRF-TOKEN",
+        cookie_path: str = "/",
+        cookie_domain: str | None = None,
+        cookie_secure: bool = False,
+        cookie_samesite: str = "lax",
+        exempt_paths: Sequence[str] = (),
+    ) -> None:
+        self.app = app
+        self.cookie_name = cookie_name
+        self.cookie_path = cookie_path
+        self.cookie_domain = cookie_domain
+        self.cookie_secure = cookie_secure
+        self.cookie_samesite = cookie_samesite
+        self.exempt_paths = exempt_paths
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        request = Request(scope, receive=receive)
+        cookie_token = request.cookies.get(self.cookie_name)
+        new_token: str | None = None
+
+        if not cookie_token:
+            cookie_token = secrets.token_urlsafe(32)
+            new_token = cookie_token
+
+        # Validate state-changing methods (POST, PUT, PATCH, DELETE)
+        if request.method.upper() not in self.SAFE_METHODS and not self._is_exempt(
+            request.url.path
+        ):
+            header_token = None
+            for header_name in self.HEADER_NAMES:
+                if header_name in request.headers:
+                    header_token = request.headers[header_name]
+                    break
+
+            if (
+                not header_token
+                or not cookie_token
+                or not secrets.compare_digest(header_token, cookie_token)
+            ):
+                response = JSONResponse(
+                    status_code=419,
+                    content={"message": "CSRF token mismatch or missing."},
+                )
+                await response(scope, receive, send)
+                return
+
+        if new_token is not None:
+            token_str: str = new_token
+
+            async def send_wrapper(message: Message) -> None:
+                if message["type"] == "http.response.start":
+                    headers = MutableHeaders(scope=message)
+                    cookie_parts = [
+                        f"{self.cookie_name}={token_str}",
+                        f"Path={self.cookie_path}",
+                        f"SameSite={self.cookie_samesite.capitalize()}",
+                    ]
+                    if self.cookie_domain:
+                        cookie_parts.append(f"Domain={self.cookie_domain}")
+                    if self.cookie_secure:
+                        cookie_parts.append("Secure")
+
+                    headers.append("set-cookie", "; ".join(cookie_parts))
+
+                await send(message)
+
+            await self.app(scope, receive, send_wrapper)
+        else:
+            await self.app(scope, receive, send)
+
+    def _is_exempt(self, path: str) -> bool:
+        return any(path.startswith(exempt) for exempt in self.exempt_paths)

astris_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: astris-python
+Version: 0.1.0
+Summary: The modern full-stack web framework for Python. Everything you need to go from idea to orbit; for developers who want to build and ship at escape velocity.
+Author: Felix Gomez
+Author-email: Felix Gomez <felix@felixgomez.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 2
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: alembic>=1.19.1
+Requires-Dist: fastapi>=0.141.1
+Requires-Dist: itsdangerous>=2.2.0
+Requires-Dist: pwdlib[argon2]>=0.3.1
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: pydantic-settings>=2.15.0
+Requires-Dist: sqlmodel>=0.0.39
+Requires-Dist: typer>=0.27.1
+Requires-Dist: uvicorn[standard]>=0.52.4
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+<p align="center" style="padding: 20px 0 10px 0;">
+  <a href="https://github.com/TheFelixGomez/astris">
+    <img src="https://raw.githubusercontent.com/TheFelixGomez/astris/main/.github/assets/astris-logo-name.png" alt="Astris" width="380">
+  </a>
+</p>
+
+<p align="center">
+  <strong>The modern full-stack web framework for Python.</strong><br>
+  Full-stack simplicity with modern Python performance.
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/astris-python/"><img src="https://img.shields.io/pypi/v/astris-python.svg" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/astris-python/"><img src="https://img.shields.io/pypi/pyversions/astris-python.svg" alt="Python Versions"></a>
+  <a href="https://github.com/TheFelixGomez/astris/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
+</p>
+
+> ⚠️ **Early Alpha**: Astris is currently in active alpha development. APIs and features may undergo breaking changes until production-ready status is confirmed. Feedback, bug reports, and ideas are welcome!
+
+---
+
+## What is Astris?
+
+**Astris** bridges the gap between the rapid, joyful developer experience of classic full-stack frameworks (like Laravel and Rails) and the raw performance, modern typing, and async concurrency of **FastAPI** and **Python 3.11+**.
+
+By combining **FastAPI**, **Inertia.js**, **Vue 3**, **Tailwind CSS v4**, and **SQLModel**, Astris lets you build rich, dynamic single-page applications without the overhead of maintaining separate API layers or complex state synchronization.
+
+---
+
+## 🌟 Key Features
+
+* **⚡ Lightning-Fast Core**: ASGI performance powered by FastAPI and Uvicorn with auto-generated OpenAPI & Swagger documentation.
+* **🧩 Modern Monolith with Inertia.js**: Render Vue 3 components directly from FastAPI controllers with full server-side state hydration and zero REST boilerplate.
+* **🛡️ Production-Ready Authentication**: Cryptographically signed cookie sessions, OWASP-standard **Argon2id** password hashing (`pwdlib`), and full-stack auth starter kit.
+* **🗄️ SQLModel & Alembic Database Engine**: Unified declarative models, DTOs, and automatic schema migrations out-of-the-box.
+* **⚙️ Type-Safe Centralized Configuration**: Powered by `pydantic-settings` for `.env` management, type casting, and fail-fast startup validation.
+* **🪐 Orbit CLI**: An artisan developer CLI for scaffolding modules, generating migrations, and serving full-stack applications with hot-reloading.
+* **🎨 Tailwind CSS v4 Pre-configured**: Instant zero-config styling powered by `@tailwindcss/vite`.
+
+---
+
+## 🚀 Quickstart
+
+Create a new full-stack Astris application in seconds using `uvx` (or `pipx`):
+
+```bash
+# 1. Create a new project
+uvx --from astris-python astris new my_app
+
+# Or install globally as a CLI tool:
+# uv tool install astris-python
+# astris new my_app
+
+# 2. Enter directory and install frontend dependencies
+cd my_app
+npm install
+
+# 3. Start full-stack development server (FastAPI + Vite HMR)
+uv run orbit serve
+```
+
+Open **`http://localhost:8000`** in your browser. Your full-stack app with authentication, Inertia.js, and SQLite is live!
+
+---
+
+## 💡 How It Feels
+
+### 1. Controllers & Inertia Rendering
+Write clean, expressive controllers that return frontend views or JSON seamlessly:
+
+```python
+from astris.auth import AuthUser, auth_required
+from astris.inertia import InertiaResponse
+from astris.routing import Controller
+
+controller = Controller(prefix="/dashboard", dependencies=[auth_required])
+
+
+@controller.get("/")
+async def dashboard_page(request: Request, user: AuthUser) -> InertiaResponse:
+    # Props are passed directly to Vue 3 with $page.props
+    return InertiaResponse(request, "Dashboard", props={"username": user["name"]})
+```
+
+### 2. Unified SQLModel Models
+Define database tables and validation schemas in a single declarative model:
+
+```python
+from astris.database import Field, SQLModel
+
+
+class ArticleBase(SQLModel):
+    title: str = Field(index=True)
+    content: str
+    is_published: bool = Field(default=False)
+
+
+class Article(ArticleBase, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+
+
+class ArticleCreate(ArticleBase):
+    pass
+```
+
+### 3. Frontend Views (Vue 3 + Inertia)
+Build dynamic reactive pages without configuring client-side routers:
+
+```vue
+<script setup lang="ts">
+import { Head, Link } from '@inertiajs/vue3'
+
+defineProps<{
+  username: string
+}>()
+</script>
+
+<template>
+  <Head title="Dashboard" />
+  <div class="min-h-screen bg-slate-950 text-slate-100 p-8">
+    <h1 class="text-3xl font-bold">Welcome back, {{ username }}!</h1>
+  </div>
+</template>
+```
+
+---
+
+## 🪐 The Orbit CLI
+
+Astris comes equipped with **Orbit**, a developer toolkit for rapid development:
+
+```bash
+# Start FastAPI backend + Vite frontend concurrently
+uv run orbit serve
+
+# Scaffold a new domain module (controller, service, model)
+uv run orbit make:module billing
+
+# Create and apply database migrations
+uv run orbit make:migration "create_billing_table"
+uv run orbit migrate
+
+# Generate encryption keys
+uv run orbit key:generate
+```
+
+---
+
+## 📂 Project Architecture
+
+Astris structures projects with a modular, **Domain-Driven Design** that grows gracefully:
+
+```
+my_app/
+├── app/
+│   ├── core/
+│   │   └── config.py        # Centralized Pydantic settings & .env loading
+│   └── modules/
+│       ├── auth/            # Authentication domain (controller, service, model)
+│       └── welcome/         # Welcome domain
+├── database/
+│   └── migrations/          # Alembic database migration versions
+├── resources/
+│   ├── css/
+│   │   └── app.css          # Tailwind CSS v4 styling
+│   ├── js/
+│   │   ├── Pages/           # Inertia Vue 3 views & components
+│   │   └── app.ts           # Vue entrypoint
+│   └── views/
+│       └── root.html        # HTML shell template
+├── .env                     # App configuration & APP_KEY
+└── pyproject.toml           # Python dependencies
+```
+
+---
+
+## 🙏 Acknowledgments
+
+Astris is built upon the work of giants. Huge gratitude to the incredible open-source projects and creators that make Astris possible:
+
+* **[FastAPI](https://fastapi.tiangolo.com/) & [SQLModel](https://sqlmodel.tiangolo.com/)** by [Tiangolo](https://github.com/tiangolo) - for setting the standard in modern Python type safety, speed, and ergonomics.
+* **[Inertia.js](https://inertiajs.com/)** by [Jonathan Reinink](https://github.com/reinink) - for the modern monolith architecture that bridges backend controllers and frontend SPAs without API boilerplate.
+* **[Vue.js](https://vuejs.org/)** by [Evan You](https://github.com/yyx990803) - for the approachable and performant frontend component framework.
+* **[Starlette](https://www.starlette.io/) & [Uvicorn](https://www.uvicorn.org/)** by [Encode](https://www.encode.io/) - for the lightning-fast ASGI toolkit and web server engine.
+* **[Pydantic](https://docs.pydantic.dev/)** by [Samuel Colvin](https://github.com/samuelcolvin) & team - for rock-solid runtime data validation and centralized settings.
+* **[Tailwind CSS](https://tailwindcss.com/)** by [Tailwind Labs](https://github.com/tailwindlabs) - for zero-config utility-first styling.
+* **[Laravel](https://laravel.com/)** by [Taylor Otwell](https://github.com/taylorotwell) - for inspiring developer-first framework craftsmanship.
+
+---
+
+## 📄 License
+
+The Astris framework is open source and licensed under the terms of the MIT license.
+
+Built with ❤️ by [Felix Gomez](https://github.com/TheFelixGomez).

astris_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+astris/__init__.py,sha256=D7FkbtDHx3Kui4UTTYjuG24jguofpRADh6tTzbGgn3c,113
+astris/assets/favicon.ico,sha256=qcGguPAGFmUGh4IhE859vx8EM7Euo6OQan5XxZcrLhw,15086
+astris/auth/__init__.py,sha256=8T1YUiPbyhXy25SH-4Ko6CzHis6ReD2-_LpVuRNlcbc,539
+astris/auth/installer.py,sha256=ZyBQui6aA5yNBN8X9HUp6UTVuwvO5W3tDVsag6TJtLQ,21631
+astris/auth/session.py,sha256=elFjFQxhM-NqvcNQv7OPue0WRY7RUiitFlP_kC42vu4,7955
+astris/cli.py,sha256=3a4_dCYpx2zTe8t3wgCyi42BRFn4indFcGaNucQN2Os,13518
+astris/config.py,sha256=P15SJD-1NsnjFYYtEVeeBEq67w_sOTsSabkxAk8wKGc,1260
+astris/database/__init__.py,sha256=8FFa-LEhkcNYxshIBOnUOMB6rKcLlLBNHVwlH7_X3Dk,375
+astris/database/migrations.py,sha256=xjbiMpRsAI8LCtzpTaWhQmmPjuVhO-szTiX7Xny2Rms,7045
+astris/database/session.py,sha256=9JNeG-UA3df7TQ7AVtaA9PjBjf__mlZF_oAQxpDWf1E,3151
+astris/http/__init__.py,sha256=oa2xsHdse6FGNxO0bAqP1p9iySl6i_NtVopxOnYUzlw,504
+astris/http/static.py,sha256=x6ysvjXVJd2pm6VbNt96VC7fT6rNbolF8Y43VG0cMVI,1191
+astris/inertia/__init__.py,sha256=220WVzFB8ppZahAmrKyMmcmsyotfiyGeOnrClInL5jA,163
+astris/inertia/exceptions.py,sha256=W-4Xi3WeSBa8FP5UKhT4XYmu-eoze6GgTkaDPo018W4,4583
+astris/inertia/response.py,sha256=P3jjUGfL5Bpz2e4Wy4f7kylJ7P3_QeMTY4OfSfX3qnw,3213
+astris/inertia/shared.py,sha256=loVqwOPE0N4WztNNn4wNWhPlj240xdLgx65RRUepyeU,6095
+astris/inertia/vite.py,sha256=cqtwqPmdxsvsAV0Ja0YrY1TPHZ14oKipS9c7UaNALIY,3211
+astris/installer.py,sha256=S8tNo6SF1MVlEWwDulEsG13cP6FBRMFc4qZKkKVFAK8,22042
+astris/kernel.py,sha256=qaIcnf080BiRNoauHIOB6TPso0mjc5Aqp7aYD9DqV2I,8278
+astris/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astris/routing/__init__.py,sha256=g1urCz-1r8CkPae-7UMbIYh7YS_VeIafa7cGtol9vV0,401
+astris/routing/router.py,sha256=NkFxYcqZCJeBVu0ncGLdYjSKg1JpKDfhr-73XEn3Vgc,530
+astris/security/__init__.py,sha256=RxdeOT3ooBox0IXFZCiM2vOnm6q0k-T9QZPt7PbPAbs,78
+astris/security/csrf.py,sha256=sO_rJ3qYAChLwNO545-OpTy-McwyPu2Rhqa_0Rhy1RI,3683
+astris_python-0.1.0.dist-info/licenses/LICENSE,sha256=em4jHkBMoTK2MVxCtwUUBKAKJYEn2tuXviBDN_Fbdrw,1077
+astris_python-0.1.0.dist-info/WHEEL,sha256=4OL6Foqnnp3xRY5wMkjgc25_i5YJC6dKsC6LPcjqEoU,80
+astris_python-0.1.0.dist-info/entry_points.txt,sha256=dPbhCstaZa3L5pAfgbqrqTH4T7zwf6oRvjxt3GZqtqE,135
+astris_python-0.1.0.dist-info/METADATA,sha256=kxo4EtdyoAS0a2Y5jYhQ2cY_HT6P6jV84jUDNdZW_IU,9634
+astris_python-0.1.0.dist-info/RECORD,,

astris_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.5
+Root-Is-Purelib: true
+Tag: py3-none-any

astris_python-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+astris = astris.installer:installer_cli
+astris-python = astris.installer:installer_cli
+orbit = astris.cli:orbit_cli
+