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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-events-lib
-Version: 0.2.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)
@@ -110,16 +109,15 @@ main.py
 ```python
 import asyncio
 from sqlalchemy_events import SQLAlchemyEvents
-from models import Base
 from session import engine
 
 
 async def main():
-    SQLAlchemyEvents(
-        base=Base,
+    sa_events = SQLAlchemyEvents(
         engine=engine,
         autodiscover_paths=['services']
     )
+    await sa_events()
     while True:
         await asyncio.sleep(9999)
 
@@ -133,22 +131,23 @@ if __name__ == '__main__':
 The SQLAlchemyEvents class accepts the following parameters:
 ```python
 SQLAlchemyEvents(
-    base,
     engine,
     autodiscover_paths,
-    logger=None
+    logger=None,
+    verbose=True
 )
 ```
 
 Parameters:
-* **base** - SQLAlchemy declarative base class used to discover mapped models.
 * **engine** - SQLAlchemy Engine or AsyncEngine instance.
 * **autodiscover_paths** - List of Python module paths where event handlers are defined.
 These modules are automatically imported so that decorators such as 
-`@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler` are executed. 
+`@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler` are executed.  
 **Example:**  
 `autodiscover_paths=["services", "app.handlers"]`
 
+* **verbose** - Enables detailed logging output. When set to True, the library will log additional informational and warning messages to help with debugging and configuration.
+
 ### Important:
 
 All modules containing event handlers must be imported through autodiscover
@@ -166,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.2.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)
@@ -88,16 +87,15 @@ main.py
 ```python
 import asyncio
 from sqlalchemy_events import SQLAlchemyEvents
-from models import Base
 from session import engine
 
 
 async def main():
-    SQLAlchemyEvents(
-        base=Base,
+    sa_events = SQLAlchemyEvents(
         engine=engine,
         autodiscover_paths=['services']
     )
+    await sa_events()
     while True:
         await asyncio.sleep(9999)
 
@@ -111,22 +109,23 @@ if __name__ == '__main__':
 The SQLAlchemyEvents class accepts the following parameters:
 ```python
 SQLAlchemyEvents(
-    base,
     engine,
     autodiscover_paths,
-    logger=None
+    logger=None,
+    verbose=True
 )
 ```
 
 Parameters:
-* **base** - SQLAlchemy declarative base class used to discover mapped models.
 * **engine** - SQLAlchemy Engine or AsyncEngine instance.
 * **autodiscover_paths** - List of Python module paths where event handlers are defined.
 These modules are automatically imported so that decorators such as 
-`@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler` are executed. 
+`@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler` are executed.  
 **Example:**  
 `autodiscover_paths=["services", "app.handlers"]`
 
+* **verbose** - Enables detailed logging output. When set to True, the library will log additional informational and warning messages to help with debugging and configuration.
+
 ### Important:
 
 All modules containing event handlers must be imported through autodiscover
@@ -144,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.2.0 → sqlalchemy_events_lib-0.3.1}/pyproject.toml

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

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

{sqlalchemy_events_lib-0.2.0 → sqlalchemy_events_lib-0.3.1}/src/sqlalchemy_events/core.py

@@ -1,16 +1,19 @@
 import asyncio
 import logging
+from collections import defaultdict
 from pathlib import Path
-from typing import Optional, Type, Union
+from typing import Optional, Union
 import inspect
 
 from sqlalchemy import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine
 from sqlalchemy.orm import DeclarativeBase
 
+from .default_logger import DefaultLogger
 from .discovery import autodiscover
 from .events import SaEventStrategy, sa_events_strategy
 from .registry import get_event_handlers
+from .types import Handler
 from .utils import dialect_resolver
 
 
@@ -18,19 +21,34 @@ class SQLAlchemyEvents:
 
     def __init__(
         self,
-        base: Type[DeclarativeBase],
         engine: Union[AsyncEngine, Engine],
-        autodiscover_paths: list[str],
-        logger: Optional[logging.Logger] = None
+        autodiscover_paths: list[str | Path],
+        logger: Optional[logging.Logger] = None,
+        verbose: bool = True
     ) -> None:
-        self.base = base
         self.engine = engine
         self.autodiscover_paths = autodiscover_paths
-        self.logger = logger
-        asyncio.create_task(self.__init())
+        self.logger = logger or DefaultLogger() if verbose else None
+        self.verbose = verbose
+
+    async def __call__(self) -> None:
+        if not isinstance(self.engine, (AsyncEngine, Engine)):
+            raise RuntimeError(
+                '[SQLAlchemyEvents] \'engine\' must be an instance of '
+                'sqlalchemy.Engine or sqlalchemy.ext.asyncio.AsyncEngine.'
+            )
+
+        if not self.autodiscover_paths:
+            if self.verbose:
+                self.logger.warning(
+                    '[SQLAlchemyEvents] No autodiscover paths specified. '
+                    'Please provide at least one module path (e.g., \'app.handlers\') '
+                    'in \'autodiscover_paths\' during initialization.'
+                )
+            return
 
-    async def __init(self) -> None:
-        if not await self.__find_handlers():
+        handlers = await self.__find_handlers()
+        if not handlers:
             return
 
         dialect = dialect_resolver(self.engine)
@@ -38,13 +56,13 @@ class SQLAlchemyEvents:
         if not event_strategy:
             raise RuntimeError(f'[SQLAlchemyEvents] Unsupported database {dialect}. '
                                f'This library supports only {', '.join(sa_events_strategy.keys())}')
-        await self.__start_listen(event_strategy)
+        await self.__start_listen(event_strategy, handlers)
 
     async def __find_handlers(self):
         autodiscover(self.autodiscover_paths)
         handlers = get_event_handlers()
         if not handlers:
-            if self.logger:
+            if self.verbose:
                 self.logger.info('[SQLAlchemyEvents] No handlers found')
             return
         res_handlers = []
@@ -53,6 +71,7 @@ class SQLAlchemyEvents:
 
         filtered_handlers = []
         handler_paths = set()
+        handlers_qty = defaultdict(int)
         for handler in res_handlers:
             file_path = inspect.getsourcefile(handler.func) or inspect.getfile(handler.func)
 
@@ -64,13 +83,28 @@ class SQLAlchemyEvents:
 
             handler_paths.add(handler_path)
             filtered_handlers.append(handler)
-            if self.logger:
-                self.logger.info(f'[SQLAlchemyEvents] Registered handler {handler.func.__name__} '
-                                 f'from {file_func.parent.name}/{file_name}')
+            handlers_qty[f'{file_func.parent.name}/{file_name}'] += 1
+
+        if self.verbose:
+            for path, qty in handlers_qty.items():
+                self.logger.info(f'[SQLAlchemyEvents] Registered {qty} {'handler' if qty == 1 else 'handlers'} '
+                                 f'from \'{path}\'')
 
         return filtered_handlers
 
-    async def __start_listen(self, event_strategy: SaEventStrategy):
+    async def __start_listen(self, event_strategy: SaEventStrategy, handlers: list[Handler]):
+        base = None
+        try:
+            model = handlers[0].args['model']
+            for cls in model.__mro__:
+                if issubclass(cls, DeclarativeBase) and cls is not DeclarativeBase:
+                    base = cls
+
+            if not base:
+                raise Exception
+        except Exception:
+            raise RuntimeError('[SQLAlchemyEvents] No Base found in Registered handlers')
+
         if isinstance(self.engine, AsyncEngine):
             async with self.engine.connect() as conn:
                 raw_conn = await conn.get_raw_connection()
@@ -80,11 +114,11 @@ class SQLAlchemyEvents:
                     raise RuntimeError('[SQLAlchemyEvents] Driver does not support LISTEN/NOTIFY')
 
                 await event_strategy.init_triggers(
-                    model_list=self.base.__subclasses__(),
+                    model_list=base.__subclasses__(),
                     conn=conn,
                     logger=self.logger
                 )
-            if self.logger:
+            if self.verbose:
                 self.logger.info('[SQLAlchemyEvents] Start listening')
             await driver_conn.add_listener('sqlalchemy_events', event_strategy.callback.handle)
             return
@@ -103,11 +137,11 @@ class SQLAlchemyEvents:
             if not asyncio.iscoroutine(result):
                 raise RuntimeError(sync_engine_error)
             await event_strategy.init_triggers(
-                model_list=self.base.__subclasses__(),
+                model_list=base.__subclasses__(),
                 conn=conn,
                 logger=self.logger
             )
-            if self.logger:
+            if self.verbose:
                 self.logger.info('[SQLAlchemyEvents] Start listening')
             await result
 
@@ -120,6 +154,6 @@ class SQLAlchemyEvents:
             try:
                 await driver_conn.wait_for_notify()
             except Exception as e:
-                if self.logger:
+                if self.verbose:
                     self.logger.error(f'[SQLAlchemyEvents] listener crashed: {e}')
                 await asyncio.sleep(1)

sqlalchemy_events_lib-0.3.1/src/sqlalchemy_events/decorators.py

@@ -0,0 +1,25 @@
+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:
+            for e in events:
+                locals()[e.name] = e.value
+
+        cls.events = Events
+        return cls
+    return wrapper

sqlalchemy_events_lib-0.3.1/src/sqlalchemy_events/default_logger.py

@@ -0,0 +1,25 @@
+import logging
+
+
+class DefaultLogger:
+    def __init__(self) -> None:
+        self.__logger = logging.getLogger('SQLAlchemyEvents')
+        self.__logger.setLevel(logging.INFO)
+
+        if not self.__logger.handlers:
+            formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(formatter)
+            self.__logger.addHandler(console_handler)
+
+    def info(self, message: str) -> None:
+        self.__logger.info(message)
+
+    def error(self, message: str, exc_info: bool = True) -> None:
+        self.__logger.error(message, exc_info=exc_info)
+
+    def warning(self, message: str) -> None:
+        self.__logger.warning(message)
+
+    def debug(self, message: str) -> None:
+        self.__logger.debug(message)

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

@@ -10,6 +10,9 @@ from .types import Handler
 
 
 def __inner(func: Callable, sa_event: SaEvent, model: Type[DeclarativeBase]):
+    if not issubclass(model, DeclarativeBase):
+        raise RuntimeError('Model must inherit from DeclarativeBase')
+
     event_handlers = get_event_handlers()
     trig_name = f'sa_{model.__tablename__}_{sa_event.lower()}_notify'
     func_path = inspect.getsourcefile(func) or inspect.getfile(func)

{sqlalchemy_events_lib-0.2.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.2.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)
@@ -110,16 +109,15 @@ main.py
 ```python
 import asyncio
 from sqlalchemy_events import SQLAlchemyEvents
-from models import Base
 from session import engine
 
 
 async def main():
-    SQLAlchemyEvents(
-        base=Base,
+    sa_events = SQLAlchemyEvents(
         engine=engine,
         autodiscover_paths=['services']
     )
+    await sa_events()
     while True:
         await asyncio.sleep(9999)
 
@@ -133,22 +131,23 @@ if __name__ == '__main__':
 The SQLAlchemyEvents class accepts the following parameters:
 ```python
 SQLAlchemyEvents(
-    base,
     engine,
     autodiscover_paths,
-    logger=None
+    logger=None,
+    verbose=True
 )
 ```
 
 Parameters:
-* **base** - SQLAlchemy declarative base class used to discover mapped models.
 * **engine** - SQLAlchemy Engine or AsyncEngine instance.
 * **autodiscover_paths** - List of Python module paths where event handlers are defined.
 These modules are automatically imported so that decorators such as 
-`@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler` are executed. 
+`@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler` are executed.  
 **Example:**  
 `autodiscover_paths=["services", "app.handlers"]`
 
+* **verbose** - Enables detailed logging output. When set to True, the library will log additional informational and warning messages to help with debugging and configuration.
+
 ### Important:
 
 All modules containing event handlers must be imported through autodiscover
@@ -166,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.2.0 → sqlalchemy_events_lib-0.3.1}/src/sqlalchemy_events_lib.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/sqlalchemy_events/__init__.py
 src/sqlalchemy_events/core.py
 src/sqlalchemy_events/decorators.py
+src/sqlalchemy_events/default_logger.py
 src/sqlalchemy_events/discovery.py
 src/sqlalchemy_events/events.py
 src/sqlalchemy_events/exceptions.py
@@ -24,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.2.0 → sqlalchemy_events_lib-0.3.1}/src/tests/conftest.py

@@ -32,12 +32,10 @@ async def prepared_db(engine):
             await conn.execute(text('CREATE SCHEMA public'))
             await conn.run_sync(Base.metadata.create_all)
 
-        SQLAlchemyEvents(
-            base=Base,
+        await SQLAlchemyEvents(
             engine=engine,
             autodiscover_paths=['tests']
-        )
-        await asyncio.sleep(0.1)
+        )()
         IS_DB = True
 
 

{sqlalchemy_events_lib-0.2.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.2.0/src/sqlalchemy_events/decorators.py

@@ -1,14 +0,0 @@
-from .types import SaEvent
-
-
-def with_events(events: list[SaEvent]):
-    def wrapper(cls):
-        cls.__events__ = set(events)
-
-        class Events:
-            for e in events:
-                locals()[e.name] = e.value
-
-        cls.events = Events
-        return cls
-    return wrapper

sqlalchemy_events_lib-0.2.0/src/sqlalchemy_events/discovery.py

@@ -1,24 +0,0 @@
-import importlib
-import pkgutil
-from types import ModuleType
-from typing import Iterable, List
-
-
-def autodiscover(paths: Iterable[str]) -> List[ModuleType]:
-    modules: List[ModuleType] = []
-
-    for path in paths:
-        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