risclog.sqlalchemy 6.0__tar.gz → 6.2__tar.gz

{risclog.sqlalchemy-6.0 → risclog.sqlalchemy-6.2}/CHANGES.rst

@@ -2,6 +2,21 @@
 Change log for risclog.sqlalchemy
 =================================
 
+6.2 (2024-04-19)
+================
+
+- Add json encoder for `datetime.time` objects.
+
+
+6.1 (2024-03-12)
+================
+
+- Add json encoder for `uuid.UUID` objects.
+
+- Add `risclog.sqlalchemy.interfaces.Deleted` event which is fired when an
+  object is deleted from the database.
+
+
 6.0 (2023-09-26)
 ================
 

{risclog.sqlalchemy-6.0 → risclog.sqlalchemy-6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risclog.sqlalchemy
-Version: 6.0
+Version: 6.2
 Summary: Encapsulate sqlalchemy modelling infrastructure.
 Home-page: https://github.com/gocept/risclog.sqlalchemy
 Author: gocept <mail@gocept.com>
@@ -106,6 +106,21 @@ python, where ``sphinx-pypi-upload`` is installed::
 Change log for risclog.sqlalchemy
 =================================
 
+6.2 (2024-04-19)
+================
+
+- Add json encoder for `datetime.time` objects.
+
+
+6.1 (2024-03-12)
+================
+
+- Add json encoder for `uuid.UUID` objects.
+
+- Add `risclog.sqlalchemy.interfaces.Deleted` event which is fired when an
+  object is deleted from the database.
+
+
 6.0 (2023-09-26)
 ================
 

{risclog.sqlalchemy-6.0 → risclog.sqlalchemy-6.2}/doc/conf.py

@@ -1,7 +1,6 @@
 import os
 import sys
 
-
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.

risclog.sqlalchemy-6.2/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=40.6.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.coverage.run]
+relative_files = true
+parallel = true
+branch = true
+source = ["risclog.sqlalchemy"]
+
+[tool.coverage.paths]
+source = ["src", ".pytest/*/site-packages"]
+
+[tool.coverage.html]
+directory = "coverage-report"
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+skip_covered = true
+exclude_lines = [
+    # a more strict default pragma
+    "\\# pragma: no cover\\b",
+
+    # allow defensive code
+    "^\\s*raise AssertionError\\b",
+    "^\\s*raise NotImplementedError\\b",
+    "^\\s*return NotImplemented\\b",
+    "^\\s*raise$",
+
+    # typing-related code
+    "^if (False|TYPE_CHECKING):",
+    ": \\.\\.\\.(\\s*#.*)?$",
+    "^ +\\.\\.\\.$",
+    "-> ['\"]?NoReturn['\"]?:",
+]
+
+[tool.black]
+line-length = 79
+target-version = ['py38']
+exclude = '''
+/(
+    \.eggs
+  | eggs
+  | venv
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+'''
+skip-string-normalization = true
+
+[tool.check-manifest]
+ignore-bad-ideas = ["*.mo"]

{risclog.sqlalchemy-6.0 → risclog.sqlalchemy-6.2}/requirements.txt

@@ -1,8 +1,10 @@
 # Created by batou. Do not edit manually.
 # appenv-python-preference: 3.7,3.8,3.9
 -e .[test]
-sqlalchemy<1.4
+sqlalchemy<2.0
 alembic
 psycopg2-binary
 pytest
 pytest-timeout
+pytest-cov
+greenlet

{risclog.sqlalchemy-6.0 → risclog.sqlalchemy-6.2}/setup.py

@@ -3,14 +3,13 @@
 """Encapsulate sqlalchemy modelling infrastructure.
 """
 
-from setuptools import find_packages
-from setuptools import setup
 import glob
 
+from setuptools import find_packages, setup
 
 setup(
     name='risclog.sqlalchemy',
-    version='6.0',
+    version='6.2',
     python_requires='>=3.7',
     install_requires=[
         'SQLAlchemy >= 1.0, < 2',
@@ -22,7 +21,6 @@ setup(
         'zope.interface',
         'zope.sqlalchemy >= 1.3',
     ],
-
     extras_require={
         'test': [
             'gocept.testdb',
@@ -32,47 +30,43 @@ setup(
             'pyramid',
             'pytest',
         ],
-        'pyramid': [
-            'pyramid'
-        ],
+        'pyramid': ['pyramid'],
     },
-
     entry_points={},
-
     author='gocept <mail@gocept.com>',
     author_email='mail@gocept.com',
     license='ZPL 2.1',
     url='https://github.com/gocept/risclog.sqlalchemy',
-
     keywords='sqlalchemy alembic model infrastructure utility',
     classifiers=[
-        "Development Status :: 5 - Production/Stable",
-        "Framework :: Pyramid",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved",
-        "License :: OSI Approved :: Zope Public License",
-        "Natural Language :: English",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: Implementation",
-        "Programming Language :: Python :: Implementation :: CPython",
-        "Topic :: Database",
-        "Topic :: Software Development :: Libraries",
-        "Topic :: Software Development :: Libraries :: Python Modules",
+        'Development Status :: 5 - Production/Stable',
+        'Framework :: Pyramid',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved',
+        'License :: OSI Approved :: Zope Public License',
+        'Natural Language :: English',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: Implementation',
+        'Programming Language :: Python :: Implementation :: CPython',
+        'Topic :: Database',
+        'Topic :: Software Development :: Libraries',
+        'Topic :: Software Development :: Libraries :: Python Modules',
     ],
     description=__doc__.strip(),
     long_description=(
-        open('README.rst').read() +
-        '\n\n' +
-        open('HACKING.rst').read() +
-        '\n\n' +
-        open('CHANGES.rst').read()),
+        open('README.rst').read()
+        + '\n\n'
+        + open('HACKING.rst').read()
+        + '\n\n'
+        + open('CHANGES.rst').read()
+    ),
     namespace_packages=['risclog'],
     packages=find_packages('src'),
     package_dir={'': 'src'},

{risclog.sqlalchemy-6.0 → risclog.sqlalchemy-6.2}/src/risclog/sqlalchemy/cache.py

@@ -1,12 +1,13 @@
-from risclog.sqlalchemy.model import ObjectBase
-from sqlalchemy.inspection import inspect
-from sqlalchemy.orm import attributes
 import csv
 import gc
 import io
-import sqlalchemy
 import sys
 
+import sqlalchemy
+from risclog.sqlalchemy.model import ObjectBase
+from sqlalchemy.inspection import inspect
+from sqlalchemy.orm import attributes
+
 
 class MultipleObjectsFoundException(Exception):
     """Raised when a single result was expected but multiple were found."""
@@ -49,18 +50,18 @@ class ModelCache:
     """
 
     def __init__(
-            self,
-            save_order,
-            sequences,
-            session,
-            engine_name,
-            prefetch=None,
-            preload_models=True,
-            preload_models_data={},
-            preload_models_filter={},
-            logger=None,
-            use_copy=False,
-            check_memory_usage=False,
+        self,
+        save_order,
+        sequences,
+        session,
+        engine_name,
+        prefetch=None,
+        preload_models=True,
+        preload_models_data={},
+        preload_models_filter={},
+        logger=None,
+        use_copy=False,
+        check_memory_usage=False,
     ):
         """
         Args:
@@ -94,6 +95,7 @@ class ModelCache:
 
         if check_memory_usage:
             from guppy import hpy
+
             self.hp = hpy()
             self.hp.setrelheap()
 
@@ -104,12 +106,12 @@ class ModelCache:
         h = self.hp.heap()
         return h.size
 
-    def _sizeof_fmt(self, num, suffix="B"):
-        for unit in ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"]:
+    def _sizeof_fmt(self, num, suffix='B'):
+        for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
             if abs(num) < 1024.0:
-                return f"{num:3.1f} {unit}{suffix}"
+                return f'{num:3.1f} {unit}{suffix}'
             num /= 1024.0
-        return f"{num:.1f}Yi{suffix}"
+        return f'{num:.1f}Yi{suffix}'
 
     def log_memory_usage(self):
         if not hasattr(self, 'hp'):
@@ -197,8 +199,11 @@ class ModelCache:
         if session is None:
             session = self.session
         if cursor is None and self._use_copy:
-            cursor = self.session.using_bind(
-                self._engine_name).connection().connection.cursor()
+            cursor = (
+                self.session.using_bind(self._engine_name)
+                .connection()
+                .connection.cursor()
+            )
 
         self._log('debug', 'Flushing model cache.')
         self._assign_sequences()
@@ -213,7 +218,8 @@ class ModelCache:
                 continue
 
             self._deregister_change_handler(
-                type(objects[0]), self._instance_change_handler)
+                type(objects[0]), self._instance_change_handler
+            )
             new_objects, updated_objects = [], []
 
             for object in objects:
@@ -254,7 +260,8 @@ class ModelCache:
             file = io.StringIO()
             writer = csv.DictWriter(file, table.columns.keys())
             columns = [
-                c for c in model.c.items()
+                c
+                for c in model.c.items()
                 if c[1].table == table or c[1].primary_key
             ]
 

{risclog.sqlalchemy-6.0 → risclog.sqlalchemy-6.2}/src/risclog/sqlalchemy/db.py

@@ -1,8 +1,9 @@
+import os
+
 import alembic.config
 import alembic.environment
 import alembic.migration
 import alembic.script
-import os
 import risclog.sqlalchemy.interfaces
 import sqlalchemy
 import sqlalchemy.ext.declarative
@@ -12,15 +13,15 @@ import zope.component
 import zope.interface
 import zope.sqlalchemy
 
-
 # Mapping engine name registered using Database.register_engine --> base class
 _ENGINE_CLASS_MAPPING = {}
 
 
 def assert_engine_not_registered(name, mapping):
     """Ensure a consistent error message."""
-    assert name not in mapping, \
-        f'An engine for name `{name}` is already registered.'
+    assert (
+        name not in mapping
+    ), f'An engine for name `{name}` is already registered.'
 
 
 def register_class(class_):
@@ -51,23 +52,25 @@ class RoutingSession(sqlalchemy.orm.Session):
         if bind:
             return bind
         db_util = zope.component.getUtility(
-            risclog.sqlalchemy.interfaces.IDatabase)
+            risclog.sqlalchemy.interfaces.IDatabase
+        )
         if self._name:
             # Engine was set using self.using_bind:
             return db_util.get_engine(self._name)
         if not mapper:
             if len(_ENGINE_CLASS_MAPPING) == 1:
                 return db_util.get_engine(
-                    list(_ENGINE_CLASS_MAPPING.keys())[0])
+                    list(_ENGINE_CLASS_MAPPING.keys())[0]
+                )
             raise RuntimeError(
-                "Don't know how to determine engine, no mapper.")
+                "Don't know how to determine engine, no mapper."
+            )
 
         for engine_name, class_ in _ENGINE_CLASS_MAPPING.items():
             if issubclass(mapper.class_, class_):
                 return db_util.get_engine(engine_name)
 
-        raise RuntimeError(
-            f"Did not find an engine for {mapper.class_}")
+        raise RuntimeError(f'Did not find an engine for {mapper.class_}')
 
     def using_bind(self, name):
         """Select an engine name if not using mappers."""
@@ -83,45 +86,55 @@ def get_database(testing=False, keep_session=False, expire_on_commit=False):
         # Keep the old testing behaviour by default
         keep_session = True
         expire_on_commit = True
-    db = zope.component.queryUtility(
-        risclog.sqlalchemy.interfaces.IDatabase)
+    db = zope.component.queryUtility(risclog.sqlalchemy.interfaces.IDatabase)
     if db is None:
         db = Database(testing, keep_session, expire_on_commit)
-    assert db.testing == testing, \
-        'Requested testing status `%s` does not match Database.testing.' % (
-            testing)
+    assert (
+        db.testing == testing
+    ), 'Requested testing status `%s` does not match Database.testing.' % (
+        testing
+    )
     return db
 
 
 @zope.interface.implementer(risclog.sqlalchemy.interfaces.IDatabase)
 class Database:
-
     def __init__(
         self, testing=False, keep_session=False, expire_on_commit=False
     ):
-        assert zope.component.queryUtility(
-            risclog.sqlalchemy.interfaces.IDatabase) is None, \
-            'Cannot create Database twice, use `.get_database()` to get '\
+        assert (
+            zope.component.queryUtility(
+                risclog.sqlalchemy.interfaces.IDatabase
+            )
+            is None
+        ), (
+            'Cannot create Database twice, use `.get_database()` to get '
             'the instance.'
+        )
         self._engines = {}
         self.testing = testing
         self.session_factory = sqlalchemy.orm.scoped_session(
             sqlalchemy.orm.sessionmaker(
-                class_=RoutingSession,
-                expire_on_commit=expire_on_commit))
+                class_=RoutingSession, expire_on_commit=expire_on_commit
+            )
+        )
         self.zope_transaction_events = zope.sqlalchemy.register(
-            self.session_factory, keep_session=keep_session)
+            self.session_factory, keep_session=keep_session
+        )
         self._setup_utility()
 
-    def register_engine(self, dsn, engine_args={}, name='',
-                        alembic_location=None):
+    def register_engine(
+        self, dsn, engine_args={}, name='', alembic_location=None
+    ):
         assert_engine_not_registered(name, self._engines)
-        engine_args['echo'] = bool(int(os.environ.get(
-            'ECHO_SQLALCHEMY_QUERIES', '0')))
+        engine_args['echo'] = bool(
+            int(os.environ.get('ECHO_SQLALCHEMY_QUERIES', '0'))
+        )
         engine = sqlalchemy.create_engine(dsn, **engine_args)
         self._verify_engine(engine)
         self._engines[name] = dict(
-            engine=engine, alembic_location=alembic_location)
+            engine=engine, alembic_location=alembic_location
+        )
         # Some model classes may already have been constructed without having
         # had access to a db engine so far, so give them a chance to do the
         # reflection now.
@@ -148,15 +161,16 @@ class Database:
         """Create all tables etc. for an engine."""
         engine = self._engines[engine_name]
         _ENGINE_CLASS_MAPPING[engine_name].metadata.create_all(
-            engine['engine'])
+            engine['engine']
+        )
 
         # mark the database to be in the latest revision
         location = engine['alembic_location']
         if location:
             with alembic_context(engine['engine'], location) as ac:
                 ac.migration_context.stamp(
-                    ac.script,
-                    ac.script.get_current_head())
+                    ac.script, ac.script.get_current_head()
+                )
         if create_defaults:
             self.create_defaults(engine_name)
 
@@ -173,25 +187,27 @@ class Database:
         # Step 1: Try to identify a testing table
         conn = engine.connect()
         try:
-            conn.execute("SELECT * FROM tmp_functest")
+            conn.execute('SELECT * FROM tmp_functest')
         except sqlalchemy.exc.DatabaseError:
             db_is_testing = False
         else:
             db_is_testing = True
         conn.invalidate()
 
-        if (self.testing and db_is_testing):
+        if self.testing and db_is_testing:
             # We're running as a test and it is a test dabase. Continue
             return
-        if (not self.testing and not db_is_testing):
+        if not self.testing and not db_is_testing:
             # We're running as a production system and we have a production
             # database. Continue.
             return
 
         # We're not in a valid state. Bail out.
-        raise SystemExit("Not working against correct database (live vs "
-                         "testing). Refusing to set up database connection "
-                         "to {}.".format(engine.url))
+        raise SystemExit(
+            'Not working against correct database (live vs '
+            'testing). Refusing to set up database connection '
+            'to {}.'.format(engine.url)
+        )
 
     def assert_database_revision_is_current(self, engine_name=''):
         def assert_revision(ac, head_rev, db_rev):
@@ -200,7 +216,9 @@ class Database:
                     'Database revision {} of engine "{}" does not match '
                     'current revision {}.\nMaybe you want to call '
                     '`bin/alembic upgrade head`.'.format(
-                        db_rev, engine_name, head_rev))
+                        db_rev, engine_name, head_rev
+                    )
+                )
 
         self._run_in_alembic_context(assert_revision, engine_name)
 
@@ -208,6 +226,7 @@ class Database:
         def upgrade_revision(ac, head_rev, db_rev):
             if head_rev != db_rev:
                 ac.upgrade(head_rev)
+
         self._run_in_alembic_context(upgrade_revision, engine_name)
 
     @property
@@ -229,9 +248,15 @@ class Database:
     def _teardown_utility(self):
         zope.component.getGlobalSiteManager().unregisterUtility(self)
 
-    def empty(self, engine, table_names=None, cascade=False,
-              restart_sequences=True,
-              empty_alembic_version=False, commit=True):
+    def empty(
+        self,
+        engine,
+        table_names=None,
+        cascade=False,
+        restart_sequences=True,
+        empty_alembic_version=False,
+        commit=True,
+    ):
         transaction.abort()
         if table_names is None:
             inspector = sqlalchemy.inspect(engine)
@@ -259,8 +284,10 @@ class Database:
             'TRUNCATE {} {} {}'.format(
                 tables,
                 'RESTART IDENTITY' if restart_sequences else '',
-                'CASCADE' if cascade else ''),
-            bind=engine)
+                'CASCADE' if cascade else '',
+            ),
+            bind=engine,
+        )
         zope.sqlalchemy.mark_changed(self.session)
         if commit:
             transaction.commit()
@@ -285,7 +312,6 @@ class Database:
 
 
 class alembic_context:
-
     def __init__(self, engine, script_location):
         self.engine = engine
         self.script_location = script_location
@@ -302,22 +328,23 @@ class alembic_context:
 
 
 class AlembicContext:
-
     def __init__(self, conn, script_location):
         self.conn = conn
         self.config = alembic.config.Config()
         self.config.set_main_option('script_location', script_location)
         self.migration_context = alembic.migration.MigrationContext.configure(
-            conn)
+            conn
+        )
         self.script = alembic.script.ScriptDirectory.from_config(self.config)
 
     def upgrade(self, dest_rev):
         """Upgrade from current to `dest_rev`."""
+
         def upgrade_fn(rev, context):
             return self.script._upgrade_revs(dest_rev, rev)
 
         with alembic.environment.EnvironmentContext(
-                self.config, self.script, fn=upgrade_fn,
-                destination_rev=dest_rev) as ec:
+            self.config, self.script, fn=upgrade_fn, destination_rev=dest_rev
+        ) as ec:
             ec.configure(self.conn)
             ec.run_migrations()

risclog.sqlalchemy-6.2/src/risclog/sqlalchemy/functions.py

@@ -0,0 +1,8 @@
+from sqlalchemy.sql.expression import and_, between, or_
+
+
+def in_interval(point, left, right):
+    return or_(
+        between(point, left, right),
+        and_(point >= left, right == None),  # noqa: E711 comparison to None
+    )

{risclog.sqlalchemy-6.0 → risclog.sqlalchemy-6.2}/src/risclog/sqlalchemy/interfaces.py

@@ -30,3 +30,10 @@ class Added(zope.interface.interfaces.ObjectEvent):
 
     def __init__(self, object):
         self.object = object
+
+
+class Deleted(zope.interface.interfaces.ObjectEvent):
+    """An object has been removed from the session."""
+
+    def __init__(self, object):
+        self.object = object