fastapi-startkit 0.54.0__tar.gz → 0.56.0__tar.gz

{fastapi_startkit-0.54.0 → fastapi_startkit-0.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi-startkit
-Version: 0.54.0
+Version: 0.56.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.54.0 → fastapi_startkit-0.56.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-startkit"
-version = "0.54.0"
+version = "0.56.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.54.0 → fastapi_startkit-0.56.0}/src/fastapi_startkit/config/app.py

@@ -7,5 +7,5 @@ from fastapi_startkit.environment.environment import env
 class AppConfig:
     name: str = field(default_factory=lambda: os.getenv("APP_NAME", "FastAPI starter kit"))
     env: str = field(default_factory=lambda: os.getenv("APP_ENV", "development"))
-    debug: bool = field(default_factory=lambda: env("APP_DEBUG", "true"))
+    debug: bool = field(default_factory=lambda: env("APP_DEBUG", True))
     timezone: str = field(default_factory=lambda: os.getenv("APP_TIMEZONE", "UTC"))

{fastapi_startkit-0.54.0 → fastapi_startkit-0.56.0}/src/fastapi_startkit/environment/environment.py

@@ -2,9 +2,15 @@
 
 import os
 import sys
+from typing import Any, Literal, TypeVar, overload
+
 from dotenv import load_dotenv
 
 
+T = TypeVar("T")
+EnvValue = str | int | bool
+
+
 class Environment:
     @staticmethod
     def resolve_environment(base_path=None, env: str | None = None):
@@ -63,11 +69,45 @@ class Environment:
                 break
 
 
-def env(value, default="", cast=True):
-    """Helper to retrieve the value of an environment variable or returns
-    a default value. In addition, if type can be inferred then the value can be casted to the
-    inferred type."""
-    env_var = os.getenv(value, default)
+@overload
+def env(val: str, default: T, cast: Literal[False]) -> str | T: ...
+
+
+@overload
+def env(val: str, default: Literal[""], cast: Literal[True] = True) -> EnvValue: ...
+
+
+@overload
+def env(val: str, default: None, cast: Literal[True] = True) -> EnvValue | None: ...
+
+
+@overload
+def env(val: str, default: T, cast: Literal[True] = True) -> T: ...
+
+
+@overload
+def env(val: str, default: None, cast: bool) -> EnvValue | None: ...
+
+
+@overload
+def env(val: str, default: T, cast: bool) -> EnvValue | T: ...
+
+
+@overload
+def env(val: str) -> EnvValue: ...
+
+
+@overload
+def env(val: str, *, cast: Literal[False]) -> str: ...
+
+
+@overload
+def env(val: str, *, cast: bool) -> EnvValue: ...
+
+
+def env(val: str, default: Any = "", cast: bool = True) -> Any:
+    """Return an environment value, casting it to the supplied default's type when possible."""
+    env_var = os.getenv(val, default)
 
     if not cast:
         return env_var
@@ -75,18 +115,23 @@ def env(value, default="", cast=True):
     if env_var == "":
         env_var = default
 
-    if isinstance(env_var, bool):
-        return env_var
-    elif env_var is None:
-        return None
-    elif isinstance(env_var, int) or env_var.isnumeric():
-        return int(env_var)
-    elif env_var in ("false", "False"):
-        return False
-    elif env_var in ("true", "True"):
-        return True
-    else:
-        return env_var
+    if default in ("", None):
+        return value(env_var)
+
+    default_type = type(default)
+    if default_type is bool:
+        if isinstance(env_var, bool):
+            return env_var
+        if env_var in ("true", "True"):
+            return True
+        if env_var in ("false", "False"):
+            return False
+        raise ValueError(f"Cannot cast environment variable {val!r} to bool")
+
+    try:
+        return default_type(env_var)
+    except (TypeError, ValueError) as error:
+        raise ValueError(f"Cannot cast environment variable {val!r} to {default_type.__name__}") from error
 
 
 def value(env_var, default=""):

fastapi_startkit-0.56.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.54.0 → fastapi_startkit-0.56.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.54.0 → fastapi_startkit-0.56.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.54.0 → fastapi_startkit-0.56.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.54.0 → fastapi_startkit-0.56.0}/src/fastapi_startkit/storage/config/storage.py

@@ -19,12 +19,12 @@ class StorageConfig:
                 url=env("FILESYSTEM_PUBLIC_DISK_URL", "/storage"),
             ),
             "s3": S3Config(
-                key=env("AWS_ACCESS_KEY_ID"),
-                secret=env("AWS_SECRET_ACCESS_KEY"),
-                region=env("AWS_DEFAULT_REGION"),
-                bucket=env("AWS_BUCKET"),
-                url=env("AWS_URL"),
-                endpoint=env("AWS_ENDPOINT"),
+                key=env("AWS_ACCESS_KEY_ID", "", cast=False),
+                secret=env("AWS_SECRET_ACCESS_KEY", "", cast=False),
+                region=env("AWS_DEFAULT_REGION", "", cast=False),
+                bucket=env("AWS_BUCKET", "", cast=False),
+                url=env("AWS_URL", "", cast=False),
+                endpoint=env("AWS_ENDPOINT", "", cast=False),
             ),
         }
     )

fastapi_startkit-0.54.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