ddsql 0.2.0__tar.gz → 0.3.0__tar.gz

{ddsql-0.2.0 → ddsql-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddsql
-Version: 0.2.0
+Version: 0.3.0
 Summary: SQL Query Library
 Keywords: python,ddsql
 Author: davyddd
@@ -141,7 +141,7 @@ per task. The connections module adds two things on top:
 
 - `ConnectionManagerFactory(registries, default, connection_manager_class=ConnectionManager)` resolves a
   connection alias to its registry, like Django's `using`. Calling it opens a connection manager on the
-  chosen registry; `registry(using)` returns the registry itself.
+  chosen registry; `registry(alias)` returns the registry itself.
 - `ConnectionManager(registry)` is the default connection manager: an async context manager that hands out
   the connection of the registry's current scope and releases nothing on exit. Enough for clients that are
   pools themselves, such as ClickHouse.
@@ -177,7 +177,7 @@ async with clickhouse() as client:
 atomic = ConnectionManagerFactory(session_registries, default=PostgresDB.PRIMARY, connection_manager_class=Atomic)
 
 
-async with atomic(using=PostgresDB.REPLICA) as session:
+async with atomic(alias=PostgresDB.REPLICA) as session:
     ...
 ```
 
@@ -202,7 +202,7 @@ class PostgresAdapter(Adapter):
     serializer = PostgresSerializer()
 
     async def _execute(self) -> Sequence[dict[str, Any]]:
-        async with atomic(using=self.db) as session:
+        async with atomic(alias=self.alias) as session:
             query = await self.get_query()  # the rendered SQL query
             result = await session.execute(text(query))
             return [dict(zip(result.keys(), row)) for row in result.fetchall()]
@@ -213,8 +213,8 @@ adapters are validated.
 
 ### Choosing the database
 
-`Adapter.using(db)` picks the database right before executing, like Django's `using`. `_execute` reads
-`self.db` (`None` means the default) and passes it to whatever opens the connection, as in the example above:
+`Adapter.using(alias)` picks the connection alias right before executing, like Django's `using`. `_execute`
+reads `self.alias` (`None` means the default) and passes it to whatever opens the connection, as in the example above:
 
 ```python
 await SQL(query).postgres.execute()                               # default connection

{ddsql-0.2.0 → ddsql-0.3.0}/README.md

@@ -121,7 +121,7 @@ per task. The connections module adds two things on top:
 
 - `ConnectionManagerFactory(registries, default, connection_manager_class=ConnectionManager)` resolves a
   connection alias to its registry, like Django's `using`. Calling it opens a connection manager on the
-  chosen registry; `registry(using)` returns the registry itself.
+  chosen registry; `registry(alias)` returns the registry itself.
 - `ConnectionManager(registry)` is the default connection manager: an async context manager that hands out
   the connection of the registry's current scope and releases nothing on exit. Enough for clients that are
   pools themselves, such as ClickHouse.
@@ -157,7 +157,7 @@ async with clickhouse() as client:
 atomic = ConnectionManagerFactory(session_registries, default=PostgresDB.PRIMARY, connection_manager_class=Atomic)
 
 
-async with atomic(using=PostgresDB.REPLICA) as session:
+async with atomic(alias=PostgresDB.REPLICA) as session:
     ...
 ```
 
@@ -182,7 +182,7 @@ class PostgresAdapter(Adapter):
     serializer = PostgresSerializer()
 
     async def _execute(self) -> Sequence[dict[str, Any]]:
-        async with atomic(using=self.db) as session:
+        async with atomic(alias=self.alias) as session:
             query = await self.get_query()  # the rendered SQL query
             result = await session.execute(text(query))
             return [dict(zip(result.keys(), row)) for row in result.fetchall()]
@@ -193,8 +193,8 @@ adapters are validated.
 
 ### Choosing the database
 
-`Adapter.using(db)` picks the database right before executing, like Django's `using`. `_execute` reads
-`self.db` (`None` means the default) and passes it to whatever opens the connection, as in the example above:
+`Adapter.using(alias)` picks the connection alias right before executing, like Django's `using`. `_execute`
+reads `self.alias` (`None` means the default) and passes it to whatever opens the connection, as in the example above:
 
 ```python
 await SQL(query).postgres.execute()                               # default connection

{ddsql-0.2.0 → ddsql-0.3.0}/ddsql/adapter.py

@@ -31,17 +31,17 @@ class Adapter(ABC):
 
     def __init__(self, sql: SQLBase) -> None:
         self.sql = sql
-        self.db: Hashable | None = None
+        self.alias: Hashable | None = None
 
-    def using(self, db: Hashable) -> Self:
+    def using(self, alias: Hashable) -> Self:
         """
-        Picks the database for this execution, like Django's `using`; `_execute` reads `self.db`
+        Picks the connection alias for this execution, like Django's `using`; `_execute` reads `self.alias`
         (`None` = default) and passes it to whatever opens the connection:
 
             await SQL(query).postgres.execute()                               # default connection
             await SQL(query).postgres.using(PostgresDB.REPLICA).execute()
         """
-        self.db = db
+        self.alias = alias
         return self
 
     async def get_query(self) -> str:

{ddsql-0.2.0 → ddsql-0.3.0}/ddsql/connections.py

@@ -41,7 +41,7 @@ class ConnectionManagerFactory(Generic[ConnectionAliasT, ConnectionT, Connection
         atomic = ConnectionManagerFactory(session_registries, default=PostgresDB.PRIMARY, connection_manager_class=Atomic)
 
         async with clickhouse() as client: ...
-        async with atomic(using=PostgresDB.REPLICA) as session: ...
+        async with atomic(alias=PostgresDB.REPLICA) as session: ...
     """
 
     def __init__(
@@ -56,15 +56,15 @@ class ConnectionManagerFactory(Generic[ConnectionAliasT, ConnectionT, Connection
         self.default = default
         self.connection_manager_class = connection_manager_class
 
-    def registry(self, using: Hashable | None = None) -> ScopedRegistry[ConnectionT]:
-        """The registry of `using`, or of the default connection; `Hashable` because `Adapter.db` is untyped."""
-        alias = self.default if using is None else using
+    def registry(self, alias: Hashable | None = None) -> ScopedRegistry[ConnectionT]:
+        """The registry of `alias`, or of the default connection; `Hashable` because `Adapter.alias` is untyped."""
+        alias = self.default if alias is None else alias
         if alias not in self.registries:
             raise KeyError(f'Unknown connection {alias!r}; expected one of {list(self.registries)!r}')
         return self.registries[alias]  # type: ignore[index]
 
-    def __call__(self, using: Hashable | None = None) -> ConnectionManagerT:
-        return self.connection_manager_class(self.registry(using))
+    def __call__(self, alias: Hashable | None = None) -> ConnectionManagerT:
+        return self.connection_manager_class(self.registry(alias))
 
 
 __all__ = ('ConnectionManager', 'ConnectionManagerFactory')

{ddsql-0.2.0 → ddsql-0.3.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "ddsql"
 description = "SQL Query Library"
-version = "0.2.0"
+version = "0.3.0"
 license = "MIT"
 license-files = ["LICENSE"]
 readme = "README.md"

{ddsql-0.2.0 → ddsql-0.3.0}/pyproject.toml.orig

@@ -1,7 +1,7 @@
 [project]
 name = "ddsql"
 description = "SQL Query Library"
-version = "0.2.0"
+version = "0.3.0"
 authors = [{ name = "davyddd" }]
 license = "MIT"
 license-files = ["LICENSE"]