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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiba-core
-Version: 0.5.3.dev77
+Version: 0.5.3.dev79
 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.dev79}/core/locks/sql.py

@@ -11,6 +11,7 @@ from core.exceptions import LockedException
 from core.locks.lock import Lock
 from core.locks.model import LockLease
 from core.store.database import Database
+from core.store.database import DatabaseTable
 from core.util import date_util
 from core.util import process_util
 
@@ -31,7 +32,7 @@ LocksTable = sqlalchemy.Table(
 
 
 class SqlLock(Lock):
-    def __init__(self, database: Database, table: sqlalchemy.Table = LocksTable, pollIntervalSeconds: float = 1.0, owner: str | None = None) -> None:
+    def __init__(self, database: Database, table: DatabaseTable = LocksTable, pollIntervalSeconds: float = 1.0, owner: str | None = None) -> None:
         self.database = database
         self.table = table
         self.pollIntervalSeconds = pollIntervalSeconds

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev79}/core/queues/sql.py

@@ -16,6 +16,7 @@ from core.exceptions import InternalServerErrorException
 from core.queues.message_queue import MessageQueue
 from core.queues.model import Message
 from core.store.database import Database
+from core.store.database import DatabaseTable
 from core.util import process_util
 
 MESSAGE_STATUS_PENDING = 'pending'
@@ -61,7 +62,7 @@ class SqlMessage(Message):
     lockToken: str
 
     @classmethod
-    def from_row(cls, row: RowMapping, table: sqlalchemy.Table) -> SqlMessage:
+    def from_row(cls, row: RowMapping, table: DatabaseTable) -> SqlMessage:
         return cls(
             id=row[table.c.id],
             command=row[table.c.command],
@@ -79,7 +80,7 @@ class SqlMessageQueue(MessageQueue[SqlMessage]):
         self,
         database: Database,
         queueName: str,
-        table: sqlalchemy.Table = QueueMessagesTable,
+        table: DatabaseTable = QueueMessagesTable,
         pollIntervalSeconds: float = 1.0,
         maxAttempts: int = 3,
         failureRetryDelaySeconds: int = 60,

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev79}/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
@@ -12,7 +12,9 @@ from sqlalchemy.engine import Result
 from sqlalchemy.ext.asyncio import AsyncConnection
 from sqlalchemy.ext.asyncio import AsyncEngine
 from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.sql.base import ReadOnlyColumnCollection
 from sqlalchemy.sql.dml import UpdateBase
+from sqlalchemy.sql.elements import KeyedColumnElement
 from sqlalchemy.sql.selectable import TypedReturnsRows
 
 from core import logging
@@ -20,7 +22,10 @@ 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')
+# NOTE(krishan711): these spell out sqlalchemy 2.1's default column collections. mypy's disallow_any_explicit rejects bare Table / FromClause annotations because the defaults contain Any, but not uses of these aliases
+DatabaseTable = sqlalchemy.Table[ReadOnlyColumnCollection[str, sqlalchemy.Column[typing.Any]]]  # type: ignore[explicit-any]
+DatabaseFromClause = sqlalchemy.FromClause[ReadOnlyColumnCollection[str, KeyedColumnElement[typing.Any]]]  # type: ignore[explicit-any]
 
 
 class Database:
@@ -140,10 +145,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 +157,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.dev79}/core/store/entity_repository.py

@@ -14,6 +14,7 @@ from core.exceptions import KibaException
 from core.exceptions import NotFoundException
 from core.store.database import Database
 from core.store.database import DatabaseConnection
+from core.store.database import DatabaseTable
 from core.store.retriever import FieldFilter
 from core.store.retriever import Order
 from core.store.retriever import apply_field_filters
@@ -37,7 +38,7 @@ class EntityRepository(typing.Generic[EntityType]):  # noqa: UP046
 
     def __init__(
         self,
-        table: sqlalchemy.Table,
+        table: DatabaseTable,
         modelClass: type[EntityType],
     ) -> None:
         self.table = table
@@ -79,7 +80,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.dev79}/core/store/retriever.py

@@ -7,11 +7,11 @@ from enum import Enum
 
 import sqlalchemy
 import sqlalchemy.sql.functions
-from sqlalchemy import Table
 from sqlalchemy.sql import ColumnElement
 from sqlalchemy.sql import Select
 
 from core.store.database import Database
+from core.store.database import DatabaseTable
 from core.store.database import ResultType
 from core.util import date_util
 
@@ -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: DatabaseTable, order: Order) -> Select[*ResultType]:
     if isinstance(order, RandomOrder):
         query = query.order_by(sqlalchemy.sql.functions.random())
     else:
@@ -119,13 +119,13 @@ 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: DatabaseTable, orders: Sequence[Order]) -> Select[*ResultType]:
     for order in orders:
         query = apply_order(query=query, table=table, order=order)
     return query
 
 
-def get_string_field_filter_conditions(table: Table, fieldFilter: StringFieldFilter) -> list[ColumnElement[bool]]:
+def get_string_field_filter_conditions(table: DatabaseTable, fieldFilter: StringFieldFilter) -> list[ColumnElement[bool]]:
     field = table.c[fieldFilter.fieldName]
     conditions: list[ColumnElement[bool]] = []
     if fieldFilter.eq is not None:
@@ -139,7 +139,7 @@ def get_string_field_filter_conditions(table: Table, fieldFilter: StringFieldFil
     return conditions
 
 
-def get_uuid_field_filter_conditions(table: Table, fieldFilter: UUIDFieldFilter) -> list[ColumnElement[bool]]:
+def get_uuid_field_filter_conditions(table: DatabaseTable, fieldFilter: UUIDFieldFilter) -> list[ColumnElement[bool]]:
     field = table.c[fieldFilter.fieldName]
     conditions: list[ColumnElement[bool]] = []
     if fieldFilter.eq is not None:
@@ -153,7 +153,7 @@ def get_uuid_field_filter_conditions(table: Table, fieldFilter: UUIDFieldFilter)
     return conditions
 
 
-def get_date_field_filter_conditions(table: Table, fieldFilter: DateFieldFilter) -> list[ColumnElement[bool]]:
+def get_date_field_filter_conditions(table: DatabaseTable, fieldFilter: DateFieldFilter) -> list[ColumnElement[bool]]:
     field = table.c[fieldFilter.fieldName]
     conditions: list[ColumnElement[bool]] = []
     if fieldFilter.eq is not None:
@@ -175,7 +175,7 @@ def get_date_field_filter_conditions(table: Table, fieldFilter: DateFieldFilter)
     return conditions
 
 
-def get_integer_field_filter_conditions(table: Table, fieldFilter: IntegerFieldFilter) -> list[ColumnElement[bool]]:
+def get_integer_field_filter_conditions(table: DatabaseTable, fieldFilter: IntegerFieldFilter) -> list[ColumnElement[bool]]:
     # NOTE(krishan711): `field == value` / `field.in_(values)` let SQLAlchemy's `Numeric.coerce_compared_value`
     # re-infer a bind param type from the compared Python `int` (typically `BigInteger`, i.e. int64) instead of
     # keeping `field.type` (e.g. `Numeric(78, 0)` for uint256 columns). Binding explicitly with `type_=field.type`
@@ -201,7 +201,7 @@ def get_integer_field_filter_conditions(table: Table, fieldFilter: IntegerFieldF
     return conditions
 
 
-def get_float_field_filter_conditions(table: Table, fieldFilter: FloatFieldFilter) -> list[ColumnElement[bool]]:
+def get_float_field_filter_conditions(table: DatabaseTable, fieldFilter: FloatFieldFilter) -> list[ColumnElement[bool]]:
     field = table.c[fieldFilter.fieldName]
     conditions: list[ColumnElement[bool]] = []
     if fieldFilter.eq is not None:
@@ -223,7 +223,7 @@ def get_float_field_filter_conditions(table: Table, fieldFilter: FloatFieldFilte
     return conditions
 
 
-def get_boolean_field_filter_conditions(table: Table, fieldFilter: BooleanFieldFilter) -> list[ColumnElement[bool]]:
+def get_boolean_field_filter_conditions(table: DatabaseTable, fieldFilter: BooleanFieldFilter) -> list[ColumnElement[bool]]:
     field = table.c[fieldFilter.fieldName]
     conditions: list[ColumnElement[bool]] = []
     if fieldFilter.eq is not None:
@@ -233,7 +233,7 @@ def get_boolean_field_filter_conditions(table: Table, fieldFilter: BooleanFieldF
     return conditions
 
 
-def get_field_filter_conditions(table: Table, fieldFilter: FieldFilter) -> list[ColumnElement[bool]]:
+def get_field_filter_conditions(table: DatabaseTable, fieldFilter: FieldFilter) -> list[ColumnElement[bool]]:
     field = table.c[fieldFilter.fieldName]
     conditions: list[ColumnElement[bool]] = []
     if fieldFilter.isNull:
@@ -255,11 +255,11 @@ def get_field_filter_conditions(table: Table, fieldFilter: FieldFilter) -> list[
     return conditions
 
 
-def get_field_filters_conditions(table: Table, fieldFilters: Sequence[FieldFilter]) -> list[ColumnElement[bool]]:
+def get_field_filters_conditions(table: DatabaseTable, fieldFilters: Sequence[FieldFilter]) -> list[ColumnElement[bool]]:
     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: DatabaseTable, 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: DatabaseTable, 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: DatabaseTable, 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: DatabaseTable, 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: DatabaseTable, 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: DatabaseTable, 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: DatabaseTable, 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: DatabaseTable, 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: DatabaseTable, 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: DatabaseTable, 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: DatabaseTable, 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.dev79}/core/store/saver.py

@@ -3,13 +3,13 @@ from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING
 from typing import Any
 
-from sqlalchemy import Table
 from sqlalchemy.engine import Result
 from sqlalchemy.sql.selectable import TypedReturnsRows
 
 from core.exceptions import InternalServerErrorException
 from core.store.database import Database
 from core.store.database import DatabaseConnection
+from core.store.database import DatabaseTable
 from core.store.database import ResultType
 
 if TYPE_CHECKING:
@@ -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)
@@ -49,19 +49,19 @@ class Saver:
         except Exception as exception:
             raise SavingException(message=f'Error running save operation: {exception!s}') from exception
 
-    async def _insert_record(self, table: Table, values: CreateRecordValuesDict, connection: DatabaseConnection | None = None) -> int:
+    async def _insert_record(self, table: DatabaseTable, values: CreateRecordValuesDict, connection: DatabaseConnection | None = None) -> int:
         query = table.insert().values(values).returning(table.c.id)
         result = await self._execute(query=query, connection=connection)
         rowId = int(result.scalar_one())
         return rowId
 
-    async def _update_records(self, table: Table, where: WhereClause, values: UpdateRecordValuesDict, connection: DatabaseConnection | None = None) -> list[int]:
+    async def _update_records(self, table: DatabaseTable, where: WhereClause, values: UpdateRecordValuesDict, connection: DatabaseConnection | None = None) -> list[int]:
         query = table.update().where(where).values(values).returning(table.c.id)
         result = await self._execute(query=query, connection=connection)
         rowIds = [int(rowId) for rowId in result.scalars()]
         return rowIds
 
-    async def _delete_records(self, table: Table, where: WhereClause, connection: DatabaseConnection | None = None) -> list[int]:
+    async def _delete_records(self, table: DatabaseTable, where: WhereClause, connection: DatabaseConnection | None = None) -> list[int]:
         query = table.delete().where(where).returning(table.c.id)
         result = await self._execute(query=query, connection=connection)
         rowIds = [int(rowId) for rowId in result.scalars()]

{kiba_core-0.5.3.dev77 → kiba_core-0.5.3.dev79}/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.dev79
 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.dev79}/pyproject.toml

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