fyro 0.1.0__tar.gz

fyro-0.1.0/LICENSE

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

fyro-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: fyro
+Version: 0.1.0
+Summary: A Django-feeling web framework on top of FastAPI: one model class gives you a table, an API, migrations, auth and an admin.
+Keywords: fastapi,django,web framework,orm,admin,postgres,sqlalchemy
+Author: Chinmay Talnikar
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Dist: alembic>=1.20.1
+Requires-Dist: asyncpg>=0.32.0
+Requires-Dist: fastapi>=0.159.1
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: pwdlib[argon2]>=0.3.1
+Requires-Dist: pydantic>=2.14.1
+Requires-Dist: pydantic-settings>=2.16.1
+Requires-Dist: sqlalchemy[asyncio]>=2.1.6
+Requires-Dist: typer>=0.27.3
+Requires-Dist: uvicorn>=0.54.0
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/Carnage725/fyro
+Project-URL: Documentation, https://carnage725.github.io/fyro/
+Project-URL: Source, https://github.com/Carnage725/fyro
+Project-URL: Issues, https://github.com/Carnage725/fyro/issues
+Project-URL: Changelog, https://github.com/Carnage725/fyro/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# fyro
+
+**Fast, Yet Ridiculously Opinionated.** A web framework on top of FastAPI that feels like Django.
+
+FastAPI is the engine. fyro adds what a project needs around it, with one obvious place for everything: one model class gives you a Postgres table, `Create`/`Read`/`Update` schemas, a REST API with docs, migrations and an admin page. Database sessions, a command line, users, login and permissions are built in.
+
+```python
+# blog/models.py
+from fyro import Field, Model
+
+
+class Post(Model):
+    title: str = Field(max_length=200)
+    body: str
+    secret: str = Field(write_only=True)
+    published: bool = False
+```
+
+That class is the table `blog_post`, the API at `/api/blog/post` (list with filters, search, ordering and paging; get; create; patch; delete) and the admin page at `/admin/blog/post`. Queries need no session code:
+
+```python
+posts = await Post.objects.filter(published=True).order_by("-id").limit(10).all()
+```
+
+## Quickstart
+
+Needs Python 3.12+, Docker (for Postgres) and [uv](https://docs.astral.sh/uv/) or pip.
+
+```bash
+uv venv && source .venv/bin/activate
+uv pip install fyro
+
+fyro new mysite && cd mysite
+docker compose up -d --wait
+python manage.py startapp blog
+# write blog/models.py, then in mysite/settings.py:
+#     installed_apps: list[str] = ["fyro.auth", "blog"]
+python manage.py makemigrations
+python manage.py migrate
+python manage.py createsuperuser
+python manage.py runserver        # http://127.0.0.1:8000/docs and /admin
+```
+
+The full walkthrough and the guides are in [`docs/`](docs/index.md): settings, models, querying, the automatic API, migrations, the command line, auth and permissions, the admin, and security notes.
+
+## Status
+
+**v0.1, alpha.** PostgreSQL only. Relations between models come in v0.2; see [what v0.1 does not do](docs/limitations.md). The plan and the history of every design decision are in [`PLAN.md`](PLAN.md) and [`BUILD_PROMPT.md`](BUILD_PROMPT.md).
+
+## Development
+
+```bash
+uv sync                     # install dependencies
+docker compose up -d        # Postgres 16 on localhost:5432 (user, password, db: fyro)
+uv run pytest               # tests, in random order (pytest-randomly)
+uv run ruff check           # lint
+uv run --only-group docs zensical serve   # docs at http://127.0.0.1:8000
+```
+
+How tests are written and attacked is described in [`test.md`](test.md).
+
+## License
+
+[MIT](LICENSE). The admin bundles [htmx](https://htmx.org) (0BSD) and [JetBrains Mono](https://www.jetbrains.com/lp/mono/) (OFL-1.1); their licenses are in `src/fyro/admin/static/`.

fyro-0.1.0/README.md

@@ -0,0 +1,64 @@
+# fyro
+
+**Fast, Yet Ridiculously Opinionated.** A web framework on top of FastAPI that feels like Django.
+
+FastAPI is the engine. fyro adds what a project needs around it, with one obvious place for everything: one model class gives you a Postgres table, `Create`/`Read`/`Update` schemas, a REST API with docs, migrations and an admin page. Database sessions, a command line, users, login and permissions are built in.
+
+```python
+# blog/models.py
+from fyro import Field, Model
+
+
+class Post(Model):
+    title: str = Field(max_length=200)
+    body: str
+    secret: str = Field(write_only=True)
+    published: bool = False
+```
+
+That class is the table `blog_post`, the API at `/api/blog/post` (list with filters, search, ordering and paging; get; create; patch; delete) and the admin page at `/admin/blog/post`. Queries need no session code:
+
+```python
+posts = await Post.objects.filter(published=True).order_by("-id").limit(10).all()
+```
+
+## Quickstart
+
+Needs Python 3.12+, Docker (for Postgres) and [uv](https://docs.astral.sh/uv/) or pip.
+
+```bash
+uv venv && source .venv/bin/activate
+uv pip install fyro
+
+fyro new mysite && cd mysite
+docker compose up -d --wait
+python manage.py startapp blog
+# write blog/models.py, then in mysite/settings.py:
+#     installed_apps: list[str] = ["fyro.auth", "blog"]
+python manage.py makemigrations
+python manage.py migrate
+python manage.py createsuperuser
+python manage.py runserver        # http://127.0.0.1:8000/docs and /admin
+```
+
+The full walkthrough and the guides are in [`docs/`](docs/index.md): settings, models, querying, the automatic API, migrations, the command line, auth and permissions, the admin, and security notes.
+
+## Status
+
+**v0.1, alpha.** PostgreSQL only. Relations between models come in v0.2; see [what v0.1 does not do](docs/limitations.md). The plan and the history of every design decision are in [`PLAN.md`](PLAN.md) and [`BUILD_PROMPT.md`](BUILD_PROMPT.md).
+
+## Development
+
+```bash
+uv sync                     # install dependencies
+docker compose up -d        # Postgres 16 on localhost:5432 (user, password, db: fyro)
+uv run pytest               # tests, in random order (pytest-randomly)
+uv run ruff check           # lint
+uv run --only-group docs zensical serve   # docs at http://127.0.0.1:8000
+```
+
+How tests are written and attacked is described in [`test.md`](test.md).
+
+## License
+
+[MIT](LICENSE). The admin bundles [htmx](https://htmx.org) (0BSD) and [JetBrains Mono](https://www.jetbrains.com/lp/mono/) (OFL-1.1); their licenses are in `src/fyro/admin/static/`.

fyro-0.1.0/pyproject.toml

@@ -0,0 +1,78 @@
+[project]
+name = "fyro"
+version = "0.1.0"
+description = "A Django-feeling web framework on top of FastAPI: one model class gives you a table, an API, migrations, auth and an admin."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+keywords = [
+    "fastapi",
+    "django",
+    "web framework",
+    "orm",
+    "admin",
+    "postgres",
+    "sqlalchemy",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: FastAPI",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Database",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+dependencies = [
+    "alembic>=1.20.1",
+    "asyncpg>=0.32.0",
+    "fastapi>=0.159.1",
+    "jinja2>=3.1.6",
+    "pwdlib[argon2]>=0.3.1",
+    "pydantic>=2.14.1",
+    "pydantic-settings>=2.16.1",
+    "sqlalchemy[asyncio]>=2.1.6",
+    "typer>=0.27.3",
+    "uvicorn>=0.54.0",
+]
+
+[[project.authors]]
+name = "Chinmay Talnikar"
+
+[project.urls]
+Homepage = "https://github.com/Carnage725/fyro"
+Documentation = "https://carnage725.github.io/fyro/"
+Source = "https://github.com/Carnage725/fyro"
+Issues = "https://github.com/Carnage725/fyro/issues"
+Changelog = "https://github.com/Carnage725/fyro/blob/main/CHANGELOG.md"
+
+[project.scripts]
+fyro = "fyro.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.10.11,<0.11"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+markers = ["slow: end-to-end tests that start real processes"]
+timeout = 120
+
+[dependency-groups]
+dev = [
+    "httpx>=0.28.1",
+    "hypothesis>=6.170.5",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "pytest-randomly>=5.0.0",
+    "pytest-timeout>=2.4.0",
+    "ruff>=0.17.1",
+]
+docs = ["zensical==0.0.69"]

fyro-0.1.0/pyproject.toml.orig

@@ -0,0 +1,70 @@
+[project]
+name = "fyro"
+version = "0.1.0"
+description = "A Django-feeling web framework on top of FastAPI: one model class gives you a table, an API, migrations, auth and an admin."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Chinmay Talnikar" }]
+requires-python = ">=3.12"
+keywords = ["fastapi", "django", "web framework", "orm", "admin", "postgres", "sqlalchemy"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: FastAPI",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Database",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+dependencies = [
+    "alembic>=1.20.1",
+    "asyncpg>=0.32.0",
+    "fastapi>=0.159.1",
+    "jinja2>=3.1.6",
+    "pwdlib[argon2]>=0.3.1",
+    "pydantic>=2.14.1",
+    "pydantic-settings>=2.16.1",
+    "sqlalchemy[asyncio]>=2.1.6",
+    "typer>=0.27.3",
+    "uvicorn>=0.54.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Carnage725/fyro"
+Documentation = "https://carnage725.github.io/fyro/"
+Source = "https://github.com/Carnage725/fyro"
+Issues = "https://github.com/Carnage725/fyro/issues"
+Changelog = "https://github.com/Carnage725/fyro/blob/main/CHANGELOG.md"
+
+[project.scripts]
+fyro = "fyro.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.10.11,<0.11"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+markers = ["slow: end-to-end tests that start real processes"]
+timeout = 120  # pytest-timeout: a hung test fails instead of blocking the run
+
+[dependency-groups]
+dev = [
+    "httpx>=0.28.1",
+    "hypothesis>=6.170.5",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "pytest-randomly>=5.0.0",
+    "pytest-timeout>=2.4.0",
+    "ruff>=0.17.1",
+]
+docs = [
+    "zensical==0.0.69",
+]

fyro-0.1.0/src/fyro/__init__.py

@@ -0,0 +1,5 @@
+from fyro.app import create_app
+from fyro.conf import Settings
+from fyro.models import Field, Model
+
+__all__ = ["Field", "Model", "Settings", "create_app"]

fyro-0.1.0/src/fyro/admin/__init__.py

@@ -0,0 +1,50 @@
+"""The admin: /admin pages for superusers, mounted by create_app() when fyro.auth is installed."""
+
+from pathlib import Path
+
+from fastapi import FastAPI, Request
+from fastapi.staticfiles import StaticFiles
+from starlette.datastructures import MutableHeaders
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+from fyro.admin.routes import AdminResponse, router
+
+STATIC_DIR = Path(__file__).parent / "static"
+SECURITY_HEADERS = {
+    "Content-Security-Policy": "default-src 'self'; frame-ancestors 'none'",
+    "X-Frame-Options": "DENY",
+    "Referrer-Policy": "same-origin",
+}
+
+
+class AdminSecurityHeaders:
+    """Adds the admin's security headers to every /admin response (pure ASGI)."""
+
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http" or not scope["path"].startswith("/admin"):
+            await self.app(scope, receive, send)
+            return
+
+        async def send_with_headers(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                headers = MutableHeaders(scope=message)
+                for name, value in SECURITY_HEADERS.items():
+                    headers[name] = value
+            await send(message)
+
+        await self.app(scope, receive, send_with_headers)
+
+
+async def _admin_response(request: Request, exc: Exception) -> object:
+    return exc.response  # type: ignore[attr-defined]
+
+
+def mount(app: FastAPI) -> None:
+    # Static first: /admin/static/... must not match the /admin/{app}/{model} page route.
+    app.mount("/admin/static", StaticFiles(directory=STATIC_DIR), name="admin-static")
+    app.include_router(router)
+    app.add_exception_handler(AdminResponse, _admin_response)
+    app.add_middleware(AdminSecurityHeaders)

fyro-0.1.0/src/fyro/admin/forms.py

@@ -0,0 +1,137 @@
+"""Turn model fields into HTML form widgets, and submitted form data back into schema input."""
+
+import enum
+from dataclasses import dataclass, field
+from datetime import UTC, date, datetime
+from decimal import Decimal
+from typing import Any
+
+from pydantic import BaseModel, ValidationError
+
+from fyro.models.base import _unwrap_optional
+from fyro.models.fields import MISSING
+
+
+@dataclass
+class FormField:
+    name: str
+    label: str
+    widget: str  # text | textarea | checkbox | number | date | datetime-local | select | password
+    value: str = ""
+    checked: bool = False
+    options: list[tuple[str, str]] = field(default_factory=list)
+    required: bool = False
+    readonly: bool = False
+    help: str = ""
+    error: str = ""
+
+
+def label(name: str) -> str:
+    return name.replace("_", " ").capitalize()
+
+
+def widget_for(tp: Any, info: Any) -> str:
+    if tp is bool:
+        return "checkbox"
+    if isinstance(tp, type) and issubclass(tp, enum.Enum):
+        return "select"
+    if tp in (int, float, Decimal):
+        return "number"
+    if tp is datetime:
+        return "datetime-local"
+    if tp is date:
+        return "date"
+    if tp is str and info.max_length is None:
+        return "textarea"
+    return "text"
+
+
+def as_input(value: Any) -> str:
+    """A Python value as the string an <input> holds."""
+    if value is None:
+        return ""
+    if isinstance(value, enum.Enum):
+        return str(value.value)
+    if isinstance(value, datetime):
+        return value.astimezone(UTC).strftime("%Y-%m-%dT%H:%M")
+    if isinstance(value, date):
+        return value.isoformat()
+    return str(value)
+
+
+def display(value: Any) -> str:
+    """A Python value as list-table text."""
+    if value is None:
+        return "—"
+    if isinstance(value, bool):
+        return "yes" if value else "no"
+    if isinstance(value, datetime):
+        return value.astimezone(UTC).strftime("%Y-%m-%d %H:%M UTC")
+    text = as_input(value)
+    return text if len(text) <= 80 else text[:79] + "…"
+
+
+def build_fields(
+    model: Any, schema: type[BaseModel], instance: Any = None, *, editing: bool = False
+) -> list[FormField]:
+    """Editable fields come from the schema; read_only ones are shown, never submitted."""
+    fields: list[FormField] = []
+    for name, info in model.__fyro_fields__.items():
+        if name in schema.model_fields:
+            tp, nullable = _unwrap_optional(schema.model_fields[name].annotation)
+            widget = widget_for(tp, info)
+            current = getattr(instance, name) if instance is not None else None
+            if instance is None and info.default is not MISSING:
+                current = info.default
+            form_field = FormField(
+                name=name,
+                label=label(name),
+                widget=widget,
+                value="" if info.write_only else as_input(current),
+                checked=bool(current) if widget == "checkbox" else False,
+                options=[(str(m.value), m.name.title()) for m in tp] if widget == "select" else [],
+                required=not editing and not nullable and widget != "checkbox"
+                and info.default is MISSING and info.default_factory is None,
+                help="Leave blank to keep the current value." if editing and info.write_only else "",
+            )
+            fields.append(form_field)
+        elif instance is not None and info.read_only and not info.write_only:
+            fields.append(
+                FormField(
+                    name=name, label=label(name), widget="text",
+                    value=display(getattr(instance, name)), readonly=True,
+                )
+            )
+    return fields
+
+
+def parse(
+    model: Any, schema: type[BaseModel], form: dict[str, list[str]], *, editing: bool
+) -> tuple[dict[str, Any], dict[str, str]]:
+    """Validate submitted form data with `schema`. Returns (values, errors by field)."""
+    raw: dict[str, Any] = {}
+    for name, schema_field in schema.model_fields.items():
+        info = model.__fyro_fields__[name]
+        tp, nullable = _unwrap_optional(schema_field.annotation)
+        if tp is bool:
+            raw[name] = name in form  # an unchecked checkbox is simply absent
+            continue
+        value = form.get(name, [""])[0]
+        if value == "":
+            if editing and info.write_only:
+                continue  # blank means "keep the current value"
+            if nullable:
+                raw[name] = None
+            elif tp is str and editing:
+                raw[name] = ""
+            continue  # create: let the schema apply its default or report "Field required"
+        raw[name] = value
+    try:
+        validated = schema.model_validate(raw)
+    except ValidationError as error:
+        return {}, {str(e["loc"][0]) if e["loc"] else "__all__": e["msg"] for e in error.errors()}
+    values = validated.model_dump(exclude_unset=True)
+    for name, value in values.items():
+        if isinstance(value, datetime) and value.tzinfo is None:
+            values[name] = value.replace(tzinfo=UTC)  # datetime-local has no zone: treat as UTC
+    return values, {}