kiba-core 0.5.3.dev77__tar.gz → 0.5.3.dev78__tar.gz

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiba-core
-Version: 0.5.3.dev77
+Version: 0.5.3.dev78
 Summary: Kiba Labs' python utilities
 Project-URL: repository, https://github.com/kibalabs/core-py
 Requires-Python: <4,>=3.12

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev78}/core/store/database.py

@@ -4,7 +4,7 @@ import datetime
 import typing
 import weakref
 from collections.abc import AsyncIterator
-from typing import TypeVar
+from typing import TypeVarTuple
 
 import sqlalchemy
 import sqlalchemy.exc
@@ -20,7 +20,7 @@ from core.exceptions import InternalServerErrorException
 from core.util import json_util
 
 DatabaseConnection = AsyncConnection
-ResultType = TypeVar('ResultType', bound=tuple)  # type: ignore[type-arg]
+ResultType = TypeVarTuple('ResultType')
 
 
 class Database:
@@ -140,10 +140,10 @@ class Database:
                 self._connectionContext.reset(token)
 
     @typing.overload
-    async def execute(self, query: TypedReturnsRows[ResultType], connection: DatabaseConnection | None = None) -> Result[ResultType]: ...
+    async def execute(self, query: TypedReturnsRows[*ResultType], connection: DatabaseConnection | None = None) -> Result[*ResultType]: ...
     @typing.overload
-    async def execute(self, query: sqlalchemy.sql.Executable, connection: DatabaseConnection | None = None) -> Result[typing.Any]: ...  # type: ignore[explicit-any]
-    async def execute(self, query: sqlalchemy.sql.Executable, connection: DatabaseConnection | None = None) -> Result[typing.Any]:  # type: ignore[explicit-any]
+    async def execute(self, query: sqlalchemy.sql.Executable, connection: DatabaseConnection | None = None) -> Result[*tuple[typing.Any, ...]]: ...  # type: ignore[explicit-any]
+    async def execute(self, query: sqlalchemy.sql.Executable, connection: DatabaseConnection | None = None) -> Result[*tuple[typing.Any, ...]]:  # type: ignore[explicit-any]
         if not self._engine:
             raise InternalServerErrorException(message='Connection has not been established. Please called collect() first.')
         if not connection:
@@ -152,4 +152,4 @@ class Database:
             raise InternalServerErrorException(message='No connection found. Please provide a connection or call create_context_connection() for the context.')
         if isinstance(query, UpdateBase):
             self._connectionsWithWrites.add(connection)
-        return typing.cast(Result[typing.Any], await connection.execute(statement=query))  # type: ignore[explicit-any]
+        return typing.cast(Result[*tuple[typing.Any, ...]], await connection.execute(statement=query))  # type: ignore[explicit-any]

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev78}/core/store/entity_repository.py

@@ -79,7 +79,7 @@ class EntityRepository(typing.Generic[EntityType]):  # noqa: UP046
     def from_row(self, row: RowMapping) -> EntityType:
         return self.modelClass.model_validate(self._get_field_values(row=row))
 
-    def force_from_result(self, result: Result[typing.Any]) -> EntityType:  # type: ignore[explicit-any]
+    def force_from_result(self, result: Result[*tuple[typing.Any, ...]]) -> EntityType:  # type: ignore[explicit-any]
         row = result.mappings().first()
         if row is None:
             raise NotFoundException

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev78}/core/store/retriever.py

@@ -110,7 +110,7 @@ def datetime_to_column_value(column: sqlalchemy.ColumnElement[typing.Any], dt: d
     return date_util.datetime_to_utc_naive_datetime(dt=dt)
 
 
-def apply_order(query: Select[ResultType], table: Table, order: Order) -> Select[ResultType]:
+def apply_order(query: Select[*ResultType], table: Table, order: Order) -> Select[*ResultType]:
     if isinstance(order, RandomOrder):
         query = query.order_by(sqlalchemy.sql.functions.random())
     else:
@@ -119,7 +119,7 @@ def apply_order(query: Select[ResultType], table: Table, order: Order) -> Select
     return query
 
 
-def apply_orders(query: Select[ResultType], table: Table, orders: Sequence[Order]) -> Select[ResultType]:
+def apply_orders(query: Select[*ResultType], table: Table, orders: Sequence[Order]) -> Select[*ResultType]:
     for order in orders:
         query = apply_order(query=query, table=table, order=order)
     return query
@@ -259,7 +259,7 @@ def get_field_filters_conditions(table: Table, fieldFilters: Sequence[FieldFilte
     return [condition for fieldFilter in fieldFilters for condition in get_field_filter_conditions(table=table, fieldFilter=fieldFilter)]
 
 
-def apply_field_filters(query: Select[ResultType], table: Table, fieldFilters: Sequence[FieldFilter]) -> Select[ResultType]:
+def apply_field_filters(query: Select[*ResultType], table: Table, fieldFilters: Sequence[FieldFilter]) -> Select[*ResultType]:
     return query.where(*get_field_filters_conditions(table=table, fieldFilters=fieldFilters))
 
 
@@ -267,32 +267,32 @@ class Retriever:
     def __init__(self, database: Database) -> None:
         self.database = database
 
-    def _apply_order(self, query: Select[ResultType], table: Table, order: Order) -> Select[ResultType]:
+    def _apply_order(self, query: Select[*ResultType], table: Table, order: Order) -> Select[*ResultType]:
         return apply_order(query=query, table=table, order=order)
 
-    def _apply_orders(self, query: Select[ResultType], table: Table, orders: Sequence[Order]) -> Select[ResultType]:
+    def _apply_orders(self, query: Select[*ResultType], table: Table, orders: Sequence[Order]) -> Select[*ResultType]:
         return apply_orders(query=query, table=table, orders=orders)
 
-    def _apply_string_field_filter(self, query: Select[ResultType], table: Table, fieldFilter: StringFieldFilter) -> Select[ResultType]:
+    def _apply_string_field_filter(self, query: Select[*ResultType], table: Table, fieldFilter: StringFieldFilter) -> Select[*ResultType]:
         return query.where(*get_string_field_filter_conditions(table=table, fieldFilter=fieldFilter))
 
-    def _apply_uuid_field_filter(self, query: Select[ResultType], table: Table, fieldFilter: UUIDFieldFilter) -> Select[ResultType]:
+    def _apply_uuid_field_filter(self, query: Select[*ResultType], table: Table, fieldFilter: UUIDFieldFilter) -> Select[*ResultType]:
         return query.where(*get_uuid_field_filter_conditions(table=table, fieldFilter=fieldFilter))
 
-    def _apply_date_field_filter(self, query: Select[ResultType], table: Table, fieldFilter: DateFieldFilter) -> Select[ResultType]:
+    def _apply_date_field_filter(self, query: Select[*ResultType], table: Table, fieldFilter: DateFieldFilter) -> Select[*ResultType]:
         return query.where(*get_date_field_filter_conditions(table=table, fieldFilter=fieldFilter))
 
-    def _apply_integer_field_filter(self, query: Select[ResultType], table: Table, fieldFilter: IntegerFieldFilter) -> Select[ResultType]:
+    def _apply_integer_field_filter(self, query: Select[*ResultType], table: Table, fieldFilter: IntegerFieldFilter) -> Select[*ResultType]:
         return query.where(*get_integer_field_filter_conditions(table=table, fieldFilter=fieldFilter))
 
-    def _apply_float_field_filter(self, query: Select[ResultType], table: Table, fieldFilter: FloatFieldFilter) -> Select[ResultType]:
+    def _apply_float_field_filter(self, query: Select[*ResultType], table: Table, fieldFilter: FloatFieldFilter) -> Select[*ResultType]:
         return query.where(*get_float_field_filter_conditions(table=table, fieldFilter=fieldFilter))
 
-    def _apply_boolean_field_filter(self, query: Select[ResultType], table: Table, fieldFilter: BooleanFieldFilter) -> Select[ResultType]:
+    def _apply_boolean_field_filter(self, query: Select[*ResultType], table: Table, fieldFilter: BooleanFieldFilter) -> Select[*ResultType]:
         return query.where(*get_boolean_field_filter_conditions(table=table, fieldFilter=fieldFilter))
 
-    def _apply_field_filter(self, query: Select[ResultType], table: Table, fieldFilter: FieldFilter) -> Select[ResultType]:
+    def _apply_field_filter(self, query: Select[*ResultType], table: Table, fieldFilter: FieldFilter) -> Select[*ResultType]:
         return query.where(*get_field_filter_conditions(table=table, fieldFilter=fieldFilter))
 
-    def _apply_field_filters(self, query: Select[ResultType], table: Table, fieldFilters: Sequence[FieldFilter]) -> Select[ResultType]:
+    def _apply_field_filters(self, query: Select[*ResultType], table: Table, fieldFilters: Sequence[FieldFilter]) -> Select[*ResultType]:
         return apply_field_filters(query=query, table=table, fieldFilters=fieldFilters)

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev78}/core/store/saver.py

@@ -39,7 +39,7 @@ class Saver:
         async with self.database.create_transaction() as connection:
             yield connection
 
-    async def _execute(self, query: TypedReturnsRows[ResultType], connection: DatabaseConnection | None = None) -> Result[ResultType]:
+    async def _execute(self, query: TypedReturnsRows[*ResultType], connection: DatabaseConnection | None = None) -> Result[*ResultType]:
         try:
             if connection:
                 return await self.database.execute(query=query, connection=connection)

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev78}/kiba_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiba-core
-Version: 0.5.3.dev77
+Version: 0.5.3.dev78
 Summary: Kiba Labs' python utilities
 Project-URL: repository, https://github.com/kibalabs/core-py
 Requires-Python: <4,>=3.12

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev78}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiba-core"
-version = "0.5.3.dev77"
+version = "0.5.3.dev78"
 description = "Kiba Labs' python utilities"
 readme = "README.md"
 requires-python = ">=3.12, <4"