plexus-python-pulse-common 1.1.83__tar.gz → 1.1.85__tar.gz

{plexus_python_pulse_common-1.1.83 → plexus_python_pulse_common-1.1.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-pulse-common
-Version: 1.1.83
+Version: 1.1.85
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

plexus_python_pulse_common-1.1.85/src/plexus/pulse/common/utils/apiutils.py

@@ -0,0 +1,47 @@
+from contextlib import AbstractContextManager
+
+import sqlalchemy.orm as sa_orm
+from fastapi import HTTPException
+from plexus.common.utils import logger
+
+__all__ = [
+    "managed_db_session",
+]
+
+
+class DBSessionExceptionManager(AbstractContextManager):
+    def __init__(self, db: sa_orm.Session, commit_on_exit: bool):
+        self.db = db
+        self.commit_on_exit = commit_on_exit
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if exc_type is None:
+            if self.commit_on_exit:
+                try:
+                    self.db.commit()
+                except BaseException as commit_exc_value:
+                    self.handle_exception(commit_exc_value)
+                    raise
+            return False
+
+        self.handle_exception(exc_value)
+        return False
+
+    def handle_exception(self, exc_value: BaseException | None) -> None:
+        try:
+            self.db.rollback()
+        except Exception:
+            logger.exception("Failed to roll back database session")
+
+        if isinstance(exc_value, HTTPException) or not isinstance(exc_value, Exception):
+            return
+
+        logger.error("Database session failed", exc_info=(type(exc_value), exc_value, exc_value.__traceback__))
+        raise HTTPException(status_code=500, detail="Internal server error") from exc_value
+
+
+def managed_db_session(db: sa_orm.Session, commit_on_exit: bool = True) -> DBSessionExceptionManager:
+    return DBSessionExceptionManager(db, commit_on_exit)

{plexus_python_pulse_common-1.1.83 → plexus_python_pulse_common-1.1.85}/src/plexus/pulse/common/utils/ormutils.py

@@ -224,24 +224,72 @@ def collect_model_tables[ModelT: SQLModel](*models: ModelT) -> sa.MetaData:
     return metadata
 
 
-def model_copy_from[ModelT: SQLModel, ModelU: SQLModel](dst: ModelT, src: ModelU, **kwargs) -> ModelT:
+def model_copy_from[ModelT: SQLModel, ModelU: SQLModel](
+    dst: ModelT,
+    src: ModelU,
+    *,
+    include: set[str] | frozenset[str] | None = None,
+    exclude: set[str] | frozenset[str] | None = None,
+    exclude_none: bool = False,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+) -> ModelT:
+    """Copy native field values without invoking serializers.
+
+    ``include`` and ``exclude`` select top-level field names only; nested filter
+    mappings and serialization options are not supported. The exclusion flags
+    also apply when recursively copying nested models.
+    """
     if not isinstance(dst, SQLModel) or not isinstance(src, SQLModel):
         raise TypeError("both 'dst' and 'src' must be instances of SQLModel or its subclasses")
+    if include is not None and (
+        not isinstance(include, (set, frozenset)) or not all(isinstance(item, str) for item in include)):
+        raise TypeError(f"'include' must be a set of field names or None")
+    if exclude is not None and (
+        not isinstance(exclude, (set, frozenset)) or not all(isinstance(item, str) for item in exclude)):
+        raise TypeError(f"'exclude' must be a set of field names or None")
 
-    for field, value in src.model_dump(**kwargs).items():
-        if field not in dst.model_fields:
-            continue
+    src_model = type(src)
+    dst_model = type(dst)
+
+    for field, src_field_info in src_model.model_fields.items():
         # Skip fields that are not present in the destination model
-        if value is None and dst.model_fields[field].required:
-            raise ValueError(f"field '{field}' is required but got None")
+        if field not in dst_model.model_fields:
+            continue
+        if include is not None and field not in include:
+            continue
+        if exclude is not None and field in exclude:
+            continue
+        if exclude_unset and field not in src.model_fields_set:
+            continue
+
+        value = getattr(src, field)
+        if exclude_none and value is None:
+            continue
+        if exclude_defaults and not src_field_info.is_required():
+            default = src_field_info.get_default(call_default_factory=True, validated_data=src.__dict__)
+            if value == default:
+                continue
+
+        field_info = dst_model.model_fields[field]
+        if value is None:
+            pdt.TypeAdapter(field_info.annotation).validate_python(None)
 
         # Only set the field if it exists in the destination model
         if hasattr(dst, field):
             # If the field is a SQLModel, recursively copy it
             if isinstance(value, SQLModel):
-                value = model_copy_from(getattr(dst, field), value, **kwargs)
+                value = model_copy_from(getattr(dst, field),
+                                        value,
+                                        exclude_none=exclude_none,
+                                        exclude_unset=exclude_unset,
+                                        exclude_defaults=exclude_defaults)
             elif isinstance(value, list) and all(isinstance(item, SQLModel) for item in value):
-                value = [model_copy_from(dst_item, src_item, **kwargs)
+                value = [model_copy_from(dst_item,
+                                         src_item,
+                                         exclude_none=exclude_none,
+                                         exclude_unset=exclude_unset,
+                                         exclude_defaults=exclude_defaults)
                          for dst_item, src_item in zip(getattr(dst, field), value)]
 
         setattr(dst, field, value)
@@ -503,6 +551,16 @@ def model_revision_type(dialect: str | None = None) -> sa.types.TypeEngine[int]:
     raise ValueError(f"unsupported database dialect '{dialect}'")
 
 
+def index_condition_kwarg(dialect: str | None = None, clause: sa.TextClause | None = None) -> dict[str, sa.TextClause]:
+    if dialect is None:
+        dialect = dialects.postgresql
+    if dialect == dialects.postgresql:
+        return dict(postgresql_where=clause)
+    if dialect == dialects.sqlite:
+        return dict(sqlite_where=clause)
+    raise ValueError(f"unsupported database dialect '{dialect}'")
+
+
 # At the present time, we cannot express intersection of Protocol and SQLModel directly.
 # Thus, we define union types here for the mixins.
 SequenceModelMixin = SequenceModelMixinProtocol | pdt.BaseModel
@@ -670,7 +728,7 @@ def make_snapshot_model_mixin(dialect: str | None = None) -> type[SnapshotModelM
                 index_name,
                 "record_sqn",
                 unique=True,
-                postgresql_where=sa.text('"expired_at" IS NULL'),
+                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
             )
 
         @classmethod
@@ -678,7 +736,7 @@ def make_snapshot_model_mixin(dialect: str | None = None) -> type[SnapshotModelM
             return sa.Index(
                 index_name,
                 *fields,
-                postgresql_where=sa.text('"expired_at" IS NULL'),
+                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
             )
 
         @classmethod
@@ -687,7 +745,7 @@ def make_snapshot_model_mixin(dialect: str | None = None) -> type[SnapshotModelM
                 index_name,
                 *fields,
                 unique=True,
-                postgresql_where=sa.text('"expired_at" IS NULL'),
+                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
             )
 
     return ModelMixin
@@ -807,7 +865,7 @@ def make_revision_model_mixin(dialect: str | None = None) -> type[RevisionModelM
                 index_name,
                 "record_sqn",
                 unique=True,
-                postgresql_where=sa.text('"expired_at" IS NULL'),
+                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
             )
 
         @classmethod
@@ -815,7 +873,7 @@ def make_revision_model_mixin(dialect: str | None = None) -> type[RevisionModelM
             return sa.Index(
                 index_name,
                 *fields,
-                postgresql_where=sa.text('"expired_at" IS NULL'),
+                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
             )
 
         @classmethod
@@ -824,7 +882,7 @@ def make_revision_model_mixin(dialect: str | None = None) -> type[RevisionModelM
                 index_name,
                 *fields,
                 unique=True,
-                postgresql_where=sa.text('"expired_at" IS NULL'),
+                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
             )
 
     return ModelMixin

{plexus_python_pulse_common-1.1.83 → plexus_python_pulse_common-1.1.85}/src/plexus_python_pulse_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-pulse-common
-Version: 1.1.83
+Version: 1.1.85
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{plexus_python_pulse_common-1.1.83 → plexus_python_pulse_common-1.1.85}/src/plexus_python_pulse_common.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ test/plexus_tests/pulse/common/carto/__init__.py
 test/plexus_tests/pulse/common/carto/osm_file_test.py
 test/plexus_tests/pulse/common/carto/osm_tags_test.py
 test/plexus_tests/pulse/common/utils/__init__.py
+test/plexus_tests/pulse/common/utils/apiutils_test.py
 test/plexus_tests/pulse/common/utils/bagutils_test.py
 test/plexus_tests/pulse/common/utils/datautils_test.py
 test/plexus_tests/pulse/common/utils/dockerutils_test.py

plexus_python_pulse_common-1.1.85/test/plexus_tests/pulse/common/utils/apiutils_test.py

@@ -0,0 +1,71 @@
+import unittest
+from unittest.mock import Mock, patch
+
+from fastapi import HTTPException
+
+from plexus.pulse.common.utils.apiutils import managed_db_session
+
+
+class ApiUtilsTest(unittest.TestCase):
+    def test_managed_db_session__success(self):
+        for commit_on_exit in (True, False):
+            with self.subTest(commit_on_exit=commit_on_exit):
+                db = Mock()
+                with managed_db_session(db, commit_on_exit):
+                    pass
+                self.assertEqual(db.commit.call_count, int(commit_on_exit))
+                db.rollback.assert_not_called()
+
+    def test_managed_db_session__http_exception(self):
+        db = Mock()
+        error = HTTPException(404, "Missing", headers={"X-Reason": "missing"})
+        with self.assertRaises(HTTPException) as caught:
+            with managed_db_session(db):
+                raise error
+        self.assertIs(caught.exception, error)
+        db.rollback.assert_called_once_with()
+        db.commit.assert_not_called()
+
+    def test_managed_db_session__body_and_commit_errors_are_sanitized(self):
+        for during_commit in (False, True):
+            with self.subTest(during_commit=during_commit):
+                db = Mock()
+                error = RuntimeError("Sensitive SQL parameters")
+                if during_commit:
+                    db.commit.side_effect = error
+                with patch("plexus.pulse.common.utils.apiutils.logger") as logger:
+                    with self.assertRaises(HTTPException) as caught:
+                        with managed_db_session(db):
+                            if not during_commit:
+                                raise error
+                    logger.error.assert_called_once()
+                self.assertEqual(caught.exception.status_code, 500)
+                self.assertEqual(caught.exception.detail, "Internal server error")
+                self.assertIs(caught.exception.__cause__, error)
+                db.rollback.assert_called_once_with()
+
+    def test_managed_db_session__process_control_exceptions_are_preserved(self):
+        for error_type in (KeyboardInterrupt, SystemExit):
+            for during_commit in (False, True):
+                with self.subTest(error_type=error_type, during_commit=during_commit):
+                    db = Mock()
+                    error = error_type()
+                    if during_commit:
+                        db.commit.side_effect = error
+                    with self.assertRaises(error_type) as caught:
+                        with managed_db_session(db):
+                            if not during_commit:
+                                raise error
+                    self.assertIs(caught.exception, error)
+                    db.rollback.assert_called_once_with()
+
+    def test_managed_db_session__rollback_failure_preserves_original_http_exception(self):
+        db = Mock()
+        db.rollback.side_effect = RuntimeError("Rollback failed")
+        error = HTTPException(409, "Conflict")
+        with patch("plexus.pulse.common.utils.apiutils.logger") as logger:
+            with self.assertRaises(HTTPException) as caught:
+                with managed_db_session(db):
+                    raise error
+            logger.exception.assert_called_once()
+        self.assertIs(caught.exception, error)

{plexus_python_pulse_common-1.1.83 → plexus_python_pulse_common-1.1.85}/test/plexus_tests/pulse/common/utils/ormutils_test.py

@@ -1,6 +1,8 @@
 import datetime
+import unittest
 import uuid as py_uuid
 
+import pydantic as pdt
 import pytest
 import pytest_postgresql.factories
 import sqlalchemy as sa
@@ -15,16 +17,9 @@ from sqlmodel import Field, SQLModel
 
 from plexus.pulse.common.utils.apiutils import managed_db_session
 from plexus.pulse.common.utils.ormutils import (
-    changing_model_mixin,
-    make_base_model,
-    make_changing_model_mixin,
-    make_revision_model_mixin,
-    make_revision_model_trigger,
-    make_sequence_model_mixin,
-    make_snapshot_model_mixin,
-    make_snapshot_model_trigger,
-    revision_model_mixin,
-    snapshot_model_mixin,
+    changing_model_mixin, make_base_model, make_changing_model_mixin,
+    make_revision_model_mixin, make_revision_model_trigger, make_sequence_model_mixin, make_snapshot_model_mixin,
+    make_snapshot_model_trigger, model_copy_from, revision_model_mixin, snapshot_model_mixin,
 )
 from plexus.pulse.common.utils.ormutils import (
     db_activate_revision_model,
@@ -1217,3 +1212,57 @@ def test_make_revision_model_trigger(fixture_postgresql_test_proc, fixture_postg
             assert updated_record.updated_at is not None
             assert updated_record.updated_at == initial_record.expired_at
             assert updated_record.expired_at is None
+
+
+class CopyRecord(SQLModel):
+    name: str | None = None
+    count: int = 0
+    values: list[int] = Field(default_factory=list)
+    created_at: datetime.datetime | None = None
+
+    @pdt.field_serializer("created_at")
+    def serialize_created_at(self, value):
+        raise AssertionError("Copying must not invoke serializers")
+
+
+class OrmUtilsTest(unittest.TestCase):
+    def test_model_copy_from__native_datetime_without_serialization(self):
+        now = datetime.datetime.now(datetime.timezone.utc)
+        result = model_copy_from(CopyRecord(), CopyRecord(created_at=now))
+        self.assertIs(result.created_at, now)
+
+    def test_field_filters(self):
+        for options in (
+                {"include": {"count"}},
+                {"exclude": frozenset({"name", "values", "created_at"})},
+                {"exclude_unset": True},
+                {"exclude_defaults": True},
+        ):
+            with self.subTest(options=options):
+                dst = CopyRecord(name="keep", count=9, values=[1])
+                model_copy_from(dst, CopyRecord(count=4), **options)
+                self.assertEqual(dst.name, "keep")
+                self.assertEqual(dst.count, 4)
+                self.assertEqual(dst.values, [1])
+
+    def test_model_copy_from__none_filter(self):
+        dst = CopyRecord(name="keep")
+        model_copy_from(dst, CopyRecord(), exclude_none=True)
+        self.assertEqual(dst.name, "keep")
+        model_copy_from(dst, CopyRecord())
+        self.assertIsNone(dst.name)
+
+    def test_model_copy_from__explicit_default_is_set(self):
+        dst = CopyRecord(count=9)
+        model_copy_from(dst, CopyRecord(count=0), exclude_unset=True)
+        self.assertEqual(dst.count, 0)
+
+    def test_model_copy_from__exclude_wins_over_include(self):
+        dst = CopyRecord(count=9)
+        model_copy_from(dst, CopyRecord(count=4), include={"count"}, exclude={"count"})
+        self.assertEqual(dst.count, 9)
+
+    def test_model_copy_from__unsupported_options_fail(self):
+        for options in ({"include": {"name": True}}, {"by_alias": True}):
+            with self.subTest(options=options), self.assertRaises(TypeError):
+                model_copy_from(CopyRecord(), CopyRecord(), **options)

{plexus_python_pulse_common-1.1.83 → plexus_python_pulse_common-1.1.85}/test/plexus_tests/pulse/common/utils/s3utils_test.py

@@ -15,7 +15,7 @@ from testenv import resources_directory
 
 @contextlib.contextmanager
 def moto_server_endpoint_url():
-    server = moto.server.ThreadedMotoServer(port=0)  # random free port
+    server = moto.server.ThreadedMotoServer(ip_address="127.0.0.1", port=0)  # random free port
     try:
         server.start()
         host, port = server.get_host_and_port()
@@ -481,9 +481,8 @@ class S3UtilsTest(unittest.TestCase):
 
     def test_s3_archive_list_files(self):
         with (
-            moto.mock_aws(),
             moto_server_endpoint_url() as endpoint_url,
-            s3_make_client(endpoint_url=endpoint_url) as client,
+            s3_make_client("testing", "testing", "us-east-1", endpoint_url=endpoint_url) as client,
         ):
             client.create_bucket(Bucket="dummy-bucket")
 
@@ -544,9 +543,8 @@ class S3UtilsTest(unittest.TestCase):
 
     def test_s3_archive_open_member(self):
         with (
-            moto.mock_aws(),
             moto_server_endpoint_url() as endpoint_url,
-            s3_make_client(endpoint_url=endpoint_url) as client,
+            s3_make_client("testing", "testing", "us-east-1", endpoint_url=endpoint_url) as client,
         ):
             client.create_bucket(Bucket="dummy-bucket")
 
@@ -571,9 +569,8 @@ class S3UtilsTest(unittest.TestCase):
 
     def test_s3_archive_open_members(self):
         with (
-            moto.mock_aws(),
             moto_server_endpoint_url() as endpoint_url,
-            s3_make_client(endpoint_url=endpoint_url) as client,
+            s3_make_client("testing", "testing", "us-east-1", endpoint_url=endpoint_url) as client,
         ):
             client.create_bucket(Bucket="dummy-bucket")
 

plexus_python_pulse_common-1.1.83/src/plexus/pulse/common/utils/apiutils.py

@@ -1,31 +0,0 @@
-from contextlib import AbstractContextManager
-
-import sqlalchemy.orm as sa_orm
-from fastapi import HTTPException
-
-__all__ = [
-    "managed_db_session",
-]
-
-
-class DBSessionExceptionManager(AbstractContextManager):
-    def __init__(self, db: sa_orm.Session, commit_on_exit: bool):
-        self.db = db
-        self.commit_on_exit = commit_on_exit
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        if isinstance(exc_type, HTTPException):
-            return False  # Propagate HTTPException
-        if exc_type is not None:
-            self.db.rollback()  # Raise a new HTTPException (or any other exception type)
-            raise HTTPException(status_code=500, detail=str(exc_value)) from exc_value
-        if self.commit_on_exit:
-            self.db.commit()
-        return True
-
-
-def managed_db_session(db: sa_orm.Session, commit_on_exit: bool = True) -> DBSessionExceptionManager:
-    return DBSessionExceptionManager(db, commit_on_exit)