sqlalchemy-events-lib 0.3.0__tar.gz → 0.3.2__tar.gz

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-events-lib
-Version: 0.3.0
+Version: 0.3.2
 Summary: Event-driven extension for SQLAlchemy that enables listening to database CUD events. This library allows you to react to database changes in real time using a clean, declarative API.
 Author-email: Alexey Kostarev <normjkeeewm@gmail.com>
 License: MIT
@@ -96,7 +96,6 @@ ___
 session.py
 ```python
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-
 from config import DATABASE_URL
 
 engine = create_async_engine(DATABASE_URL)
@@ -114,10 +113,11 @@ from session import engine
 
 
 async def main():
-    SQLAlchemyEvents(
+    sa_events = SQLAlchemyEvents(
         engine=engine,
         autodiscover_paths=['services']
     )
+    await sa_events()
     while True:
         await asyncio.sleep(9999)
 
@@ -165,16 +165,25 @@ If provided, the library will log internal lifecycle events such as:
 **Example:**
 ```python
 import logging
+import asyncio
+from sqlalchemy_events import SQLAlchemyEvents
+from session import engine
 
 logger = logging.getLogger('sqlalchemy_events')
 logger.setLevel(logging.INFO)
 
-SQLAlchemyEvents(
-    base=Base,
-    engine=engine,
-    autodiscover_paths=['services'],
-    logger=logger
-)
+async def main():
+    sa_events = SQLAlchemyEvents(
+        engine=engine,
+        autodiscover_paths=['services'],
+        logger=logger
+    )
+    await sa_events()
+    while True:
+        await asyncio.sleep(9999)
+
+if __name__ == '__main__':
+    asyncio.run(main())
 ```
 
 ## How it works

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/README.md

@@ -74,7 +74,6 @@ ___
 session.py
 ```python
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-
 from config import DATABASE_URL
 
 engine = create_async_engine(DATABASE_URL)
@@ -92,10 +91,11 @@ from session import engine
 
 
 async def main():
-    SQLAlchemyEvents(
+    sa_events = SQLAlchemyEvents(
         engine=engine,
         autodiscover_paths=['services']
     )
+    await sa_events()
     while True:
         await asyncio.sleep(9999)
 
@@ -143,16 +143,25 @@ If provided, the library will log internal lifecycle events such as:
 **Example:**
 ```python
 import logging
+import asyncio
+from sqlalchemy_events import SQLAlchemyEvents
+from session import engine
 
 logger = logging.getLogger('sqlalchemy_events')
 logger.setLevel(logging.INFO)
 
-SQLAlchemyEvents(
-    base=Base,
-    engine=engine,
-    autodiscover_paths=['services'],
-    logger=logger
-)
+async def main():
+    sa_events = SQLAlchemyEvents(
+        engine=engine,
+        autodiscover_paths=['services'],
+        logger=logger
+    )
+    await sa_events()
+    while True:
+        await asyncio.sleep(9999)
+
+if __name__ == '__main__':
+    asyncio.run(main())
 ```
 
 ## How it works

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/pyproject.toml

@@ -10,7 +10,7 @@ where = ["src"]
 
 [project]
 name = "sqlalchemy-events-lib"
-version = "0.3.0"
+version = "0.3.2"
 description = "Event-driven extension for SQLAlchemy that enables listening to database CUD events. This library allows you to react to database changes in real time using a clean, declarative API."
 requires-python = ">=3.12"
 authors = [

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/sqlalchemy_events/__init__.py

@@ -11,4 +11,4 @@ __all__ = [
     'with_events',
     'SaEvent'
 ]
-__version__ = '0.3.0'
+__version__ = '0.3.2'

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/sqlalchemy_events/callbacks_strategies/postgres_callback.py

@@ -66,4 +66,4 @@ class PostgresCallback(SaEventsCallbacksStrategy):
                     )
                 )
 
-        await asyncio.gather(*tasks)
+        return await asyncio.gather(*tasks)

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/sqlalchemy_events/core.py

@@ -30,9 +30,8 @@ class SQLAlchemyEvents:
         self.autodiscover_paths = autodiscover_paths
         self.logger = logger or DefaultLogger() if verbose else None
         self.verbose = verbose
-        asyncio.create_task(self.__init())
 
-    async def __init(self) -> None:
+    async def __call__(self) -> None:
         if not isinstance(self.engine, (AsyncEngine, Engine)):
             raise RuntimeError(
                 '[SQLAlchemyEvents] \'engine\' must be an instance of '

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/sqlalchemy_events/decorators.py

@@ -1,12 +1,19 @@
+from sqlalchemy.orm import DeclarativeBase
+
 from .types import SaEvent
 
 
 def with_events(events: list[SaEvent]):
+    if not isinstance(events, list) or not events:
+        raise RuntimeError('Events must be a list with at least one SeEvent element')
+
     for e in events:
         if not isinstance(e, SaEvent):
             raise RuntimeError(f'Event must be a SaEvent instance, not {type(e)}')
 
     def wrapper(cls):
+        if not issubclass(cls, DeclarativeBase):
+            raise RuntimeError('Model must inherit from DeclarativeBase')
         cls.__events__ = set(events)
 
         class Events:

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/sqlalchemy_events/default_logger.py

@@ -3,7 +3,7 @@ import logging
 
 class DefaultLogger:
     def __init__(self) -> None:
-        self.__logger = logging.getLogger()
+        self.__logger = logging.getLogger('SQLAlchemyEvents')
         self.__logger.setLevel(logging.INFO)
 
         if not self.__logger.handlers:

sqlalchemy_events_lib-0.3.2/src/sqlalchemy_events/discovery.py

@@ -0,0 +1,44 @@
+import importlib
+import pkgutil
+from pathlib import Path
+from types import ModuleType
+from typing import Iterable, List
+
+
+def autodiscover(paths: Iterable[str | Path]) -> List[ModuleType]:
+    modules: List[ModuleType] = []
+    seen: set[str] = set()
+
+    def add_module(module: ModuleType):
+        if module.__name__ in seen:
+            return
+        seen.add(module.__name__)
+        modules.append(module)
+
+    for path in paths:
+        is_file = False
+
+        if isinstance(path, Path):
+            is_file = path.suffix == '.py'
+            path = str(path)
+
+        if isinstance(path, str) and path.endswith('.py'):
+            is_file = True
+            path = path[:-3]
+
+        path = path.replace('\\', '.').replace('/', '.').lstrip('.')
+
+        module = importlib.import_module(path)
+        add_module(module)
+
+        if is_file or not hasattr(module, '__path__'):
+            continue
+
+        for _, module_name, _ in pkgutil.walk_packages(
+            module.__path__,
+            module.__name__ + '.',
+        ):
+            submodule = importlib.import_module(module_name)
+            add_module(submodule)
+
+    return modules

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/sqlalchemy_events/handlers.py

@@ -1,5 +1,3 @@
-import inspect
-from pathlib import Path
 from typing import Callable, Type
 
 from sqlalchemy.orm import DeclarativeBase
@@ -10,24 +8,23 @@ from .types import Handler
 
 
 def __inner(func: Callable, sa_event: SaEvent, model: Type[DeclarativeBase]):
-    if not isinstance(model, type) or not issubclass(model, DeclarativeBase):
+    if not issubclass(model, DeclarativeBase):
         raise RuntimeError('Model must inherit from DeclarativeBase')
 
+    if '.' in func.__qualname__ and not isinstance(func, staticmethod):
+        raise RuntimeError(f'Handler must be a regular function or staticmethod, not method or classmethod of '
+                           f'{func.__qualname__.split('.')[0]}')
+
+    if isinstance(func, staticmethod):
+        func = func.__func__
+
     event_handlers = get_event_handlers()
     trig_name = f'sa_{model.__tablename__}_{sa_event.lower()}_notify'
-    func_path = inspect.getsourcefile(func) or inspect.getfile(func)
-    func_path = Path(func_path)
-    func_path_name = f'{func_path.parent.name}/{func_path.name}/{func.__name__}'
     handlers: list[Handler] | None = event_handlers.get(trig_name)
+
     obj_handler = Handler(func=func, args={'model': model})
-    if handlers:
-        for handler in handlers:
-            handler_path = inspect.getsourcefile(handler.func) or inspect.getfile(handler.func)
-            handler_path = Path(handler_path)
-            handler_path_name = f'{handler_path.parent.name}/{handler_path.name}/{handler.func.__name__}'
-            if func_path_name == handler_path_name:
-                continue
-            handlers.append(obj_handler)
+    if handlers and obj_handler not in handlers:
+        handlers.append(obj_handler)
     else:
         event_handlers[trig_name] = [obj_handler]
 

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/sqlalchemy_events/registry.py

@@ -11,5 +11,5 @@ if _GLOBAL_KEY not in sys.modules:
 _registry = sys.modules[_GLOBAL_KEY]
 
 
-def get_event_handlers():
+def get_event_handlers() -> dict:
     return _registry.handlers

sqlalchemy_events_lib-0.3.2/src/sqlalchemy_events/types.py

@@ -0,0 +1,40 @@
+import inspect
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+from typing import Any, Awaitable, Callable, TypeAlias, Union
+
+
+class SaEvent(StrEnum):
+    INSERT = 'INSERT'
+    UPDATE = 'UPDATE'
+    DELETE = 'DELETE'
+
+
+class Dialect(StrEnum):
+    POSTGRESQL = 'postgresql'
+    SQLITE = 'sqlite'
+    MYSQL = 'mysql'
+    MSSQL = 'mssql'
+    ORACLE = 'oracle'
+
+
+@dataclass
+class Handler:
+    func: Union[Callable, Awaitable]
+    args: dict[str, Any]
+    full_path: str | None = None
+
+    def __post_init__(self):
+        func_path = inspect.getsourcefile(self.func) or inspect.getfile(self.func)
+        func_path = Path(func_path)
+        self.full_path = f'{func_path.parent.name}/{func_path.name}/{self.func.__name__}'
+
+    def __hash__(self):
+        return hash(self.full_path)
+
+    def __eq__(self, other):
+        return self.full_path == other.full_path
+
+
+DB_ID: TypeAlias = str | int

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/sqlalchemy_events_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-events-lib
-Version: 0.3.0
+Version: 0.3.2
 Summary: Event-driven extension for SQLAlchemy that enables listening to database CUD events. This library allows you to react to database changes in real time using a clean, declarative API.
 Author-email: Alexey Kostarev <normjkeeewm@gmail.com>
 License: MIT
@@ -96,7 +96,6 @@ ___
 session.py
 ```python
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-
 from config import DATABASE_URL
 
 engine = create_async_engine(DATABASE_URL)
@@ -114,10 +113,11 @@ from session import engine
 
 
 async def main():
-    SQLAlchemyEvents(
+    sa_events = SQLAlchemyEvents(
         engine=engine,
         autodiscover_paths=['services']
     )
+    await sa_events()
     while True:
         await asyncio.sleep(9999)
 
@@ -165,16 +165,25 @@ If provided, the library will log internal lifecycle events such as:
 **Example:**
 ```python
 import logging
+import asyncio
+from sqlalchemy_events import SQLAlchemyEvents
+from session import engine
 
 logger = logging.getLogger('sqlalchemy_events')
 logger.setLevel(logging.INFO)
 
-SQLAlchemyEvents(
-    base=Base,
-    engine=engine,
-    autodiscover_paths=['services'],
-    logger=logger
-)
+async def main():
+    sa_events = SQLAlchemyEvents(
+        engine=engine,
+        autodiscover_paths=['services'],
+        logger=logger
+    )
+    await sa_events()
+    while True:
+        await asyncio.sleep(9999)
+
+if __name__ == '__main__':
+    asyncio.run(main())
 ```
 
 ## How it works

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/sqlalchemy_events_lib.egg-info/SOURCES.txt

@@ -25,5 +25,8 @@ src/sqlalchemy_events_lib.egg-info/requires.txt
 src/sqlalchemy_events_lib.egg-info/top_level.txt
 src/tests/conftest.py
 src/tests/test_autodiscover.py
+src/tests/test_handlers.py
 src/tests/test_is_created_triggers.py
-src/tests/test_models.py
+src/tests/test_models.py
+src/tests/test_sa_events.py
+src/tests/test_with_events_deco.py

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/tests/conftest.py

@@ -1,4 +1,3 @@
-import asyncio
 import os
 
 import pytest_asyncio
@@ -7,6 +6,8 @@ from dotenv import load_dotenv
 from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
 from sqlalchemy import text
 from sqlalchemy_events import SQLAlchemyEvents
+from sqlalchemy_events.events import sa_events_strategy
+from sqlalchemy_events.utils import dialect_resolver
 
 from tests.test_models import Base
 
@@ -32,11 +33,10 @@ async def prepared_db(engine):
             await conn.execute(text('CREATE SCHEMA public'))
             await conn.run_sync(Base.metadata.create_all)
 
-        SQLAlchemyEvents(
+        await SQLAlchemyEvents(
             engine=engine,
             autodiscover_paths=['tests']
-        )
-        await asyncio.sleep(0.1)
+        )()
         IS_DB = True
 
 
@@ -46,4 +46,10 @@ async def session(engine):
 
     async with async_session() as session:
         yield session
-        await session.rollback()
+        await session.rollback()
+
+
+@pytest_asyncio.fixture
+async def mock_callback(engine):
+    dialect = dialect_resolver(engine)
+    yield sa_events_strategy[dialect].callback

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.2}/src/tests/test_autodiscover.py

@@ -1,6 +1,8 @@
 import sys
 import types
 
+import pytest
+
 from sqlalchemy_events.discovery import autodiscover
 from sqlalchemy_events import sa_insert_handler, sa_update_handler, sa_delete_handler
 from sqlalchemy_events.registry import get_event_handlers
@@ -115,15 +117,31 @@ async def test_discover_handlers():
     assert handlers
     result_handlers = []
     for key, handler_list in handlers.items():
-        assert len(handler_list) == 1
         if 'insert' in key:
             assert handler_list[0].func.__name__ == 'insert_handler'
-            result_handlers.extend(handler_list)
+            result_handlers.append(handler_list[0])
         if 'update' in key:
             assert handler_list[0].func.__name__ == 'update_handler'
-            result_handlers.extend(handler_list)
+            result_handlers.append(handler_list[0])
         if 'delete' in key:
             assert handler_list[0].func.__name__ == 'delete_handler'
-            result_handlers.extend(handler_list)
+            result_handlers.append(handler_list[0])
+
+    assert len(result_handlers) == 3
+
+
+def test_invalid_autodiscover_path():
+    with pytest.raises(ModuleNotFoundError):
+        autodiscover(['not.existing.module'])
+
+
+def test_autodiscover_no_duplicates():
+    modules = autodiscover(['tests', 'tests.test_autodiscover.py'])
+
+    names = [m.__name__ for m in modules]
+    assert len(names) == len(set(names))
+
 
-    assert len(result_handlers) == len(handlers)
+def test_autodiscover_import_error_is_handled():
+    with pytest.raises(Exception):
+        autodiscover(['app.broken_module'])

sqlalchemy_events_lib-0.3.2/src/tests/test_handlers.py

@@ -0,0 +1,79 @@
+import json
+import pytest
+
+from sqlalchemy_events import sa_delete_handler, sa_insert_handler, sa_update_handler
+from tests.test_models import UserModel
+
+
+def test_invalid_model_in_handler():
+    with pytest.raises(RuntimeError):
+        @sa_insert_handler(object)
+        def test_func():
+            pass
+
+
+def test_handler_signature():
+    with pytest.raises(TypeError):
+        @sa_insert_handler()
+        def test_func():
+            pass
+
+
+class Test:
+    def test_method(self):
+        pass
+
+    @classmethod
+    def test_class_method(cls):
+        pass
+
+    @staticmethod
+    def test_static_method():
+        pass
+
+
+def test_handler_in_class():
+    with pytest.raises(RuntimeError):
+        sa_insert_handler(UserModel)(Test().test_method)
+
+    with pytest.raises(RuntimeError):
+        sa_update_handler(UserModel)(Test.test_class_method)
+
+
+@sa_insert_handler(UserModel)
+async def insert_user_handler(rows):
+    assert rows == [1, 2, 3]
+    return rows
+
+
+@sa_update_handler(UserModel)
+async def update_user_handler(rows):
+    assert rows == [4, 5, 6]
+    return rows
+
+
+@sa_delete_handler(UserModel)
+async def delete_user_handler(rows):
+    assert rows == [7, 8, 9]
+    return rows
+
+
+@pytest.mark.parametrize(
+    'op,rows,resp',
+    [
+        ('insert', [1, 2, 3], [None, [1, 2, 3]]),
+        ('update', [4, 5, 6], [None, [4, 5, 6]]),
+        ('delete', [7, 8, 9], [None, [7, 8, 9]]),
+    ]
+)
+async def test_handlers(mock_callback, op, rows, resp):
+    response = await mock_callback.handle(
+        None, None, None, json.dumps(
+            {
+                'op': op,
+                'table': 'users',
+                'rows': rows
+            }
+        )
+    )
+    assert response == resp

sqlalchemy_events_lib-0.3.2/src/tests/test_sa_events.py

@@ -0,0 +1,27 @@
+import logging
+
+import pytest
+
+from sqlalchemy_events import SQLAlchemyEvents
+
+
+async def test_invalid_engine_type():
+    with pytest.raises(RuntimeError):
+        await SQLAlchemyEvents(engine='not_engine', autodiscover_paths=[])()
+
+
+async def test_empty_autodiscover_paths_logs_warning(caplog, engine):
+    caplog.set_level('WARNING', logger='SQLAlchemyEvents')
+    await SQLAlchemyEvents(engine=engine, autodiscover_paths=[], verbose=True)()
+    assert 'No autodiscover paths' in caplog.text
+
+
+async def test_no_logs_when_verbose_disabled(caplog, engine):
+    await SQLAlchemyEvents(engine=engine, autodiscover_paths=[], verbose=False)()
+    assert caplog.text == ''
+
+
+async def test_custom_logger_used(caplog, engine):
+    logger = logging.getLogger('test')
+    await SQLAlchemyEvents(engine=engine, autodiscover_paths=[], logger=logger)()
+    assert 'SQLAlchemyEvents' in caplog.text

sqlalchemy_events_lib-0.3.2/src/tests/test_with_events_deco.py

@@ -0,0 +1,45 @@
+import pytest
+from sqlalchemy import Column, Integer, String
+
+from sqlalchemy_events import SaEvent, with_events
+from tests.test_models import Base, UserModel
+
+
+def test_with_events_on_incorrect_class_type():
+    with pytest.raises(RuntimeError):
+        @with_events([SaEvent.INSERT])
+        class Test: ...
+
+
+def test_incorrect_event_type():
+    with pytest.raises(RuntimeError):
+        @with_events(['incorrect_event_type'])
+        class UserModel(Base):
+            __tablename__ = 'test_model'
+
+            id = Column(Integer, primary_key=True)
+            name = Column(String)
+
+
+def test_empty_events():
+    with pytest.raises(TypeError):
+        @with_events()
+        class UserModel(Base):
+            __tablename__ = 'test_model'
+
+            id = Column(Integer, primary_key=True)
+            name = Column(String)
+
+    with pytest.raises(RuntimeError):
+        @with_events([])
+        class UserModel(Base):
+            __tablename__ = 'test_model'
+
+            id = Column(Integer, primary_key=True)
+            name = Column(String)
+
+
+def test_events_in_model():
+    assert UserModel.events.INSERT
+    assert UserModel.events.UPDATE
+    assert UserModel.events.DELETE

sqlalchemy_events_lib-0.3.0/src/sqlalchemy_events/discovery.py

@@ -1,30 +0,0 @@
-import importlib
-import pkgutil
-from pathlib import Path
-from types import ModuleType
-from typing import Iterable, List
-
-
-def autodiscover(paths: Iterable[str]) -> List[ModuleType]:
-    modules: List[ModuleType] = []
-
-    for path in paths:
-        if isinstance(path, Path):
-            path = str(path)
-            path = path.replace('\\', '.')
-
-        path = path.strip('/').replace('/', '.').lstrip('.')
-        module = importlib.import_module(path)
-        modules.append(module)
-
-        if not hasattr(module, '__path__'):
-            continue
-
-        for _, module_name, _ in pkgutil.walk_packages(
-            module.__path__,
-            module.__name__ + '.',
-        ):
-            submodule = importlib.import_module(module_name)
-            modules.append(submodule)
-
-    return modules

sqlalchemy_events_lib-0.3.0/src/sqlalchemy_events/types.py

@@ -1,26 +0,0 @@
-from dataclasses import dataclass
-from enum import StrEnum
-from typing import Any, Awaitable, Callable, TypeAlias, Union
-
-
-class SaEvent(StrEnum):
-    INSERT = 'INSERT'
-    UPDATE = 'UPDATE'
-    DELETE = 'DELETE'
-
-
-class Dialect(StrEnum):
-    POSTGRESQL = 'postgresql'
-    SQLITE = 'sqlite'
-    MYSQL = 'mysql'
-    MSSQL = 'mssql'
-    ORACLE = 'oracle'
-
-
-@dataclass
-class Handler:
-    func: Union[Callable, Awaitable]
-    args: dict[str, Any]
-
-
-DB_ID: TypeAlias = str | int