fastapi-rtk 2.10.2__tar.gz → 2.11.0__tar.gz

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 2.10.2
+Version: 2.11.0
 Summary: A package that provides a set of tools to build a FastAPI application with a Class-Based CRUD API.
 Project-URL: Homepage, https://codeberg.org/datatactics/fastapi-rtk
 Project-URL: Issues, https://codeberg.org/datatactics/fastapi-rtk/issues

fastapi_rtk-2.11.0/fastapi_rtk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.11.0"

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.0}/fastapi_rtk/backends/generic/filters.py

@@ -64,7 +64,11 @@ class GenericBaseFilter(AbstractBaseFilter[GenericSession]):
             if self.datamodel.is_float(col):
                 return float(value)
             if self.datamodel.is_boolean(col):
-                return value == 1 or value.lower() in ["true", "1"]
+                if isinstance(value, bool):
+                    return value
+                return value == 1 or (
+                    isinstance(value, str) and value.lower() in ["true", "1"]
+                )
             if self.datamodel.is_date(col):
                 return datetime.datetime.fromisoformat(value).date()
             if self.datamodel.is_datetime(col):

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.0}/fastapi_rtk/backends/sqla/filters.py

@@ -121,7 +121,11 @@ class BaseFilter(AbstractBaseFilter[sqlalchemy.Select[Model]]):
             if self.datamodel.is_float(col):
                 return float(value)
             if self.datamodel.is_boolean(col):
-                return value == 1 or value.lower() in ["true", "1"]
+                if isinstance(value, bool):
+                    return value
+                return value == 1 or (
+                    isinstance(value, str) and value.lower() in ["true", "1"]
+                )
             if self.datamodel.is_date(
                 col
             ):  # pragma: no cover - exercised via integration filter tests only

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.0}/fastapi_rtk/cli/cli.py

@@ -1,5 +1,6 @@
 import io
 import pathlib
+import re
 import typing
 import zipfile
 
@@ -35,16 +36,26 @@ def callback(
 
 @app.command()
 def create_app(
+    name: typing.Annotated[
+        str,
+        typer.Option(
+            prompt="Project name",
+            help="The name of the new application. Fills the project-name placeholders in the generated files.",
+        ),
+    ],
     directory: typing.Annotated[
         str,
         typer.Option(
-            ...,
             help="The directory where the new FastAPI RTK application will be created.",
         ),
     ] = ".",
 ):
     """
     Create a new FastAPI RTK application with a predefined structure from https://codeberg.org/datatactics/fastapi-rtk-skeleton.
+
+    Args:
+        name (str): The project name; normalized and substituted into the scaffolded project's placeholder files.
+        directory (str): Target directory for the new application. Defaults to the current directory.
     """
     with httpx.Client() as client:
         url = "https://codeberg.org/datatactics/fastapi-rtk-skeleton/archive/main.zip"
@@ -84,8 +95,41 @@ def create_app(
                     with open(target_file, "wb") as f:
                         f.write(source.read())
 
+            _apply_project_name(pathlib.Path(directory), name)
+
             typer.echo(f"FastAPI RTK application skeleton created in {directory}")
 
 
+def _apply_project_name(directory: pathlib.Path, name: str) -> None:
+    """
+    Substitute the skeleton's project-name placeholders with the given name.
+
+    Each placeholder receives the casing its file expects: a slug for the
+    distribution name, upper snake for the config env var, and the raw name for
+    the page title. Missing files are skipped so partial scaffolds do not error.
+
+    Args:
+        directory (pathlib.Path): Root directory of the freshly created application.
+        name (str): Raw project name entered by the user.
+    """
+    raw = name.strip()
+    slug = re.sub(r"[-_.\s]+", "-", raw.lower()).strip("-")
+    env = slug.upper().replace("-", "_")
+    replacements = {
+        "pyproject.toml": [("project-name", slug)],
+        "requirements.txt": [("project-name", slug)],
+        "app/__init__.py": [("PROJECTNAME", env)],
+        "webapp/index.html": [("YOUR_APP_NAME_HERE", raw)],
+    }
+    for relative_path, subs in replacements.items():
+        target = directory / relative_path
+        if not target.exists():
+            continue
+        content = target.read_text(encoding="utf-8")
+        for placeholder, value in subs:
+            content = content.replace(placeholder, value)
+        target.write_text(content, encoding="utf-8")
+
+
 def main():
     app()

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.0}/tests/unit/backends/generic/test_filters.py

@@ -1,7 +1,6 @@
 import datetime
 
 import pytest
-
 from fastapi_rtk.backends.generic.column import GenericColumn
 from fastapi_rtk.backends.generic.filters import (
     GenericBaseFilter,
@@ -109,6 +108,18 @@ class TestCastValue:
         f = GenericFilterEqual(StubInterface({"flag": bool}))
         assert f._cast_value("flag", 1) is True
 
+    def test_boolean_cast_native_true(self, caplog):
+        f = GenericFilterEqual(StubInterface({"flag": bool}))
+        with caplog.at_level("WARNING", logger="DT_FASTAPI"):
+            assert f._cast_value("flag", True) is True
+        assert not any("Failed to cast" in r.message for r in caplog.records)
+
+    def test_boolean_cast_native_false(self, caplog):
+        f = GenericFilterEqual(StubInterface({"flag": bool}))
+        with caplog.at_level("WARNING", logger="DT_FASTAPI"):
+            assert f._cast_value("flag", False) is False
+        assert not any("Failed to cast" in r.message for r in caplog.records)
+
     def test_date_cast(self):
         f = GenericFilterEqual(StubInterface({"d": datetime.date}))
         assert f._cast_value("d", "2024-01-15") == datetime.date(2024, 1, 15)

{fastapi_rtk-2.10.2 → fastapi_rtk-2.11.0}/tests/unit/backends/sqla/test_filters.py

@@ -2,7 +2,6 @@ import unittest.mock
 
 import pytest
 import sqlalchemy
-
 from fastapi_rtk.backends.sqla.filters import (
     FilterBetween,
     FilterContains,
@@ -188,6 +187,18 @@ class TestCastValue:
         f = FilterEqual(iface)
         assert f._cast_value("active", "false") is False
 
+    def test_boolean_native_true(self, iface, caplog):
+        f = FilterEqual(iface)
+        with caplog.at_level("WARNING", logger="DT_FASTAPI"):
+            assert f._cast_value("active", True) is True
+        assert not caplog.records
+
+    def test_boolean_native_false(self, iface, caplog):
+        f = FilterEqual(iface)
+        with caplog.at_level("WARNING", logger="DT_FASTAPI"):
+            assert f._cast_value("active", False) is False
+        assert not caplog.records
+
 
 class TestSQLAFilterConverter:
     def test_conversion_table_present(self):
@@ -212,7 +223,6 @@ class TestSQLAFilterConverter:
 
     def test_init_filters_picks_list_row_for_list_column(self):
         import sqlalchemy
-
         from fastapi_rtk import ListColumn, Mapped, mapped_column
         from fastapi_rtk.backends.sqla.filters import (
             FilterEqual,
@@ -444,9 +454,8 @@ class TestFilterGlobalSqla:
     ):
         # Must not collapse all columns into one concat() call: 2 args per
         # column can exceed a database's function-argument limit on wide tables.
-        from sqlalchemy.dialects import postgresql
-
         from fastapi_rtk.backends.sqla.filters import FilterGlobal
+        from sqlalchemy.dialects import postgresql
 
         iface = SQLAInterface(WideRow_cls)
         f = FilterGlobal(iface)

fastapi_rtk-2.11.0/tests/unit/cli/test_cli.py

@@ -0,0 +1,172 @@
+"""Tier 14 - tests for fastapi_rtk.cli.cli (top-level Typer app)."""
+
+import io
+import unittest.mock
+import zipfile
+
+import typer.testing
+from fastapi_rtk.cli.cli import app, main
+from fastapi_rtk.version import __version__
+
+runner = typer.testing.CliRunner()
+
+
+def _build_skeleton_zip(
+    *, with_naked_root_entry: bool = False, with_placeholders: bool = True
+) -> bytes:
+    """Synthetic skeleton archive that mimics the layout of the upstream zip."""
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as zf:
+        if with_naked_root_entry:
+            # Triggers the empty-target_path continue branch
+            zf.writestr("skeleton-main", "")
+        zf.writestr("skeleton-main/", "")
+        zf.writestr("skeleton-main/README.md", "# skeleton")
+        if with_placeholders:
+            zf.writestr("skeleton-main/pyproject.toml", 'name = "project-name"\n')
+            zf.writestr(
+                "skeleton-main/requirements.txt",
+                "# via project-name (pyproject.toml)\n",
+            )
+            zf.writestr(
+                "skeleton-main/app/__init__.py", 'ENV_VAR = "PROJECTNAME_CONFIG"\n'
+            )
+            zf.writestr(
+                "skeleton-main/webapp/index.html", "<title>YOUR_APP_NAME_HERE</title>\n"
+            )
+        zf.writestr("skeleton-main/app/", "")
+        zf.writestr("skeleton-main/app/main.py", "print('ok')")
+    return buf.getvalue()
+
+
+def _fake_client(zip_bytes: bytes):
+    """Build a drop-in httpx.Client replacement serving a fixed zip archive."""
+
+    class FakeResponse:
+        content = zip_bytes
+
+        def raise_for_status(self):
+            pass
+
+    class FakeClient:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *a):
+            pass
+
+        def get(self, url):
+            return FakeResponse()
+
+    return FakeClient
+
+
+class TestHelp:
+    def test_help_returns_zero(self):
+        result = runner.invoke(app, ["--help"])
+        assert result.exit_code == 0
+
+    def test_help_shows_create_app(self):
+        result = runner.invoke(app, ["--help"])
+        assert "create-app" in result.output
+
+
+class TestVersion:
+    def test_version_returns_zero(self):
+        result = runner.invoke(app, ["--version"])
+        assert result.exit_code == 0
+
+    def test_version_shows_version_string(self):
+        result = runner.invoke(app, ["--version"])
+        assert __version__ in result.output
+
+
+class TestCreateAppHelp:
+    def test_create_app_help(self):
+        result = runner.invoke(app, ["create-app", "--help"])
+        assert result.exit_code == 0
+        assert "directory" in result.output.lower()
+
+    def test_create_app_help_shows_name(self):
+        result = runner.invoke(app, ["create-app", "--help"])
+        assert "name" in result.output.lower()
+
+
+class TestCreateAppExtraction:
+    def test_create_app_extracts_skeleton(self, tmp_path):
+        zip_bytes = _build_skeleton_zip()
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app, ["create-app", "--name", "demo", "--directory", str(tmp_path)]
+            )
+        assert result.exit_code == 0, result.output
+        assert (tmp_path / "README.md").exists()
+        assert (tmp_path / "app" / "main.py").exists()
+        assert "skeleton created" in result.output
+
+    def test_create_app_handles_naked_root_entry(self, tmp_path):
+        zip_bytes = _build_skeleton_zip(with_naked_root_entry=True)
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app, ["create-app", "--name", "demo", "--directory", str(tmp_path)]
+            )
+        assert result.exit_code == 0, result.output
+        assert (tmp_path / "README.md").exists()
+
+
+class TestCreateAppProjectName:
+    def test_create_app_substitutes_all_placeholders(self, tmp_path):
+        zip_bytes = _build_skeleton_zip()
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app,
+                ["create-app", "--name", "My Cool App", "--directory", str(tmp_path)],
+            )
+        assert result.exit_code == 0, result.output
+        assert 'name = "my-cool-app"' in (tmp_path / "pyproject.toml").read_text()
+        assert "my-cool-app" in (tmp_path / "requirements.txt").read_text()
+        assert (
+            'ENV_VAR = "MY_COOL_APP_CONFIG"'
+            in (tmp_path / "app" / "__init__.py").read_text()
+        )
+        assert (
+            "<title>My Cool App</title>"
+            in (tmp_path / "webapp" / "index.html").read_text()
+        )
+
+    def test_create_app_prompts_for_name(self, tmp_path):
+        zip_bytes = _build_skeleton_zip()
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app,
+                ["create-app", "--directory", str(tmp_path)],
+                input="prompted-app\n",
+            )
+        assert result.exit_code == 0, result.output
+        assert 'name = "prompted-app"' in (tmp_path / "pyproject.toml").read_text()
+
+    def test_create_app_without_placeholders_is_noop(self, tmp_path):
+        zip_bytes = _build_skeleton_zip(with_placeholders=False)
+        with unittest.mock.patch(
+            "fastapi_rtk.cli.cli.httpx.Client", _fake_client(zip_bytes)
+        ):
+            result = runner.invoke(
+                app, ["create-app", "--name", "demo", "--directory", str(tmp_path)]
+            )
+        assert result.exit_code == 0, result.output
+        assert not (tmp_path / "pyproject.toml").exists()
+
+
+class TestMain:
+    def test_main_invokes_app(self):
+        with unittest.mock.patch("fastapi_rtk.cli.cli.app") as mock_app:
+            main()
+            mock_app.assert_called_once()

fastapi_rtk-2.10.2/fastapi_rtk/_version.py

@@ -1 +0,0 @@
-__version__ = "2.10.2"

fastapi_rtk-2.10.2/tests/unit/cli/test_cli.py

@@ -1,117 +0,0 @@
-"""Tier 14 - tests for fastapi_rtk.cli.cli (top-level Typer app)."""
-
-import io
-import unittest.mock
-import zipfile
-
-import typer.testing
-
-from fastapi_rtk.cli.cli import app, main
-from fastapi_rtk.version import __version__
-
-runner = typer.testing.CliRunner()
-
-
-def _build_skeleton_zip(*, with_naked_root_entry: bool = False) -> bytes:
-    """Synthetic skeleton archive that mimics the layout of the upstream zip."""
-    buf = io.BytesIO()
-    with zipfile.ZipFile(buf, "w") as zf:
-        if with_naked_root_entry:
-            # Triggers the empty-target_path continue branch
-            zf.writestr("skeleton-main", "")
-        zf.writestr("skeleton-main/", "")
-        zf.writestr("skeleton-main/README.md", "# skeleton")
-        zf.writestr("skeleton-main/app/", "")
-        zf.writestr("skeleton-main/app/main.py", "print('ok')")
-    return buf.getvalue()
-
-
-class TestHelp:
-    def test_help_returns_zero(self):
-        result = runner.invoke(app, ["--help"])
-        assert result.exit_code == 0
-
-    def test_help_shows_create_app(self):
-        result = runner.invoke(app, ["--help"])
-        assert "create-app" in result.output
-
-
-class TestVersion:
-    def test_version_returns_zero(self):
-        result = runner.invoke(app, ["--version"])
-        assert result.exit_code == 0
-
-    def test_version_shows_version_string(self):
-        result = runner.invoke(app, ["--version"])
-        assert __version__ in result.output
-
-
-class TestCreateAppHelp:
-    def test_create_app_help(self):
-        result = runner.invoke(app, ["create-app", "--help"])
-        assert result.exit_code == 0
-        assert "directory" in result.output.lower()
-
-
-class TestCreateAppExtraction:
-    def test_create_app_extracts_skeleton(self, tmp_path):
-        # Mock httpx.Client to return a fake zip archive so the command
-        # exercises its extraction logic without hitting the network.
-        zip_bytes = _build_skeleton_zip()
-
-        class FakeResponse:
-            content = zip_bytes
-
-            def raise_for_status(self):
-                pass
-
-        class FakeClient:
-            def __enter__(self):
-                return self
-
-            def __exit__(self, *a):
-                pass
-
-            def get(self, url):
-                return FakeResponse()
-
-        with unittest.mock.patch("fastapi_rtk.cli.cli.httpx.Client", FakeClient):
-            result = runner.invoke(app, ["create-app", "--directory", str(tmp_path)])
-        assert result.exit_code == 0, result.output
-        assert (tmp_path / "README.md").exists()
-        assert (tmp_path / "app" / "main.py").exists()
-        assert "skeleton created" in result.output
-
-    def test_create_app_handles_naked_root_entry(self, tmp_path):
-        # Some zip producers list the top-level dir without a trailing slash;
-        # exercise the empty-target_path skip branch.
-        zip_bytes = _build_skeleton_zip(with_naked_root_entry=True)
-
-        class FakeResponse:
-            content = zip_bytes
-
-            def raise_for_status(self):
-                pass
-
-        class FakeClient:
-            def __enter__(self):
-                return self
-
-            def __exit__(self, *a):
-                pass
-
-            def get(self, url):
-                return FakeResponse()
-
-        with unittest.mock.patch("fastapi_rtk.cli.cli.httpx.Client", FakeClient):
-            result = runner.invoke(app, ["create-app", "--directory", str(tmp_path)])
-        assert result.exit_code == 0, result.output
-        assert (tmp_path / "README.md").exists()
-
-
-class TestMain:
-    def test_main_invokes_app(self):
-        # main() calls app() under typer; verify it's a callable that runs.
-        with unittest.mock.patch("fastapi_rtk.cli.cli.app") as mock_app:
-            main()
-            mock_app.assert_called_once()