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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-events-lib
-Version: 0.3.0
+Version: 0.3.1
 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.1}/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.1}/pyproject.toml

@@ -10,7 +10,7 @@ where = ["src"]
 
 [project]
 name = "sqlalchemy-events-lib"
-version = "0.3.0"
+version = "0.3.1"
 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.1}/src/sqlalchemy_events/__init__.py

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

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.1}/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.1}/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.1}/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.1/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.1}/src/sqlalchemy_events/handlers.py

@@ -10,7 +10,7 @@ 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')
 
     event_handlers = get_event_handlers()

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.1}/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.1
 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.1}/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.1}/src/tests/conftest.py

@@ -32,11 +32,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
 
 

{sqlalchemy_events_lib-0.3.0 → sqlalchemy_events_lib-0.3.1}/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
@@ -127,3 +129,20 @@ async def test_discover_handlers():
             result_handlers.extend(handler_list)
 
     assert len(result_handlers) == len(handlers)
+
+
+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))
+
+
+def test_autodiscover_import_error_is_handled():
+    with pytest.raises(Exception):
+        autodiscover(['app.broken_module'])

sqlalchemy_events_lib-0.3.1/src/tests/test_handlers.py

@@ -0,0 +1,17 @@
+import pytest
+
+from sqlalchemy_events import sa_insert_handler
+
+
+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

sqlalchemy_events_lib-0.3.1/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.1/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