fastapi-startkit 0.53.0__tar.gz → 0.55.0__tar.gz

{fastapi_startkit-0.53.0 → fastapi_startkit-0.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi-startkit
-Version: 0.53.0
+Version: 0.55.0
 Summary: A modular, provider-driven framework for building async Python web applications with FastAPI — bundling a service container, configuration system, an async-first ORM, facades, and a Cleo-powered console.
 Keywords: fastapi,framework,async,web,asgi,orm,sqlalchemy,pydantic,ioc-container,dependency-injection,service-provider,cli,console,configuration,microservices,starter-kit,boilerplate
 Author: Bedram Tamang

{fastapi_startkit-0.53.0 → fastapi_startkit-0.55.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-startkit"
-version = "0.53.0"
+version = "0.55.0"
 description = "A modular, provider-driven framework for building async Python web applications with FastAPI — bundling a service container, configuration system, an async-first ORM, facades, and a Cleo-powered console."
 readme = "README.md"
 keywords = [

{fastapi_startkit-0.53.0 → fastapi_startkit-0.55.0}/src/fastapi_startkit/fastapi/commands/serve_command.py

@@ -1,8 +1,11 @@
+from typing import Any
+
 from cleo.helpers import option
 
 from fastapi_startkit import Config
 from fastapi_startkit.console.command import Command
 from fastapi_startkit.environment import value as cast_value
+from fastapi_startkit.fastapi.config import FastAPIConfig
 from fastapi_startkit.support import Uri, Uriable
 
 
@@ -36,18 +39,27 @@ class ServeCommand(Command):
             "app",
             "a",
             flag=False,
-            default="bootstrap.application:app",
-            description="The application to serve",
+            default=None,
+            description="The application to serve (overrides fastapi config)",
         ),
     ]
 
-    def resolve_option(self, key: str, default: str | int | None = None):
-        value = self.option(key) or Config.get(f"fastapi.{key}", default)
+    def config_value(self, key: str) -> Any:
+        """Resolve `fastapi.<key>`, falling back to the FastAPIConfig default."""
+        # Instantiated per call so env-backed fields are read at command time.
+        default = getattr(FastAPIConfig(), key, None)
+        # Configuration.get() only substitutes its default on a missing key, so a
+        # key that is present but None would otherwise leak through.
+        value = Config.get(f"fastapi.{key}", default)
 
-        return cast_value(value)
+        return default if value is None else value
+
+    def resolve_option(self, key: str) -> Any:
+        """CLI flag > fastapi config > FastAPIConfig default."""
+        return cast_value(self.option(key) or self.config_value(key))
 
     def resolve_url(self) -> Uriable:
-        host = self.option("host") or Config.get("fastapi.app_url", "http://127.0.0.1:8000")
+        host = self.option("host") or self.config_value("app_url")
         port = self.option("port")
 
         if host and not host.startswith("http"):
@@ -60,15 +72,11 @@ class ServeCommand(Command):
     def handle(self):
         import uvicorn
 
-        from fastapi_startkit import Config
         from fastapi_startkit.container import Container
 
-        # Resolve server settings: CLI flag > fastapi config > uvicorn default (None)
-        cfg_reload_dirs = Config.get("fastapi.reload_dirs") or None
-        cfg_reload_excludes = Config.get("fastapi.reload_excludes") or None
-
         url = self.resolve_url()
-        reload = self.resolve_option("reload", True)
+        reload = self.resolve_option("reload")
+        app = self.resolve_option("app")
 
         kwargs = {
             "host": url.host(),
@@ -77,19 +85,24 @@ class ServeCommand(Command):
             "ws": "websockets-sansio",
         }
 
-        if self.is_app_exist():
+        if self.is_app_exist(app):
             kwargs.update(
                 {
-                    "app": self.option("app"),
+                    "app": app,
                     "factory": True,
                 }
             )
-            if cfg_reload_dirs is not None and reload:
-                kwargs["reload_dirs"] = cfg_reload_dirs
-            if cfg_reload_excludes is not None and reload:
-                kwargs["reload_excludes"] = cfg_reload_excludes
 
-            self.line(f"<info>Starting Uvicorn server on {url.host()}:{url.port()} [{self.option('app')}]...</info>")
+            if reload:
+                reload_dirs = self.config_value("reload_dirs")
+                reload_excludes = self.config_value("reload_excludes")
+
+                if reload_dirs:
+                    kwargs["reload_dirs"] = reload_dirs
+                if reload_excludes:
+                    kwargs["reload_excludes"] = reload_excludes
+
+            self.line(f"<info>Starting Uvicorn server on {url.host()}:{url.port()} [{app}]...</info>")
 
         else:
             self.line(f"<info>Starting Uvicorn server on {url.host()}:{url.port()}...</info>")
@@ -100,11 +113,9 @@ class ServeCommand(Command):
         except KeyboardInterrupt:
             self.line("<comment>Server stopped manually.</comment>")
 
-    def is_app_exist(self) -> "bool":
+    def is_app_exist(self, app: str) -> "bool":
         import importlib.util
 
-        app = self.option("app")
-
         module_name = app.split(":")[0]
         try:
             spec = importlib.util.find_spec(module_name)
@@ -113,6 +124,6 @@ class ServeCommand(Command):
         except (ImportError, ValueError):
             pass
 
-        self.line("<fg=yellow>Unable to detect the application, run the command with --app={app}</>")
+        self.line(f"<fg=yellow>Unable to detect the application '{app}', run the command with --app=your_module:app</>")
 
         return False

{fastapi_startkit-0.53.0 → fastapi_startkit-0.55.0}/src/fastapi_startkit/fastapi/config/fastapi.py

@@ -6,6 +6,7 @@ from fastapi_startkit.environment import env
 @dataclasses.dataclass
 class FastAPIConfig:
     app_url: str = dataclasses.field(default_factory=lambda: env("APP_URL", "http://127.0.0.1:8000"))
+    app: str = "bootstrap.application:app"
     reload: bool = dataclasses.field(default_factory=lambda: env("APP_RELOAD", True))
     reload_dirs: list | None = None
     reload_excludes: list = dataclasses.field(

fastapi_startkit-0.55.0/src/fastapi_startkit/masoniteorm/connections/connection.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+from contextvars import ContextVar, Token
+from types import TracebackType
+from typing import TYPE_CHECKING
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, AsyncTransaction
+
+from fastapi_startkit.masoniteorm.models.builder import QueryBuilder
+
+if TYPE_CHECKING:
+    from typing import Self
+
+
+class Transaction:
+    def __init__(self, owner: Connection):
+        self.owner = owner
+        self.connection: AsyncConnection | None = None
+        self.transaction: AsyncTransaction | None = None
+        self._token: Token[AsyncConnection | None] | None = None
+        self._owns_connection = False
+
+    async def __aenter__(self) -> Self:
+        connection = self.owner.connection
+        if connection is None:
+            connection = await self.owner.engine.connect()
+            self._owns_connection = True
+        self.connection = connection
+        self._token = self.owner._connection_context.set(connection)
+
+        try:
+            if connection.in_transaction():
+                self.transaction = await connection.begin_nested()
+            else:
+                self.transaction = await connection.begin()
+        except BaseException:
+            self.owner._connection_context.reset(self._token)
+            if self._owns_connection:
+                await connection.close()
+            raise
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        assert self.connection is not None
+        assert self.transaction is not None
+        assert self._token is not None
+        try:
+            await self.transaction.__aexit__(exc_type, exc_value, traceback)
+        finally:
+            self.owner._connection_context.reset(self._token)
+            if self._owns_connection:
+                await self.connection.close()
+
+    async def commit(self) -> None:
+        assert self.transaction is not None
+        await self.transaction.commit()
+
+    async def rollback(self) -> None:
+        assert self.transaction is not None
+        await self.transaction.rollback()
+
+
+class Connection:
+    def __init__(self, engine: AsyncEngine, config: dict):
+        self.config = config
+        self.engine: AsyncEngine = engine
+        self._connection_context: ContextVar[AsyncConnection | None] = ContextVar(
+            f"masoniteorm_connection_{id(self)}", default=None
+        )
+
+    @property
+    def connection(self) -> AsyncConnection | None:
+        return self._connection_context.get()
+
+    @property
+    def transactions(self) -> list[AsyncTransaction]:
+        connection = self.connection
+        if connection is None:
+            return []
+        nested = connection.get_nested_transaction()
+        root = connection.get_transaction()
+        return [transaction for transaction in (root, nested) if transaction is not None]
+
+    def transaction(self) -> Transaction:
+        return Transaction(self)
+
+    def query(self) -> QueryBuilder:
+        return QueryBuilder(
+            connection=self,
+            grammar=self.get_query_grammar(),
+            processor=self.get_post_processor(),
+        )
+
+    async def get_connection(self) -> AsyncConnection:
+        return self.connection or await self.engine.connect()
+
+    def get_query_grammar(cls):
+        pass
+
+    def get_post_processor(self):
+        pass
+
+    async def begin_transaction(self) -> None:
+        connection = self.connection
+        if connection is None:
+            connection = await self.engine.connect()
+            self._connection_context.set(connection)
+        if connection.in_transaction():
+            await connection.begin_nested()
+        else:
+            await connection.begin()
+
+    async def commit_transaction(self) -> None:
+        connection = self.connection
+        if connection is None or not connection.in_transaction():
+            raise RuntimeError("No active transaction to commit")
+        nested = connection.get_nested_transaction()
+        if nested is not None:
+            await nested.commit()
+        else:
+            transaction = connection.get_transaction()
+            assert transaction is not None
+            await transaction.commit()
+            await self._release_connection(connection)
+
+    async def rollback(self) -> None:
+        connection = self.connection
+        if connection is None or not connection.in_transaction():
+            raise RuntimeError("No active transaction to rollback")
+        nested = connection.get_nested_transaction()
+        if nested is not None:
+            await nested.rollback()
+        else:
+            transaction = connection.get_transaction()
+            assert transaction is not None
+            await transaction.rollback()
+            await self._release_connection(connection)
+
+    async def _release_connection(self, connection: AsyncConnection) -> None:
+        await connection.close()
+        if self.connection is connection:
+            self._connection_context.set(None)
+
+    async def close(self) -> None:
+        connection = self.connection
+        if connection is not None:
+            await connection.close()
+            self._connection_context.set(None)
+
+    async def reconnect(self) -> None:
+        await self.close()
+
+    @staticmethod
+    def sql_alchemy_bindings(query: str, bindings: list | None = None):
+        params = {}
+        if bindings:
+            for i, val in enumerate(bindings):
+                name = f"p{i}"
+                params[name] = val
+                query = query.replace("?", f":{name}", 1)
+        return (query, params)
+
+    async def run(self, query: str, bindings: list | None = None):
+        query, params = self.sql_alchemy_bindings(query, bindings)
+        return await self._execute(query, params)
+
+    async def execute(self, query: str, bindings: list | None = None):
+        query, params = self.sql_alchemy_bindings(query, bindings)
+        return await self._execute(query, params)
+
+    async def _execute(self, query: str, bindings: dict):
+        connection = self.connection
+        if connection is not None:
+            return await connection.execute(text(query), bindings or {})
+        async with self.engine.begin() as operation_connection:
+            return await operation_connection.execute(text(query), bindings or {})
+
+    async def insert(self, query: str, bindings: list | None = None) -> int | None:
+        result = await self.execute(query, bindings)
+        return getattr(result, "lastrowid", None)
+
+    async def insert_get_id(self, query: str, bindings: list | None = None) -> int | None:
+        result = await self.execute(query, bindings)
+        return getattr(result, "lastrowid", None)
+
+    async def update(self, query: str, bindings: list | None = None) -> int:
+        result = await self.execute(query, bindings)
+        return result.rowcount  # type: ignore[return-value]
+
+    async def delete(self, query: str, bindings: list | None = None) -> int:
+        result = await self.execute(query, bindings)
+        return result.rowcount  # type: ignore[return-value]
+
+    async def select(self, query: str, bindings: list | None = None) -> list[dict]:
+        result = await self.run(query, bindings)
+        return result.mappings().all()
+
+    async def select_one(self, query: str, bindings: list | None = None) -> dict | None:
+        result = await self.run(query, bindings)
+        row = result.fetchone()
+        return dict(zip(result.keys(), row)) if row else None
+
+    async def statement(self, query: str, bindings: list | None = None) -> bool:
+        query, params = self.sql_alchemy_bindings(query, bindings)
+        await self._execute(query, params)
+        return True

{fastapi_startkit-0.53.0 → fastapi_startkit-0.55.0}/src/fastapi_startkit/masoniteorm/connections/postgres_connection.py

@@ -10,9 +10,6 @@ class PostgresConnection(Connection):
     async def insert_get_id(self, query: str, bindings: list | None = None) -> int | None:
         result = await self.run(query, bindings)
         row = result.fetchone()
-        if not self.transactions:
-            conn = await self.get_connection()
-            await conn.commit()
         return row[0] if row is not None else None
 
     @classmethod

{fastapi_startkit-0.53.0 → fastapi_startkit-0.55.0}/src/fastapi_startkit/masoniteorm/schema/Blueprint.py

@@ -736,8 +736,9 @@ class Blueprint:
 
         sql = await self.to_sql()
         if isinstance(sql, list):
-            for q in sql:
-                await self.connection.statement(q, ())
+            async with self.connection.transaction():
+                for q in sql:
+                    await self.connection.statement(q, ())
             return
         return await self.connection.statement(sql, ())
 

{fastapi_startkit-0.53.0 → fastapi_startkit-0.55.0}/src/fastapi_startkit/masoniteorm/testing/transaction.py

@@ -3,10 +3,12 @@ class DatabaseTransaction:
         from fastapi_startkit.masoniteorm.models import Model
 
         self.connection = Model.db_manager.connection(None)
-        await self.connection.begin_transaction()
+        self.transaction = self.connection.transaction()
+        await self.transaction.__aenter__()
 
     async def asyncStopTestRun(self):
-        await self.connection.rollback()
+        await self.transaction.rollback()
+        await self.transaction.__aexit__(None, None, None)
 
 
 class RefreshDatabase(DatabaseTransaction):

fastapi_startkit-0.53.0/src/fastapi_startkit/masoniteorm/connections/connection.py

@@ -1,151 +0,0 @@
-from typing import List
-
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, AsyncTransaction
-
-from fastapi_startkit.masoniteorm.models.builder import QueryBuilder
-
-
-class Connection:
-    def __init__(self, engine: AsyncEngine, config: dict):
-        self.config = config
-        self.engine: AsyncEngine = engine
-        self.connection: AsyncConnection | None = None
-        self.transactions: List[AsyncTransaction] = []
-
-    def query(self) -> "QueryBuilder":
-        return QueryBuilder(
-            connection=self,
-            grammar=self.get_query_grammar(),
-            processor=self.get_post_processor(),
-        )
-
-    async def get_connection(self) -> AsyncConnection:
-        if self.connection is None:
-            self.connection = await self.engine.connect()
-
-        assert self.connection is not None
-        return self.connection
-
-    def get_query_grammar(cls):
-        pass
-
-    def get_post_processor(self):
-        pass
-
-    async def begin_transaction(self) -> None:
-        connection = await self.get_connection()
-
-        if not self.transactions:
-            transaction = await connection.begin()
-        else:
-            transaction = await connection.begin_nested()
-
-        self.transactions.append(transaction)
-
-    async def commit_transaction(self) -> None:
-        if not self.transactions:
-            raise RuntimeError("No active transaction to commit")
-
-        transaction = self.transactions.pop()
-        await transaction.commit()
-
-        await self._maybe_cleanup()
-
-    async def rollback(self) -> None:
-        if not self.transactions:
-            raise RuntimeError("No active transaction to rollback")
-
-        transaction = self.transactions.pop()
-        await transaction.rollback()
-
-        await self._maybe_cleanup()
-
-    async def close(self) -> None:
-        if self.connection is not None:
-            await self.connection.close()
-            self.connection = None
-        self.transactions = []
-
-    async def reconnect(self) -> None:
-        await self.close()
-
-    @staticmethod
-    def sql_alchemy_bindings(query: str, bindings: list | None = None):
-        params = {}
-        if bindings:
-            for i, val in enumerate(bindings):
-                name = f"p{i}"
-                params[name] = val
-                query = query.replace("?", f":{name}", 1)
-        return (query, params)
-
-    async def run(self, query: str, bindings: list | None = None):
-        query, bindings = self.sql_alchemy_bindings(query, bindings)
-
-        conn = await self.get_connection()
-        result = await conn.execute(text(query), bindings or {})
-
-        if not self.transactions:
-            await conn.commit()
-
-        return result
-
-    async def execute(self, query: str, bindings: list | None = None):
-        query, bindings = self.sql_alchemy_bindings(query, bindings)
-
-        conn = await self.get_connection()
-        result = await conn.execute(text(query), bindings or {})
-
-        if not self.transactions:
-            await conn.commit()
-
-        return result
-
-    async def insert(self, query: str, bindings: list | None = None) -> int | None:
-        result = await self.execute(query, bindings)
-
-        return getattr(result, "lastrowid", None)
-
-    async def insert_get_id(self, query: str, bindings: list | None = None) -> int | None:
-        result = await self.execute(query, bindings)
-        return getattr(result, "lastrowid", None)
-
-    async def update(self, query: str, bindings: list | None = None) -> int:
-        result = await self.execute(query, bindings)
-
-        return result.rowcount  # type: ignore[return-value]
-
-    async def delete(self, query: str, bindings: list | None = None) -> int:
-        result = await self.execute(query, bindings)
-        return result.rowcount  # type: ignore[return-value]
-
-    async def select(self, query: str, bindings: list | None = None) -> list[dict]:
-        result = await self.run(query, bindings)
-
-        return result.mappings().all()
-
-    async def select_one(self, query: str, bindings: list | None = None) -> dict | None:
-        result = await self.run(query, bindings)
-        row = result.fetchone()
-        result_dict = dict(zip(result.keys(), row)) if row else None
-        if not self.transactions and self.connection is not None:
-            await self.connection.commit()
-        return result_dict
-
-    async def statement(self, query: str, bindings: list | None = None) -> bool:
-        query, bindings = self.sql_alchemy_bindings(query, bindings)
-
-        conn = await self.get_connection()
-        await conn.execute(text(query), bindings or {})
-
-        # Only commit if NOT inside a transaction
-        if not self.transactions:
-            await conn.commit()
-
-        return True
-
-    async def _maybe_cleanup(self):
-        if not self.transactions and self.connection:
-            await self.connection.close()
-            self.connection = None