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

kiba_core-0.5.3.dev80/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish
+on:
+  push:
+    tags: ["v*"]
+jobs:
+  deploy-package:
+    runs-on: ubuntu-latest
+    env:
+      DOCKER_IMAGE: build
+      PYPI_PUBLISH_TOKEN: ${{ secrets.PYPI_PUBLISH_TOKEN }}
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v7
+      - name: Build docker image
+        run: docker build --tag $DOCKER_IMAGE .
+      - name: Publish package to pypi
+        run: docker run -e UV_PUBLISH_TOKEN=$PYPI_PUBLISH_TOKEN $DOCKER_IMAGE /bin/bash -c " make publish"
+  create-release:
+    needs: deploy-package
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v7
+      - name: Create Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh release create ${{ github.ref_name }} --title "Release ${{ github.ref_name }}" --generate-notes

kiba_core-0.5.3.dev80/.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: Release
+on:
+  workflow_dispatch:
+concurrency:
+  group: release
+jobs:
+  push-version-tag:
+    runs-on: ubuntu-latest
+    # NOTE(krishan711): the release environment only allows main and holds the deploy key, the only thing allowed to push version tags. Unlike the GITHUB_TOKEN, a push with it starts the workflows that publish the tag.
+    environment: release
+    permissions:
+      contents: read
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v7
+        with:
+          ssh-key: ${{ secrets.RELEASE_DEPLOY_KEY }}
+      - name: Push the version tag
+        run: |
+          version="v$(python3 -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")"
+          if [[ ! "$version" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "::error::pyproject.toml version $version is not X.Y.Z"
+            exit 1
+          fi
+          existingSha="$(git ls-remote origin "refs/tags/$version" | cut -f1)"
+          if [[ "$existingSha" == "$GITHUB_SHA" ]]; then
+            echo "$version is already tagged on this commit; if publishing failed, re-run the workflow run for the tag"
+          elif [[ -n "$existingSha" ]]; then
+            echo "::error::$version already exists on $existingSha, bump the version in pyproject.toml"
+            exit 1
+          else
+            git tag "$version"
+            git push origin "refs/tags/$version"
+          fi

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

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

{kiba_core-0.5.3.dev78 → kiba_core-0.5.3.dev80}/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.dev78 → kiba_core-0.5.3.dev80}/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.dev78 → kiba_core-0.5.3.dev80}/core/store/database.py

@@ -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
@@ -21,6 +23,9 @@ from core.util import json_util
 
 DatabaseConnection = AsyncConnection
 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:

{kiba_core-0.5.3.dev78 → kiba_core-0.5.3.dev80}/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

{kiba_core-0.5.3.dev78 → kiba_core-0.5.3.dev80}/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) -> Selec
     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.dev78 → kiba_core-0.5.3.dev80}/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:
@@ -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.dev78 → kiba_core-0.5.3.dev80}/kiba_core.egg-info/PKG-INFO

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

{kiba_core-0.5.3.dev78 → kiba_core-0.5.3.dev80}/kiba_core.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ pyproject.toml
 uv.lock
 .github/pull_request_template.md
 .github/workflows/deploy.yml
+.github/workflows/publish.yml
 .github/workflows/pull-request.yml
 .github/workflows/release.yml
 core/__init__.py

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

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

kiba_core-0.5.3.dev78/.github/workflows/release.yml

@@ -1,39 +0,0 @@
-name: Release
-on:
-  push:
-    tags: ["v*"]
-jobs:
-  deploy-package:
-    runs-on: ubuntu-latest
-    env:
-      DOCKER_IMAGE: build
-      PYPI_PUBLISH_TOKEN: ${{ secrets.PYPI_PUBLISH_TOKEN }}
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v2
-      - name: Check the package version is the same as the tag
-        run: |
-          version=$(python3 setup.py --version)
-          if [ "${{ github.ref }}" != "refs/tags/v${version}" ]; then
-            echo "version in setup.py (v${version}) is different to the given tag (${{ github.ref }})"
-            exit 1;
-          fi
-      - name: Build docker image
-        run: docker build --tag $DOCKER_IMAGE .
-      - name: Publish package to pypi
-        run: docker run -e UV_PUBLISH_TOKEN=$PYPI_PUBLISH_TOKEN $DOCKER_IMAGE /bin/bash -c " make publish"
-  create-release:
-    needs: deploy-package
-    runs-on: ubuntu-latest
-    env:
-      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v2
-      - name: Create Release
-        uses: actions/create-release@v1
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          draft: false
-          prerelease: false