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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-events-lib
-Version: 0.1.1
+Version: 0.2.0
 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
@@ -61,16 +61,35 @@ class UserModel(Base):
 ___
 
 
-### Define event handlers using decorator `@sa_event_handler`  
+### Define event handlers using decorators `@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler`
 services/handlers.py
 ```python
 from models import UserModel
-from sqlalchemy_events import sa_event_handler
+from sqlalchemy_events import sa_insert_handler
 
-@sa_event_handler.on_insert(UserModel)
+@sa_insert_handler(UserModel)
 async def handle_user_insert():
-    print("User inserted!")
+    print('User inserted!')
 ```
+
+**Optional Argument**: `rows`
+Handlers can optionally accept a rows argument.
+
+If the parameter is declared in the function signature, it will automatically receive a list of affected `row` IDs.
+
+```python
+from models import UserModel
+from sqlalchemy_events import sa_insert_handler
+
+@sa_insert_handler(UserModel)
+async def handle_user_insert(rows: list[DB_ID]):
+    print('Users inserted!', rows)
+```
+**Output:**
+```
+Users inserted! ['3310aa38-f555-4c05-a57f-5acae32a0a7b', '6aeba1b0-8e80-4369-8adf-cf967ab7ba7a']
+```
+
 ___
  
 ### Configure SQLAlchemy async engine  
@@ -96,17 +115,13 @@ from session import engine
 
 
 async def main():
-    asyncio.create_task(
-        SQLAlchemyEvents(
-            base=Base,
-            engine=engine,
-            autodiscover_paths=['services']
-        ).init()
+    SQLAlchemyEvents(
+        base=Base,
+        engine=engine,
+        autodiscover_paths=['services']
     )
-    try:
+    while True:
         await asyncio.sleep(9999)
-    except:
-        pass
 
 if __name__ == '__main__':
     asyncio.run(main())
@@ -129,7 +144,10 @@ 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_event_handler` are executed. Example:`autodiscover_paths=["services", "app.handlers"]`
+These modules are automatically imported so that decorators such as 
+`@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler` are executed. 
+**Example:**  
+`autodiscover_paths=["services", "app.handlers"]`
 
 ### Important:
 
@@ -149,13 +167,13 @@ If provided, the library will log internal lifecycle events such as:
 ```python
 import logging
 
-logger = logging.getLogger("sqlalchemy_events")
+logger = logging.getLogger('sqlalchemy_events')
 logger.setLevel(logging.INFO)
 
 SQLAlchemyEvents(
     base=Base,
     engine=engine,
-    autodiscover_paths=["services"],
+    autodiscover_paths=['services'],
     logger=logger
 )
 ```
@@ -173,7 +191,7 @@ SQLAlchemyEvents(
 * Ensure handlers are imported via autodiscover_paths, otherwise they will not be registered
 
 ## Example flow
-INSERT INTO {table} → DATABASE trigger fires →
+INSERT INTO/UPDATE/DELETE FROM {table} → DATABASE trigger fires →
 NOTIFY → Python listener receives event →
 handler is executed
 

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/README.md

@@ -39,16 +39,35 @@ class UserModel(Base):
 ___
 
 
-### Define event handlers using decorator `@sa_event_handler`  
+### Define event handlers using decorators `@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler`
 services/handlers.py
 ```python
 from models import UserModel
-from sqlalchemy_events import sa_event_handler
+from sqlalchemy_events import sa_insert_handler
 
-@sa_event_handler.on_insert(UserModel)
+@sa_insert_handler(UserModel)
 async def handle_user_insert():
-    print("User inserted!")
+    print('User inserted!')
 ```
+
+**Optional Argument**: `rows`
+Handlers can optionally accept a rows argument.
+
+If the parameter is declared in the function signature, it will automatically receive a list of affected `row` IDs.
+
+```python
+from models import UserModel
+from sqlalchemy_events import sa_insert_handler
+
+@sa_insert_handler(UserModel)
+async def handle_user_insert(rows: list[DB_ID]):
+    print('Users inserted!', rows)
+```
+**Output:**
+```
+Users inserted! ['3310aa38-f555-4c05-a57f-5acae32a0a7b', '6aeba1b0-8e80-4369-8adf-cf967ab7ba7a']
+```
+
 ___
  
 ### Configure SQLAlchemy async engine  
@@ -74,17 +93,13 @@ from session import engine
 
 
 async def main():
-    asyncio.create_task(
-        SQLAlchemyEvents(
-            base=Base,
-            engine=engine,
-            autodiscover_paths=['services']
-        ).init()
+    SQLAlchemyEvents(
+        base=Base,
+        engine=engine,
+        autodiscover_paths=['services']
     )
-    try:
+    while True:
         await asyncio.sleep(9999)
-    except:
-        pass
 
 if __name__ == '__main__':
     asyncio.run(main())
@@ -107,7 +122,10 @@ 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_event_handler` are executed. Example:`autodiscover_paths=["services", "app.handlers"]`
+These modules are automatically imported so that decorators such as 
+`@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler` are executed. 
+**Example:**  
+`autodiscover_paths=["services", "app.handlers"]`
 
 ### Important:
 
@@ -127,13 +145,13 @@ If provided, the library will log internal lifecycle events such as:
 ```python
 import logging
 
-logger = logging.getLogger("sqlalchemy_events")
+logger = logging.getLogger('sqlalchemy_events')
 logger.setLevel(logging.INFO)
 
 SQLAlchemyEvents(
     base=Base,
     engine=engine,
-    autodiscover_paths=["services"],
+    autodiscover_paths=['services'],
     logger=logger
 )
 ```
@@ -151,7 +169,7 @@ SQLAlchemyEvents(
 * Ensure handlers are imported via autodiscover_paths, otherwise they will not be registered
 
 ## Example flow
-INSERT INTO {table} → DATABASE trigger fires →
+INSERT INTO/UPDATE/DELETE FROM {table} → DATABASE trigger fires →
 NOTIFY → Python listener receives event →
 handler is executed
 

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/pyproject.toml

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

@@ -0,0 +1,14 @@
+from .core import SQLAlchemyEvents
+from .decorators import with_events
+from .handlers import sa_insert_handler, sa_update_handler, sa_delete_handler
+from .types import SaEvent
+
+__all__ = [
+    'SQLAlchemyEvents',
+    'sa_insert_handler',
+    'sa_update_handler',
+    'sa_delete_handler',
+    'with_events',
+    'SaEvent'
+]
+__version__ = '0.2.0'

sqlalchemy_events_lib-0.2.0/src/sqlalchemy_events/callbacks_strategies/postgres_callback.py

@@ -0,0 +1,69 @@
+import asyncio
+import json
+import inspect
+import signal
+import sys
+
+from .base import SaEventsCallbacksStrategy
+from ..registry import get_event_handlers
+from ..types import Handler
+from ..utils import _process_pool
+
+
+signal.signal(signal.SIGINT, lambda sig, frame: sys.exit(0))
+
+
+class PostgresCallback(SaEventsCallbacksStrategy):
+
+    def __init__(self) -> None:
+        self.__handlers = get_event_handlers()
+
+    async def handle(self, *args, **kwargs):
+        data = json.loads(args[3] or '{}')
+        trigger = data['op']
+        rows = data['rows']
+        trig_name = f'sa_{data['table']}_{trigger}_notify'
+        handlers: list[Handler] = self.__handlers.get(trig_name, [])
+        if not handlers:
+            return
+
+        loop = asyncio.get_running_loop()
+        tasks = []
+
+        for handler in handlers:
+            func = handler.func
+            sig = inspect.signature(func)
+
+            params = list(sig.parameters.values())
+            rows_index = None
+
+            for i, p in enumerate(params):
+                if p.name == 'rows':
+                    rows_index = i
+                    break
+
+            def build_args():
+                args = []
+                kwargs = {}
+
+                if rows_index is not None:
+                    if not any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params):
+                        args.insert(rows_index, rows)
+                    else:
+                        kwargs['rows'] = rows
+                return args, kwargs
+
+            args, kwargs = build_args()
+
+            if asyncio.iscoroutinefunction(func):
+                tasks.append(func(*args, **kwargs))
+            else:
+                tasks.append(
+                    loop.run_in_executor(
+                        _process_pool,
+                        func,
+                        *args,
+                    )
+                )
+
+        await asyncio.gather(*tasks)

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

@@ -27,8 +27,9 @@ class SQLAlchemyEvents:
         self.engine = engine
         self.autodiscover_paths = autodiscover_paths
         self.logger = logger
+        asyncio.create_task(self.__init())
 
-    async def init(self) -> None:
+    async def __init(self) -> None:
         if not await self.__find_handlers():
             return
 
@@ -53,18 +54,18 @@ class SQLAlchemyEvents:
         filtered_handlers = []
         handler_paths = set()
         for handler in res_handlers:
-            file_path = inspect.getsourcefile(handler) or inspect.getfile(handler)
+            file_path = inspect.getsourcefile(handler.func) or inspect.getfile(handler.func)
 
             file_func = Path(file_path)
             file_name = file_func.name
-            handler_path = f'{file_func} {handler.__name__}'
+            handler_path = f'{file_func} {handler.func.__name__}'
             if handler_path in handler_paths:
                 continue
 
             handler_paths.add(handler_path)
             filtered_handlers.append(handler)
             if self.logger:
-                self.logger.info(f'[SQLAlchemyEvents] Registered handler {handler.__name__} '
+                self.logger.info(f'[SQLAlchemyEvents] Registered handler {handler.func.__name__} '
                                  f'from {file_func.parent.name}/{file_name}')
 
         return filtered_handlers

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/src/sqlalchemy_events/decorators.py

@@ -1,4 +1,4 @@
-from .enums import SaEvent
+from .types import SaEvent
 
 
 def with_events(events: list[SaEvent]):
@@ -11,4 +11,4 @@ def with_events(events: list[SaEvent]):
 
         cls.events = Events
         return cls
-    return wrapper
+    return wrapper

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/src/sqlalchemy_events/events.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 
 from .callbacks_strategies.base import SaEventsCallbacksStrategy
 from .callbacks_strategies.postgres_callback import PostgresCallback
-from .enums import Dialect, SaEvent
+from .types import Dialect, SaEvent
 from .init_triggers_strategies.base import InitTriggersStrategy
 from .init_triggers_strategies.postgres_init_triggers import PostgresInitTriggers
 

sqlalchemy_events_lib-0.2.0/src/sqlalchemy_events/handlers.py

@@ -0,0 +1,50 @@
+import inspect
+from pathlib import Path
+from typing import Callable, Type
+
+from sqlalchemy.orm import DeclarativeBase
+
+from .types import SaEvent
+from .registry import get_event_handlers
+from .types import Handler
+
+
+def __inner(func: Callable, sa_event: SaEvent, model: Type[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)
+    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)
+    else:
+        event_handlers[trig_name] = [obj_handler]
+
+
+def sa_insert_handler(model: Type[DeclarativeBase]):
+    def decorator(func: Callable):
+        __inner(func, SaEvent.INSERT, model)
+        return func
+    return decorator
+
+
+def sa_update_handler(model: Type[DeclarativeBase]):
+    def decorator(func: Callable):
+        __inner(func, SaEvent.UPDATE, model)
+        return func
+    return decorator
+
+
+def sa_delete_handler(model: Type[DeclarativeBase]):
+    def decorator(func: Callable):
+        __inner(func, SaEvent.DELETE, model)
+        return func
+    return decorator

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/src/sqlalchemy_events/init_triggers_strategies/postgres_init_triggers.py

@@ -3,24 +3,35 @@ from typing import Type
 from sqlalchemy import text
 from sqlalchemy.orm import DeclarativeBase
 
-from ..enums import SaEvent
+from ..types import SaEvent
 from .base import InitTriggersStrategy
 
 
 class PostgresInitTriggers(InitTriggersStrategy):
 
     async def __call__(self, model_list: list[Type[DeclarativeBase]], conn, logger):
-        await conn.execute(
-            text("""
-                 CREATE OR REPLACE FUNCTION sqlalchemy_events() 
-                 RETURNS trigger AS $$ 
-                 BEGIN PERFORM pg_notify(
-                    'sqlalchemy_events', json_build_object(
-                    'table', TG_TABLE_NAME, 'event', TG_OP, 'trigger', TG_NAME
-                 )::text); 
-                 RETURN NEW; END; $$ LANGUAGE plpgsql;
-                 """)
-        )
+        for sa_event in SaEvent:
+            sa_event = sa_event.lower()
+            await conn.execute(
+                text(f"""
+                        CREATE OR REPLACE FUNCTION sqlalchemy_events_notify_{sa_event}()
+                        RETURNS trigger AS $$
+                        DECLARE
+                            payload json;
+                        BEGIN
+                            payload := json_build_object(
+                                'op', '{sa_event}',
+                                'table', TG_TABLE_NAME,
+                                'rows', array_agg(n.id)
+                            )
+                            FROM {'old_rows' if sa_event.upper() == SaEvent.DELETE else 'new_rows'} n;
+                        
+                            PERFORM pg_notify('sqlalchemy_events', payload::text);
+                            RETURN NULL;
+                        END;
+                        $$ LANGUAGE plpgsql;
+                     """)
+            )
 
         for cls in model_list:
             events = getattr(cls, '__events__', None)
@@ -69,14 +80,17 @@ class PostgresInitTriggers(InitTriggersStrategy):
 
                 added_events.append(event)
                 await conn.execute(
-                    text(f"DROP TRIGGER IF EXISTS {trig_name} ON {table_name};")
+                    text(f'DROP TRIGGER IF EXISTS {trig_name} ON {table_name};')
                 )
 
                 await conn.execute(
                     text(f"""
-                         CREATE TRIGGER {trig_name}
-                         AFTER {event} ON {table_name}
-                         FOR EACH ROW EXECUTE FUNCTION sqlalchemy_events();
+                            CREATE TRIGGER {trig_name}
+                            AFTER {event} ON {table_name}
+                            REFERENCING {'OLD' if event == SaEvent.DELETE else 'NEW'} 
+                            TABLE AS {'old_rows' if event == SaEvent.DELETE else 'new_rows'}
+                            FOR EACH STATEMENT
+                            EXECUTE FUNCTION sqlalchemy_events_notify_{l_event}();
                          """)
                 )
 

sqlalchemy_events_lib-0.2.0/src/sqlalchemy_events/types.py

@@ -0,0 +1,26 @@
+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

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/src/sqlalchemy_events/utils.py

@@ -1,8 +1,12 @@
+import multiprocessing as mp
+import os
+from concurrent.futures import ProcessPoolExecutor
 from typing import Union
+
 from sqlalchemy.engine import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine
 
-from .enums import Dialect
+from .types import Dialect
 
 
 def dialect_resolver(engine: Union[AsyncEngine, Engine]) -> Dialect:
@@ -22,4 +26,10 @@ def dialect_resolver(engine: Union[AsyncEngine, Engine]) -> Dialect:
     elif dialect_name.startswith('oracle'):
         return Dialect.ORACLE
 
-    raise ValueError(f'Unsupported dialect: {dialect_name}')
+    raise ValueError(f'Unsupported dialect: {dialect_name}')
+
+
+_process_pool = ProcessPoolExecutor(
+    max_workers=max(1, os.cpu_count() - 1),
+    mp_context=mp.get_context('spawn'),
+)

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/src/sqlalchemy_events_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-events-lib
-Version: 0.1.1
+Version: 0.2.0
 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
@@ -61,16 +61,35 @@ class UserModel(Base):
 ___
 
 
-### Define event handlers using decorator `@sa_event_handler`  
+### Define event handlers using decorators `@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler`
 services/handlers.py
 ```python
 from models import UserModel
-from sqlalchemy_events import sa_event_handler
+from sqlalchemy_events import sa_insert_handler
 
-@sa_event_handler.on_insert(UserModel)
+@sa_insert_handler(UserModel)
 async def handle_user_insert():
-    print("User inserted!")
+    print('User inserted!')
 ```
+
+**Optional Argument**: `rows`
+Handlers can optionally accept a rows argument.
+
+If the parameter is declared in the function signature, it will automatically receive a list of affected `row` IDs.
+
+```python
+from models import UserModel
+from sqlalchemy_events import sa_insert_handler
+
+@sa_insert_handler(UserModel)
+async def handle_user_insert(rows: list[DB_ID]):
+    print('Users inserted!', rows)
+```
+**Output:**
+```
+Users inserted! ['3310aa38-f555-4c05-a57f-5acae32a0a7b', '6aeba1b0-8e80-4369-8adf-cf967ab7ba7a']
+```
+
 ___
  
 ### Configure SQLAlchemy async engine  
@@ -96,17 +115,13 @@ from session import engine
 
 
 async def main():
-    asyncio.create_task(
-        SQLAlchemyEvents(
-            base=Base,
-            engine=engine,
-            autodiscover_paths=['services']
-        ).init()
+    SQLAlchemyEvents(
+        base=Base,
+        engine=engine,
+        autodiscover_paths=['services']
     )
-    try:
+    while True:
         await asyncio.sleep(9999)
-    except:
-        pass
 
 if __name__ == '__main__':
     asyncio.run(main())
@@ -129,7 +144,10 @@ 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_event_handler` are executed. Example:`autodiscover_paths=["services", "app.handlers"]`
+These modules are automatically imported so that decorators such as 
+`@sa_insert_handler`, `@sa_update_handler`, `@sa_delete_handler` are executed. 
+**Example:**  
+`autodiscover_paths=["services", "app.handlers"]`
 
 ### Important:
 
@@ -149,13 +167,13 @@ If provided, the library will log internal lifecycle events such as:
 ```python
 import logging
 
-logger = logging.getLogger("sqlalchemy_events")
+logger = logging.getLogger('sqlalchemy_events')
 logger.setLevel(logging.INFO)
 
 SQLAlchemyEvents(
     base=Base,
     engine=engine,
-    autodiscover_paths=["services"],
+    autodiscover_paths=['services'],
     logger=logger
 )
 ```
@@ -173,7 +191,7 @@ SQLAlchemyEvents(
 * Ensure handlers are imported via autodiscover_paths, otherwise they will not be registered
 
 ## Example flow
-INSERT INTO {table} → DATABASE trigger fires →
+INSERT INTO/UPDATE/DELETE FROM {table} → DATABASE trigger fires →
 NOTIFY → Python listener receives event →
 handler is executed
 

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/src/sqlalchemy_events_lib.egg-info/SOURCES.txt

@@ -5,11 +5,11 @@ src/sqlalchemy_events/__init__.py
 src/sqlalchemy_events/core.py
 src/sqlalchemy_events/decorators.py
 src/sqlalchemy_events/discovery.py
-src/sqlalchemy_events/enums.py
 src/sqlalchemy_events/events.py
 src/sqlalchemy_events/exceptions.py
-src/sqlalchemy_events/handler.py
+src/sqlalchemy_events/handlers.py
 src/sqlalchemy_events/registry.py
+src/sqlalchemy_events/types.py
 src/sqlalchemy_events/utils.py
 src/sqlalchemy_events/callbacks_strategies/__init__.py
 src/sqlalchemy_events/callbacks_strategies/base.py

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/src/tests/conftest.py

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

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/src/tests/test_autodiscover.py

@@ -2,7 +2,7 @@ import sys
 import types
 
 from sqlalchemy_events.discovery import autodiscover
-from sqlalchemy_events import sa_event_handler
+from sqlalchemy_events import sa_insert_handler, sa_update_handler, sa_delete_handler
 from sqlalchemy_events.registry import get_event_handlers
 from tests.test_models import UserModel
 
@@ -98,15 +98,15 @@ def test_module_without_submodules(monkeypatch):
     cleanup_modules(module_name)
 
 
-@sa_event_handler.on_insert(UserModel)
+@sa_insert_handler(UserModel)
 async def insert_handler(): ...
 
 
-@sa_event_handler.on_update(UserModel)
+@sa_update_handler(UserModel)
 async def update_handler(): ...
 
 
-@sa_event_handler.on_delete(UserModel)
+@sa_delete_handler(UserModel)
 async def delete_handler(): ...
 
 
@@ -117,13 +117,13 @@ async def test_discover_handlers():
     for key, handler_list in handlers.items():
         assert len(handler_list) == 1
         if 'insert' in key:
-            assert handler_list[0].__name__ == 'insert_handler'
+            assert handler_list[0].func.__name__ == 'insert_handler'
             result_handlers.extend(handler_list)
         if 'update' in key:
-            assert handler_list[0].__name__ == 'update_handler'
+            assert handler_list[0].func.__name__ == 'update_handler'
             result_handlers.extend(handler_list)
         if 'delete' in key:
-            assert handler_list[0].__name__ == 'delete_handler'
+            assert handler_list[0].func.__name__ == 'delete_handler'
             result_handlers.extend(handler_list)
 
     assert len(result_handlers) == len(handlers)

{sqlalchemy_events_lib-0.1.1 → sqlalchemy_events_lib-0.2.0}/src/tests/test_is_created_triggers.py

@@ -26,13 +26,17 @@ async def test_is_created_triggers(session):
 
 
 async def test_is_created_function(session):
+    func_names = [
+        'sqlalchemy_events_notify_insert',
+        'sqlalchemy_events_notify_update',
+        'sqlalchemy_events_notify_delete'
+    ]
     result = await session.execute(
         text("""
-             SELECT EXISTS (SELECT 1
-                            FROM pg_proc
-                            WHERE proname = 'sqlalchemy_events')
-             """)
+             SELECT COUNT(*) FROM pg_proc WHERE proname = ANY (:func_names)
+             """),
+        {'func_names': func_names}
     )
-    exists = result.scalar()
+    count = result.scalar()
 
-    assert exists is True
+    assert count == len(func_names)

sqlalchemy_events_lib-0.1.1/src/sqlalchemy_events/__init__.py

@@ -1,8 +0,0 @@
-from .core import SQLAlchemyEvents
-from .decorators import with_events
-from .enums import SaEvent
-from .handler import sa_event_handler
-
-__all__ = ['SQLAlchemyEvents', 'sa_event_handler', 'with_events', 'SaEvent']
-__version__ = '0.1.0'
-

sqlalchemy_events_lib-0.1.1/src/sqlalchemy_events/callbacks_strategies/postgres_callback.py

@@ -1,28 +0,0 @@
-import asyncio
-import json
-
-from .base import SaEventsCallbacksStrategy
-from ..registry import get_event_handlers
-
-
-class PostgresCallback(SaEventsCallbacksStrategy):
-
-    def __init__(self) -> None:
-        self.__handlers = get_event_handlers()
-
-    async def handle(self, *args, **kwargs):
-        data = json.loads(args[3] or '{}')
-        trig_name = data.get('trigger')
-
-        if not trig_name:
-            return
-
-        handlers = self.__handlers.get(trig_name, [])
-        if not handlers:
-            return
-
-        for handler in handlers:
-            if asyncio.iscoroutinefunction(handler):
-                await handler()
-            else:
-                handler()

sqlalchemy_events_lib-0.1.1/src/sqlalchemy_events/enums.py

@@ -1,15 +0,0 @@
-from enum import StrEnum
-
-
-class SaEvent(StrEnum):
-    INSERT = 'INSERT'
-    UPDATE = 'UPDATE'
-    DELETE = 'DELETE'
-
-
-class Dialect(StrEnum):
-    POSTGRESQL = 'postgresql'
-    SQLITE = 'sqlite'
-    MYSQL = 'mysql'
-    MSSQL = 'mssql'
-    ORACLE = 'oracle'

sqlalchemy_events_lib-0.1.1/src/sqlalchemy_events/handler.py

@@ -1,52 +0,0 @@
-import inspect
-from pathlib import Path
-from typing import Callable, Type
-from sqlalchemy.orm import DeclarativeBase
-
-from .enums import SaEvent
-from .registry import get_event_handlers
-
-
-class SaEventHandler:
-
-    def __init__(self):
-        self.__handlers = get_event_handlers()
-
-    def __sa_event_handler(self, model: Type[DeclarativeBase], event: SaEvent):
-        if event not in getattr(model, '__events__', set()):
-            raise ValueError(
-                f'[SQLAlchemyEvents] Event {event} is not registered for model {model.__name__}'
-            )
-
-        def decorator(func: Callable):
-            trig_name = f'sa_{model.__tablename__}_{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__}'
-            funcs = self.__handlers.get(trig_name)
-            if funcs:
-                for handler in funcs:
-                    handler_path = inspect.getsourcefile(handler) or inspect.getfile(handler)
-                    handler_path = Path(handler_path)
-                    handler_path_name = f'{handler_path.parent.name}/{handler_path.name}/{handler.__name__}'
-                    if func_path_name == handler_path_name:
-                        continue
-                    funcs[trig_name].append(handler)
-            else:
-                self.__handlers[trig_name] = [func]
-
-            return func
-
-        return decorator
-
-    def on_insert(self, model: Type[DeclarativeBase]):
-        return self.__sa_event_handler(model, SaEvent.INSERT)
-
-    def on_update(self, model: Type[DeclarativeBase]):
-        return self.__sa_event_handler(model, SaEvent.UPDATE)
-
-    def on_delete(self, model: Type[DeclarativeBase]):
-        return self.__sa_event_handler(model, SaEvent.DELETE)
-
-
-sa_event_handler = SaEventHandler()