kiba-core 0.5.3.dev55__tar.gz → 0.5.3.dev56__tar.gz

{kiba_core-0.5.3.dev55 → kiba_core-0.5.3.dev56}/CHANGELOG.md

@@ -8,6 +8,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 ## [Unreleased]
 
 ### Added
+- [MINOR] Use `json_util`/`orjson` for API and database JSON serialization
+- [MINOR] Use Pydantic `JsonValue` for JSON type aliases
 - [MAJOR] Update web3 to 7.8.0
 - [MINOR] Added `call_function_by_name`, `send_transaction_by_name` and `wait_for_transaction_receipt` to `RestEthClient`
 - [MINOR] Updated `RestEthClient` to use `maxPriorityFeePerGas` and `maxFeePerGas` instead of `gasPrice`

{kiba_core-0.5.3.dev55 → kiba_core-0.5.3.dev56}/PKG-INFO

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

{kiba_core-0.5.3.dev55 → kiba_core-0.5.3.dev56}/core/api/default_routes.py

@@ -1,13 +1,14 @@
 from starlette.requests import Request
-from starlette.responses import JSONResponse
 from starlette.responses import Response
 from starlette.routing import BaseRoute
 from starlette.routing import Route
 
+from core.api.api_response import KibaJSONResponse
+
 
 def create_default_routes(name: str, version: str, environment: str) -> list[BaseRoute]:
     async def root(request: Request) -> Response:  # noqa: ARG001
-        return JSONResponse(content={'server': name, 'version': version, 'environment': environment})
+        return KibaJSONResponse(content={'server': name, 'version': version, 'environment': environment})
 
     return [
         Route('/', methods=['GET'], endpoint=root),

{kiba_core-0.5.3.dev55 → kiba_core-0.5.3.dev56}/core/api/middleware/exception_handling_middleware.py

@@ -1,11 +1,11 @@
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.middleware.base import RequestResponseEndpoint
 from starlette.requests import Request
-from starlette.responses import JSONResponse
 from starlette.responses import Response
 from starlette.types import ASGIApp
 
 from core import logging
+from core.api.api_response import KibaJSONResponse
 from core.exceptions import ClientException
 from core.exceptions import KibaException
 from core.exceptions import RedirectException
@@ -19,7 +19,7 @@ class ExceptionHandlingMiddleware(BaseHTTPMiddleware):
 
     @staticmethod
     def _convert_exception(exception: KibaException) -> Response:
-        response = JSONResponse(status_code=exception.statusCode, content=exception.to_dict())
+        response = KibaJSONResponse(status_code=exception.statusCode, content=exception.to_dict())
         response.headers.update(exception.outgoing_headers())
         return response
 

{kiba_core-0.5.3.dev55 → kiba_core-0.5.3.dev56}/core/store/database.py

@@ -14,6 +14,7 @@ from sqlalchemy.sql.selectable import TypedReturnsRows
 
 from core import logging
 from core.exceptions import InternalServerErrorException
+from core.util import json_util
 
 DatabaseConnection = AsyncConnection
 ResultType = TypeVar('ResultType', bound=tuple)  # type: ignore[type-arg]
@@ -43,6 +44,8 @@ class Database:
                 self.connectionString,
                 # echo_pool=True,
                 # hide_parameters=False,
+                json_serializer=json_util.dumps,
+                json_deserializer=json_util.loads,
                 pool_size=poolSize,
                 pool_recycle=3600,
                 pool_pre_ping=True,

kiba_core-0.5.3.dev56/core/util/typing_util.py

@@ -0,0 +1,5 @@
+from pydantic import JsonValue
+
+type Json = JsonValue
+type JsonObject = dict[str, JsonValue]
+type JsonList = list[JsonValue]

{kiba_core-0.5.3.dev55 → kiba_core-0.5.3.dev56}/kiba_core.egg-info/PKG-INFO

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

{kiba_core-0.5.3.dev55 → kiba_core-0.5.3.dev56}/kiba_core.egg-info/SOURCES.txt

@@ -78,11 +78,17 @@ kiba_core.egg-info/dependency_links.txt
 kiba_core.egg-info/requires.txt
 kiba_core.egg-info/top_level.txt
 tests/__init__.py
+tests/test_database.py
+tests/test_exceptions.py
+tests/api/test_api_response.py
 tests/api/test_authorizer.py
+tests/api/test_exception_handling_middleware.py
 tests/api/test_json_route.py
 tests/api/test_streaming_json_route.py
 tests/caching/test_dict_cache.py
 tests/caching/test_file_cache.py
+tests/requester/__init__.py
+tests/requester/test_requester.py
 tests/util/__init__.py
 tests/util/test_async_util.py
 tests/util/test_chain_util.py

{kiba_core-0.5.3.dev55 → kiba_core-0.5.3.dev56}/pyproject.toml

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

kiba_core-0.5.3.dev56/tests/api/test_api_response.py

@@ -0,0 +1,39 @@
+import datetime
+
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.routing import Route
+from starlette.testclient import TestClient
+
+from core.api.api_response import KibaJSONResponse
+from core.api.default_routes import create_default_routes
+from core.api.middleware.exception_handling_middleware import ExceptionHandlingMiddleware
+from core.exceptions import BadRequestException
+
+
+def test_kiba_json_response_uses_compact_utf8_serialization():
+    response = KibaJSONResponse(content={'message': 'Hello 🌍', 'createdAt': datetime.datetime(2025, 1, 2, 3, 4, 5), 'values': [1, 2]})
+
+    assert response.body == '{"message":"Hello 🌍","createdAt":"2025-01-02T03:04:05","values":[1,2]}'.encode()
+
+
+def test_default_route_uses_kiba_json_response():
+    app = Starlette(routes=create_default_routes(name='core', version='1.0', environment='test'))
+    client = TestClient(app)
+
+    response = client.get('/')
+
+    assert response.content == b'{"server":"core","version":"1.0","environment":"test"}'
+
+
+def test_exception_handling_middleware_uses_kiba_json_response():
+    async def failing_endpoint(_request: Request) -> KibaJSONResponse:
+        raise BadRequestException(message='bad input')
+
+    app = Starlette(routes=[Route('/fail', failing_endpoint)])
+    app.add_middleware(ExceptionHandlingMiddleware)
+    client = TestClient(app, raise_server_exceptions=False)
+
+    response = client.get('/fail')
+
+    assert response.content == b'{"exceptionType":"BadRequestException","message":"bad input","fields":{},"statusCode":400}'

kiba_core-0.5.3.dev56/tests/api/test_exception_handling_middleware.py

@@ -0,0 +1,109 @@
+import pytest
+from pydantic import BaseModel
+from starlette.applications import Starlette
+from starlette.routing import Route
+from starlette.testclient import TestClient
+
+from core.api.api_request import KibaApiRequest
+from core.api.json_route import json_route
+from core.api.middleware.exception_handling_middleware import ExceptionHandlingMiddleware
+from core.exceptions import BadRequestException
+from core.exceptions import FoundRedirectException
+from core.exceptions import MovedPermanentlyRedirectException
+from core.exceptions import TooManyRequestsException
+
+
+class SimpleRequest(BaseModel):
+    value: str
+
+
+class SimpleResponse(BaseModel):
+    result: str
+
+
+@pytest.fixture
+def rate_limited_client():
+    @json_route(requestType=SimpleRequest, responseType=SimpleResponse)
+    async def limited_endpoint(request: KibaApiRequest[SimpleRequest]) -> SimpleResponse:
+        raise TooManyRequestsException(message='slow down', retryAfterSeconds=30)
+
+    app = Starlette(routes=[Route('/limited', limited_endpoint, methods=['POST'])])
+    app.add_middleware(ExceptionHandlingMiddleware)
+    return TestClient(app, raise_server_exceptions=False)
+
+
+@pytest.fixture
+def rate_limited_no_retry_client():
+    @json_route(requestType=SimpleRequest, responseType=SimpleResponse)
+    async def limited_endpoint(request: KibaApiRequest[SimpleRequest]) -> SimpleResponse:
+        raise TooManyRequestsException(message='slow down')
+
+    app = Starlette(routes=[Route('/limited', limited_endpoint, methods=['POST'])])
+    app.add_middleware(ExceptionHandlingMiddleware)
+    return TestClient(app, raise_server_exceptions=False)
+
+
+@pytest.fixture
+def found_redirect_client():
+    @json_route(requestType=SimpleRequest, responseType=SimpleResponse)
+    async def redirect_endpoint(request: KibaApiRequest[SimpleRequest]) -> SimpleResponse:
+        raise FoundRedirectException(location='https://example.com/elsewhere')
+
+    app = Starlette(routes=[Route('/redirect', redirect_endpoint, methods=['POST'])])
+    app.add_middleware(ExceptionHandlingMiddleware)
+    return TestClient(app, raise_server_exceptions=False, follow_redirects=False)
+
+
+@pytest.fixture
+def permanent_redirect_client():
+    @json_route(requestType=SimpleRequest, responseType=SimpleResponse)
+    async def redirect_endpoint(request: KibaApiRequest[SimpleRequest]) -> SimpleResponse:
+        raise MovedPermanentlyRedirectException(location='https://example.com/moved')
+
+    app = Starlette(routes=[Route('/redirect', redirect_endpoint, methods=['POST'])])
+    app.add_middleware(ExceptionHandlingMiddleware)
+    return TestClient(app, raise_server_exceptions=False, follow_redirects=False)
+
+
+@pytest.fixture
+def plain_error_client():
+    @json_route(requestType=SimpleRequest, responseType=SimpleResponse)
+    async def failing_endpoint(request: KibaApiRequest[SimpleRequest]) -> SimpleResponse:
+        raise BadRequestException(message='bad input')
+
+    app = Starlette(routes=[Route('/fail', failing_endpoint, methods=['POST'])])
+    app.add_middleware(ExceptionHandlingMiddleware)
+    return TestClient(app, raise_server_exceptions=False)
+
+
+def test_too_many_requests_returns_429_with_retry_after_header(rate_limited_client):
+    response = rate_limited_client.post('/limited', json={'value': 'hello'})
+    assert response.status_code == 429
+    assert response.headers['retry-after'] == '30'
+
+
+def test_too_many_requests_without_retry_after_omits_header(rate_limited_no_retry_client):
+    response = rate_limited_no_retry_client.post('/limited', json={'value': 'hello'})
+    assert response.status_code == 429
+    assert 'retry-after' not in response.headers
+
+
+def test_found_redirect_sets_location_without_cache_header(found_redirect_client):
+    response = found_redirect_client.post('/redirect', json={'value': 'hello'})
+    assert response.status_code == 302
+    assert response.headers['location'] == 'https://example.com/elsewhere'
+    assert 'cache-control' not in response.headers
+
+
+def test_permanent_redirect_sets_location_and_cache_header(permanent_redirect_client):
+    response = permanent_redirect_client.post('/redirect', json={'value': 'hello'})
+    assert response.status_code == 301
+    assert response.headers['location'] == 'https://example.com/moved'
+    assert response.headers['cache-control'] == f'max-age={60 * 60 * 24 * 365}'
+
+
+def test_plain_exception_has_no_extra_headers(plain_error_client):
+    response = plain_error_client.post('/fail', json={'value': 'hello'})
+    assert response.status_code == 400
+    assert 'retry-after' not in response.headers
+    assert 'location' not in response.headers

kiba_core-0.5.3.dev56/tests/requester/test_requester.py

@@ -0,0 +1,41 @@
+import httpx
+import pytest
+
+from core.exceptions import NotFoundException
+from core.exceptions import TooManyRequestsException
+from core.requester.requester import Requester
+
+
+class TestRequesterExceptionHeaders:
+
+    @pytest.mark.asyncio
+    async def test_429_response_populates_retry_after_from_header(self):
+        def handler(request: httpx.Request) -> httpx.Response:  # noqa: ARG001
+            return httpx.Response(429, headers={'Retry-After': '17'}, text='Too Many Requests')
+
+        requester = Requester()
+        requester.client = httpx.AsyncClient(transport=httpx.MockTransport(handler))
+        with pytest.raises(TooManyRequestsException) as excInfo:
+            await requester.get(url='https://example.com/resource')
+        assert excInfo.value.retryAfterSeconds == 17
+
+    @pytest.mark.asyncio
+    async def test_429_response_without_retry_after_header(self):
+        def handler(request: httpx.Request) -> httpx.Response:  # noqa: ARG001
+            return httpx.Response(429, text='Too Many Requests')
+
+        requester = Requester()
+        requester.client = httpx.AsyncClient(transport=httpx.MockTransport(handler))
+        with pytest.raises(TooManyRequestsException) as excInfo:
+            await requester.get(url='https://example.com/resource')
+        assert excInfo.value.retryAfterSeconds is None
+
+    @pytest.mark.asyncio
+    async def test_404_response_still_maps_to_correct_exception_type(self):
+        def handler(request: httpx.Request) -> httpx.Response:  # noqa: ARG001
+            return httpx.Response(404, text='Not Found')
+
+        requester = Requester()
+        requester.client = httpx.AsyncClient(transport=httpx.MockTransport(handler))
+        with pytest.raises(NotFoundException):
+            await requester.get(url='https://example.com/resource')

kiba_core-0.5.3.dev56/tests/test_database.py

@@ -0,0 +1,121 @@
+import datetime
+
+import pytest
+import sqlalchemy
+from sqlalchemy import JSON
+from sqlalchemy import Column
+from sqlalchemy import MetaData
+from sqlalchemy import Table
+from sqlalchemy import insert
+from sqlalchemy import select
+from sqlalchemy import text
+
+from core.exceptions import InternalServerErrorException
+from core.store.database import Database
+from core.util import json_util
+
+
+@pytest.fixture
+def database(tmp_path):
+    return Database(connectionString=Database.create_sqlite_connection_string(str(tmp_path / 'database.sqlite')))
+
+
+@pytest.mark.parametrize(
+    ('engine', 'username', 'password', 'host', 'port', 'name', 'expected'),
+    [
+        ('postgresql+asyncpg', 'user', 'password', 'localhost', '5432', 'core', 'postgresql+asyncpg://user:password@localhost:5432/core'),
+    ],
+)
+def test_create_connection_string(engine, username, password, host, port, name, expected):
+    assert Database.create_connection_string(engine, username, password, host, port, name) == expected
+
+
+def test_create_psql_connection_string():
+    assert Database.create_psql_connection_string('user', 'password', 'localhost', '5432', 'core') == 'postgresql+asyncpg://user:password@localhost:5432/core'
+
+
+def test_create_sqlite_connection_string():
+    assert Database.create_sqlite_connection_string('database.sqlite') == 'sqlite+aiosqlite:///database.sqlite'
+
+
+@pytest.mark.asyncio
+async def test_connect_is_idempotent_and_disconnect_clears_engine(database):
+    await database.connect(poolSize=1)
+    engine = database._engine
+
+    await database.connect(poolSize=2)
+
+    assert database._engine is engine
+    assert database._engine.sync_engine.dialect._json_serializer is json_util.dumps
+    assert database._engine.sync_engine.dialect._json_deserializer is json_util.loads
+
+    await database.disconnect()
+    assert database._engine is None
+    await database.disconnect()
+
+
+@pytest.mark.asyncio
+async def test_create_transaction_requires_connection(database):
+    with pytest.raises(InternalServerErrorException, match='Engine has not been established'):
+        async with database.create_transaction():
+            pass
+
+
+@pytest.mark.asyncio
+async def test_execute_requires_connection(database):
+    with pytest.raises(InternalServerErrorException, match='Connection has not been established'):
+        await database.execute(text('SELECT 1'))
+
+
+@pytest.mark.asyncio
+async def test_json_values_round_trip_through_sqlalchemy(database):
+    metadata = MetaData()
+    records = Table(
+        'records',
+        metadata,
+        Column('id', sqlalchemy.Integer, primary_key=True),
+        Column('payload', JSON, nullable=False),
+    )
+    payload = {
+        'createdAt': datetime.datetime(2025, 1, 2, 3, 4, 5),
+        'message': 'Hello 🌍',
+        'nested': {'enabled': True, 'values': [None, 1, 2.5]},
+    }
+
+    await database.connect(poolSize=1)
+    async with database.create_transaction() as connection:
+        await connection.run_sync(metadata.create_all)
+        await database.execute(insert(records).values(payload=payload), connection=connection)
+        result = await database.execute(select(records.c.payload), connection=connection)
+
+    assert result.scalar_one() == {
+        'createdAt': '2025-01-02T03:04:05',
+        'message': 'Hello 🌍',
+        'nested': {'enabled': True, 'values': [None, 1, 2.5]},
+    }
+    await database.disconnect()
+
+
+@pytest.mark.asyncio
+async def test_context_connection_is_used_by_execute(database):
+    await database.connect(poolSize=1)
+
+    async with database.create_context_connection() as connection:
+        result = await database.execute(text('SELECT 42 AS answer'))
+        assert result.scalar_one() == 42
+        assert database._get_context_connection() is connection
+
+    assert database._get_context_connection() is None
+    await database.disconnect()
+
+
+@pytest.mark.asyncio
+async def test_context_connection_cannot_be_nested(database):
+    await database.connect(poolSize=1)
+
+    with pytest.raises(InternalServerErrorException, match='Connection has already been established'):
+        async with database.create_context_connection():
+            async with database.create_context_connection():
+                pass
+
+    await database.disconnect()

kiba_core-0.5.3.dev56/tests/test_exceptions.py

@@ -0,0 +1,71 @@
+import datetime
+import email.utils
+
+from core.exceptions import HTTP_EXCEPTIONS_MAP
+from core.exceptions import BadRequestException
+from core.exceptions import RedirectException
+from core.exceptions import TooManyRequestsException
+
+
+class TestExceptionHeaderHooks:
+
+    def test_default_from_headers_ignores_headers(self):
+        exception = BadRequestException.from_headers(message='bad request', statusCode=400, headers={'Retry-After': '99'})
+        assert exception.message == 'bad request'
+
+    def test_default_outgoing_headers_is_empty(self):
+        exception = BadRequestException(message='bad request')
+        assert exception.outgoing_headers() == {}
+
+
+class TestTooManyRequestsException:
+
+    def test_from_headers_parses_delta_seconds(self):
+        exception = TooManyRequestsException.from_headers(message='slow down', statusCode=429, headers={'Retry-After': '42'})
+        assert exception.retryAfterSeconds == 42
+
+    def test_from_headers_parses_http_date(self):
+        futureDate = email.utils.format_datetime(datetime.datetime.now(datetime.UTC) + datetime.timedelta(seconds=30))
+        exception = TooManyRequestsException.from_headers(message='slow down', statusCode=429, headers={'Retry-After': futureDate})
+        assert exception.retryAfterSeconds is not None
+        assert 25 <= exception.retryAfterSeconds <= 30
+
+    def test_from_headers_missing_header_is_none(self):
+        exception = TooManyRequestsException.from_headers(message='slow down', statusCode=429, headers={})
+        assert exception.retryAfterSeconds is None
+
+    def test_from_headers_invalid_header_is_none(self):
+        exception = TooManyRequestsException.from_headers(message='slow down', statusCode=429, headers={'Retry-After': 'not-a-value'})
+        assert exception.retryAfterSeconds is None
+
+    def test_from_headers_past_http_date_clamps_to_zero(self):
+        pastDate = email.utils.format_datetime(datetime.datetime.now(datetime.UTC) - datetime.timedelta(seconds=30))
+        exception = TooManyRequestsException.from_headers(message='slow down', statusCode=429, headers={'Retry-After': pastDate})
+        assert exception.retryAfterSeconds == 0
+
+    def test_outgoing_headers_includes_retry_after_when_set(self):
+        exception = TooManyRequestsException(message='slow down', retryAfterSeconds=42)
+        assert exception.outgoing_headers() == {'Retry-After': '42'}
+
+    def test_outgoing_headers_empty_when_not_set(self):
+        exception = TooManyRequestsException(message='slow down')
+        assert exception.outgoing_headers() == {}
+
+    def test_dispatched_via_http_exceptions_map(self):
+        exceptionCls = HTTP_EXCEPTIONS_MAP[429]
+        exception = exceptionCls.from_headers(message='slow down', statusCode=429, headers={'Retry-After': '7'})
+        assert isinstance(exception, TooManyRequestsException)
+        assert exception.retryAfterSeconds == 7
+
+
+class TestRedirectException:
+
+    def test_outgoing_headers_without_cache_header(self):
+        exception = RedirectException(location='https://example.com', statusCode=302, shouldAddCacheHeader=False)
+        assert exception.outgoing_headers() == {'Location': 'https://example.com'}
+
+    def test_outgoing_headers_with_cache_header(self):
+        exception = RedirectException(location='https://example.com', statusCode=301, shouldAddCacheHeader=True)
+        headers = exception.outgoing_headers()
+        assert headers['Location'] == 'https://example.com'
+        assert headers['Cache-Control'] == f'max-age={60 * 60 * 24 * 365}'

kiba_core-0.5.3.dev55/core/util/typing_util.py

@@ -1,7 +0,0 @@
-from collections.abc import Mapping
-from collections.abc import Sequence
-
-JsonBaseType = str | int | float | bool | None
-type Json = dict[str, 'Json'] | Mapping[str, 'Json'] | list['Json'] | Sequence['Json'] | JsonBaseType
-type JsonObject = dict[str, 'Json']
-type JsonList = list['Json']