plexus-python-common 1.0.65__tar.gz → 1.0.67__tar.gz

{plexus_python_common-1.0.65 → plexus_python_common-1.0.67}/PKG-INFO

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

{plexus_python_common-1.0.65 → plexus_python_common-1.0.67}/src/plexus/common/utils/jsonutils.py

@@ -21,7 +21,9 @@ __all__ = [
 ]
 
 
-def json_datetime_decoder(v: Any) -> datetime.datetime:
+def json_datetime_decoder(v: Any) -> datetime.datetime | None:
+    if v is None:
+        return None
     if isinstance(v, str):
         return json_datetime_decoder(dt_parse(v, extended_format(with_us=True, with_tz=True)))
     if isinstance(v, datetime.datetime):
@@ -29,7 +31,9 @@ def json_datetime_decoder(v: Any) -> datetime.datetime:
     raise ValueError("unexpected type of value for datetime decoder")
 
 
-def json_datetime_encoder(v: Any) -> str:
+def json_datetime_encoder(v: Any) -> str | None:
+    if v is None:
+        return None
     if isinstance(v, str):
         return json_datetime_encoder(dt_parse(v, extended_format(with_us=True, with_tz=True)))
     if isinstance(v, datetime.datetime):

{plexus_python_common-1.0.65 → plexus_python_common-1.0.67}/src/plexus/common/utils/ormutils.py

@@ -28,6 +28,10 @@ __all__ = [
     "ChangingModelMixinProtocol",
     "SnapshotModelMixinProtocol",
     "RevisionModelMixinProtocol",
+    "SQLiteDateTime",
+    "model_sqn_type",
+    "model_datetime_tz_type",
+    "model_revision_type",
     "SequenceModelMixin",
     "ChangingModelMixin",
     "SnapshotModelMixin",
@@ -391,12 +395,26 @@ class RevisionModelMixinProtocol(SequenceModelMixinProtocol):
         ...
 
 
-# At the present time, we cannot express intersection of Protocol and SQLModel directly.
-# Thus, we define union types here for the mixins.
-SequenceModelMixin = SequenceModelMixinProtocol | SQLModel
-ChangingModelMixin = ChangingModelMixinProtocol | SQLModel
-SnapshotModelMixin = SnapshotModelMixinProtocol | SQLModel
-RevisionModelMixin = RevisionModelMixinProtocol | SQLModel
+class SQLiteDateTime(sa.TypeDecorator):
+    """
+    Custom SQLAlchemy type decorator for handling timezone-aware datetimes in SQLite.
+    """
+    impl = sa.DateTime
+    cache_ok = True
+
+    def process_bind_param(self, value: datetime.datetime | None, dialect) -> datetime.datetime | None:
+        if value is None:
+            return None
+        if value.tzinfo is None:
+            return value.replace(tzinfo=datetime.timezone.utc)
+        if value.tzinfo == datetime.timezone.utc:
+            return value
+        raise ValueError("Only UTC timezone-aware datetimes are supported")
+
+    def process_result_value(self, value: datetime.datetime | None, dialect) -> datetime.datetime | None:
+        if value is None:
+            return None
+        return value.replace(tzinfo=datetime.timezone.utc)
 
 
 def model_sqn_type(dialect: str | None = None) -> sa.types.TypeEngine[int]:
@@ -428,7 +446,7 @@ def model_datetime_tz_type(dialect: str | None = None) -> sa.types.TypeEngine[da
     if dialect == dialects.postgresql:
         return sa_pg.TIMESTAMP(timezone=True)
     if dialect == dialects.sqlite:
-        return sa_sqlite.TIMESTAMP(timezone=True)
+        return SQLiteDateTime
     raise ValueError(f"unsupported database dialect '{dialect}'")
 
 
@@ -448,6 +466,14 @@ def model_revision_type(dialect: str | None = None) -> sa.types.TypeEngine[int]:
     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
+ChangingModelMixin = ChangingModelMixinProtocol | pdt.BaseModel
+SnapshotModelMixin = SnapshotModelMixinProtocol | pdt.BaseModel
+RevisionModelMixin = RevisionModelMixinProtocol | pdt.BaseModel
+
+
 def make_sequence_model_mixin(dialect: str | None = None) -> type[SequenceModelMixin]:
     """
     Creates a mixin class for SQLModel models that adds a unique identifier field ``sqn``.
@@ -457,7 +483,7 @@ def make_sequence_model_mixin(dialect: str | None = None) -> type[SequenceModelM
     :return: A mixin class that can be used with SQLModel models to add the ``sqn`` field.
     """
 
-    class ModelMixin(SQLModel):
+    class ModelMixin(pdt.BaseModel):
         sqn: int | None = Field(
             sa_column=sa.Column(model_sqn_type(dialect), primary_key=True, autoincrement=True),
             default=None,
@@ -477,7 +503,7 @@ def make_changing_model_mixin(dialect: str | None = None) -> type[ChangingModelM
              updatable records.
     """
 
-    class ModelMixin(SQLModel):
+    class ModelMixin(pdt.BaseModel):
         sqn: int | None = Field(
             sa_column=sa.Column(model_sqn_type(dialect), primary_key=True, autoincrement=True),
             default=None,
@@ -496,14 +522,14 @@ def make_changing_model_mixin(dialect: str | None = None) -> type[ChangingModelM
 
         @pdt.field_validator("created_at", mode="after")
         @classmethod
-        def validate_created_at(cls, v: datetime.datetime) -> datetime.datetime:
+        def validate_created_at(cls, v: datetime.datetime | None) -> datetime.datetime | None:
             if v is not None:
                 validate_dt_timezone(v)
             return v
 
         @pdt.field_validator("updated_at", mode="after")
         @classmethod
-        def validate_updated_at(cls, v: datetime.datetime) -> datetime.datetime:
+        def validate_updated_at(cls, v: datetime.datetime | None) -> datetime.datetime | None:
             if v is not None:
                 validate_dt_timezone(v)
             return v
@@ -547,7 +573,7 @@ def make_snapshot_model_mixin(dialect: str | None = None) -> type[SnapshotModelM
              record snapshots.
     """
 
-    class ModelMixin(SQLModel):
+    class ModelMixin(pdt.BaseModel):
         sqn: int | None = Field(
             sa_column=sa.Column(model_sqn_type(dialect), primary_key=True, autoincrement=True),
             default=None,
@@ -571,14 +597,14 @@ def make_snapshot_model_mixin(dialect: str | None = None) -> type[SnapshotModelM
 
         @pdt.field_validator("created_at", mode="after")
         @classmethod
-        def validate_created_at(cls, v: datetime.datetime) -> datetime.datetime:
+        def validate_created_at(cls, v: datetime.datetime | None) -> datetime.datetime | None:
             if v is not None:
                 validate_dt_timezone(v)
             return v
 
         @pdt.field_validator("expired_at", mode="after")
         @classmethod
-        def validate_expired_at(cls, v: datetime.datetime) -> datetime.datetime:
+        def validate_expired_at(cls, v: datetime.datetime | None) -> datetime.datetime | None:
             if v is not None:
                 validate_dt_timezone(v)
             return v
@@ -650,7 +676,7 @@ def make_revision_model_mixin(dialect: str | None = None) -> type[RevisionModelM
              record revisions.
     """
 
-    class ModelMixin(SQLModel):
+    class ModelMixin(pdt.BaseModel):
         sqn: int | None = Field(
             sa_column=sa.Column(model_sqn_type(dialect), primary_key=True, autoincrement=True),
             default=None,
@@ -684,28 +710,28 @@ def make_revision_model_mixin(dialect: str | None = None) -> type[RevisionModelM
 
         @pdt.field_validator("created_at", mode="after")
         @classmethod
-        def validate_created_at(cls, v: datetime.datetime) -> datetime.datetime:
+        def validate_created_at(cls, v: datetime.datetime | None) -> datetime.datetime | None:
             if v is not None:
                 validate_dt_timezone(v)
             return v
 
         @pdt.field_validator("updated_at", mode="after")
         @classmethod
-        def validate_updated_at(cls, v: datetime.datetime) -> datetime.datetime:
+        def validate_updated_at(cls, v: datetime.datetime | None) -> datetime.datetime | None:
             if v is not None:
                 validate_dt_timezone(v)
             return v
 
         @pdt.field_validator("expired_at", mode="after")
         @classmethod
-        def validate_expired_at(cls, v: datetime.datetime) -> datetime.datetime:
+        def validate_expired_at(cls, v: datetime.datetime | None) -> datetime.datetime | None:
             if v is not None:
                 validate_dt_timezone(v)
             return v
 
         @pdt.field_validator("revision", mode="after")
         @classmethod
-        def validate_revision(cls, v: int) -> int:
+        def validate_revision(cls, v: int | None) -> int | None:
             if v is not None and not v > 0:
                 raise ValueError("revision number must be positive integer")
             return v
@@ -941,11 +967,12 @@ def clone_sequence_model_instance[SequenceModelT: SequenceModelMixin](
     model: type[SequenceModelT],
     instance: SequenceModelMixin,
     *,
+    validate_only: bool = False,
     clear_meta_fields: bool = True,
-    inplace: bool = False,
 ) -> SequenceModelT:
     result = model.model_validate(instance)
-    result = instance if inplace else result
+    if validate_only:
+        return instance
     if clear_meta_fields:
         result.sqn = None
     return result
@@ -955,11 +982,12 @@ def clone_changing_model_instance[ChangingModelT: ChangingModelMixin](
     model: type[ChangingModelT],
     instance: ChangingModelMixin,
     *,
+    validate_only: bool = False,
     clear_meta_fields: bool = True,
-    inplace: bool = False,
 ) -> ChangingModelT:
     result = model.model_validate(instance)
-    result = instance if inplace else result
+    if validate_only:
+        return instance
     if clear_meta_fields:
         result.sqn = None
         result.created_at = None
@@ -971,11 +999,12 @@ def clone_snapshot_model_instance[SnapshotModelT: SnapshotModelMixin](
     model: type[SnapshotModelT],
     instance: SnapshotModelMixin,
     *,
+    validate_only: bool = False,
     clear_meta_fields: bool = True,
-    inplace: bool = False,
 ) -> SnapshotModelT:
     result = model.model_validate(instance)
-    result = instance if inplace else result
+    if validate_only:
+        return instance
     if clear_meta_fields:
         result.sqn = None
         result.created_at = None
@@ -988,11 +1017,12 @@ def clone_revision_model_instance[RevisionModelT: RevisionModelMixin](
     model: type[RevisionModelT],
     instance: RevisionModelMixin,
     *,
+    validate_only: bool = False,
     clear_meta_fields: bool = True,
-    inplace: bool = False,
 ) -> RevisionModelT:
     result = model.model_validate(instance)
-    result = instance if inplace else result
+    if validate_only:
+        return instance
     if clear_meta_fields:
         result.sqn = None
         result.created_at = None
@@ -1081,7 +1111,7 @@ def db_update_sequence_model[SequenceModelT: SequenceModelMixin](
         raise sa_exc.NoResultFound(f"'{model_name_of(model)}' of specified sqn '{sqn}' not found")
 
     db_instance = model_copy_from(db_instance, clone_sequence_model_instance(model, instance), exclude_none=True)
-    db_instance = clone_sequence_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    clone_sequence_model_instance(model, db_instance, validate_only=True)
     db.flush()
 
     return db_instance
@@ -1146,7 +1176,7 @@ def db_update_changing_model[ChangingModelT: ChangingModelMixin](
 
     db_instance = model_copy_from(db_instance, clone_changing_model_instance(model, instance), exclude_none=True)
     db_instance.updated_at = updated_at
-    db_instance = clone_changing_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    clone_changing_model_instance(model, db_instance, validate_only=True)
     db.flush()
 
     return db_instance
@@ -1304,13 +1334,14 @@ def db_update_snapshot_model[SnapshotModelT: SnapshotModelMixin](
         raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_instance.expired_at = updated_at
-    db_instance = clone_snapshot_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    clone_snapshot_model_instance(model, db_instance, validate_only=True)
     db.flush()
 
     db_new_instance = clone_snapshot_model_instance(model, instance)
     db_new_instance.record_sqn = record_sqn
     db_new_instance.created_at = updated_at
     db_new_instance.expired_at = None
+    clone_snapshot_model_instance(model, db_new_instance, validate_only=True)
     db.add(db_new_instance)
     db.flush()
 
@@ -1333,7 +1364,7 @@ def db_expire_snapshot_model[SnapshotModelT: SnapshotModelMixin](
         raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_instance.expired_at = updated_at
-    db_instance = clone_snapshot_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    clone_snapshot_model_instance(model, db_instance, validate_only=True)
     db.flush()
 
     return db_instance
@@ -1364,9 +1395,10 @@ def db_activate_snapshot_model[SnapshotModelT: SnapshotModelMixin](
     db_new_instance.record_sqn = record_sqn
     db_new_instance.created_at = db_instance.expired_at
     db_new_instance.expired_at = updated_at
-    db_new_instance = clone_snapshot_model_instance(model, db_new_instance, clear_meta_fields=False, inplace=True)
+    clone_snapshot_model_instance(model, db_new_instance, validate_only=True)
     db_new_instance.created_at = updated_at
     db_new_instance.expired_at = None
+    clone_snapshot_model_instance(model, db_new_instance, validate_only=True)
     db.add(db_new_instance)
     db.flush()
 
@@ -1529,7 +1561,7 @@ def db_update_revision_model[RevisionModelT: RevisionModelMixin](
         raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_instance.expired_at = updated_at
-    db_instance = clone_revision_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    clone_revision_model_instance(model, db_instance, validate_only=True)
     db.flush()
 
     db_new_instance = clone_revision_model_instance(model, instance)
@@ -1538,6 +1570,7 @@ def db_update_revision_model[RevisionModelT: RevisionModelMixin](
     db_new_instance.updated_at = updated_at
     db_new_instance.expired_at = None
     db_new_instance.revision = db_instance.revision + 1
+    clone_revision_model_instance(model, db_new_instance, validate_only=True)
     db.add(db_new_instance)
     db.flush()
 
@@ -1560,7 +1593,7 @@ def db_expire_revision_model[RevisionModelT: RevisionModelMixin](
         raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_instance.expired_at = updated_at
-    db_instance = clone_revision_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    clone_revision_model_instance(model, db_instance, validate_only=True)
     db.flush()
 
     return db_instance
@@ -1593,9 +1626,10 @@ def db_activate_revision_model[RevisionModelT: RevisionModelMixin](
     db_new_instance.updated_at = db_instance.expired_at
     db_new_instance.expired_at = updated_at
     db_new_instance.revision = db_instance.revision + 1
-    db_new_instance = clone_revision_model_instance(model, db_new_instance, clear_meta_fields=False, inplace=True)
+    clone_revision_model_instance(model, db_new_instance, validate_only=True)
     db_new_instance.updated_at = updated_at
     db_new_instance.expired_at = None
+    clone_revision_model_instance(model, db_new_instance, validate_only=True)
     db.add(db_new_instance)
     db.flush()
 

{plexus_python_common-1.0.65 → plexus_python_common-1.0.67}/src/plexus/common/utils/tagutils.py

@@ -27,12 +27,13 @@ from iker.common.utils.iterutils import dicttree_children, dicttree_lineage, dic
 from iker.common.utils.jsonutils import JsonObject, JsonType
 from iker.common.utils.randutils import randomizer
 from iker.common.utils.strutils import is_blank
-from sqlmodel import Field, SQLModel
+from sqlmodel import Field
 
 from plexus.common.resources.tags import predefined_tagset_specs
 from plexus.common.utils.datautils import validate_colon_tag, validate_snake_case, validate_vehicle_name
 from plexus.common.utils.datautils import validate_dt_timezone, validate_semver, validate_slash_tag
 from plexus.common.utils.jsonutils import json_datetime_encoder
+from plexus.common.utils.ormutils import SQLiteDateTime
 from plexus.common.utils.ormutils import SequenceModelMixinProtocol
 from plexus.common.utils.ormutils import clone_sequence_model_instance, make_base_model, make_sequence_model_mixin
 from plexus.common.utils.sqlutils import escape_sql_like
@@ -45,6 +46,8 @@ __all__ = [
     "populate_tagset",
     "predefined_tagsets",
     "render_tagset_markdown_readme",
+    "make_tag_target_model_mixin",
+    "make_tag_record_model_mixin",
     "TagTarget",
     "TagRecord",
     "TagTargetTable",
@@ -375,173 +378,187 @@ def render_tagset_markdown_readme(tagset: Tagset) -> str:
     return env.from_string(template_str).render(tagset=tagset)
 
 
-BaseModel = make_base_model()
-
-
-class TagTarget(BaseModel):
-    identifier: str = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(256), nullable=False, unique=True),
-        description="Identifier of the tag target",
-    )
-    tagger_name: str = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=False),
-        description="Name of the tagger that generates the tag records for the target",
-    )
-    tagger_version: str = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(32), nullable=False),
-        description="Version of the tagger that generates the tag records for the target",
-    )
-    vehicle_name: str = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=False),
-        description="Vehicle name associated with the tag record",
-    )
-    begin_dt: datetime.datetime = Field(
-        sa_column=sa.Column(sa_sqlite.TIMESTAMP, nullable=False),
-        description="Begin datetime of the target range associated with the tag record",
-    )
-    end_dt: datetime.datetime = Field(
-        sa_column=sa.Column(sa_sqlite.TIMESTAMP, nullable=False),
-        description="End datetime of the target range associated with the tag record",
-    )
-
-    @pdt.field_validator("identifier", mode="after")
-    @classmethod
-    def validate_identifier(cls, v: str) -> str:
-        validate_slash_tag(v)
-        return v
-
-    @pdt.field_validator("tagger_name", mode="after")
-    @classmethod
-    def validate_tagger_name(cls, v: str) -> str:
-        validate_snake_case(v)
-        return v
-
-    @pdt.field_validator("tagger_version", mode="after")
-    @classmethod
-    def validate_tagger_version(cls, v: str) -> str:
-        validate_semver(v)
-        return v
-
-    @pdt.field_validator("vehicle_name", mode="after")
-    @classmethod
-    def validate_vehicle_name(cls, v: str) -> str:
-        validate_vehicle_name(v)
-        return v
-
-    @pdt.field_validator("begin_dt", mode="after")
-    @classmethod
-    def validate_begin_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        validate_dt_timezone(v, allow_naive=True)
-        return v
-
-    @pdt.field_validator("end_dt", mode="after")
-    @classmethod
-    def validate_end_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        validate_dt_timezone(v, allow_naive=True)
-        return v
-
-    @pdt.model_validator(mode="after")
-    def validate_begin_dt_end_dt(self) -> Self:
-        if self.begin_dt > self.end_dt:
-            raise ValueError(f"begin_dt '{self.begin_dt}' is greater than end_dt '{self.end_dt}'")
-        return self
+def make_tag_target_model_mixin() -> type[pdt.BaseModel]:
+    class ModelMixin(pdt.BaseModel):
+        identifier: str = Field(
+            sa_column=sa.Column(sa_sqlite.VARCHAR(256), nullable=False, unique=True),
+            description="Identifier of the tag target",
+        )
+        tagger_name: str = Field(
+            sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=False),
+            description="Name of the tagger that generates the tag records for the target",
+        )
+        tagger_version: str = Field(
+            sa_column=sa.Column(sa_sqlite.VARCHAR(32), nullable=False),
+            description="Version of the tagger that generates the tag records for the target",
+        )
+        vehicle_name: str = Field(
+            sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=False),
+            description="Vehicle name associated with the tag record",
+        )
+        begin_dt: datetime.datetime = Field(
+            sa_column=sa.Column(SQLiteDateTime, nullable=False),
+            description="Begin datetime of the target range associated with the tag record",
+        )
+        end_dt: datetime.datetime = Field(
+            sa_column=sa.Column(SQLiteDateTime, nullable=False),
+            description="End datetime of the target range associated with the tag record",
+        )
 
-    @pdt.field_serializer("begin_dt", mode="plain")
-    def serialize_begin_dt(self, v: datetime.datetime) -> str:
-        return json_datetime_encoder(v)
+        @pdt.field_validator("identifier", mode="after")
+        @classmethod
+        def validate_identifier(cls, v: str) -> str:
+            validate_slash_tag(v)
+            return v
 
-    @pdt.field_serializer("end_dt", mode="plain")
-    def serialize_end_dt(self, v: datetime.datetime) -> str:
-        return json_datetime_encoder(v)
+        @pdt.field_validator("tagger_name", mode="after")
+        @classmethod
+        def validate_tagger_name(cls, v: str) -> str:
+            validate_snake_case(v)
+            return v
 
+        @pdt.field_validator("tagger_version", mode="after")
+        @classmethod
+        def validate_tagger_version(cls, v: str) -> str:
+            validate_semver(v)
+            return v
+
+        @pdt.field_validator("vehicle_name", mode="after")
+        @classmethod
+        def validate_vehicle_name(cls, v: str) -> str:
+            validate_vehicle_name(v)
+            return v
+
+        @pdt.field_validator("begin_dt", mode="after")
+        @classmethod
+        def validate_begin_dt(cls, v: datetime.datetime) -> datetime.datetime:
+            validate_dt_timezone(v)
+            return v
+
+        @pdt.field_validator("end_dt", mode="after")
+        @classmethod
+        def validate_end_dt(cls, v: datetime.datetime) -> datetime.datetime:
+            validate_dt_timezone(v)
+            return v
+
+        @pdt.model_validator(mode="after")
+        def validate_begin_dt_end_dt(self) -> Self:
+            if self.begin_dt > self.end_dt:
+                raise ValueError(f"begin_dt '{self.begin_dt}' is greater than end_dt '{self.end_dt}'")
+            return self
+
+        @pdt.field_serializer("begin_dt", mode="plain")
+        def serialize_begin_dt(self, v: datetime.datetime) -> str:
+            return json_datetime_encoder(v)
+
+        @pdt.field_serializer("end_dt", mode="plain")
+        def serialize_end_dt(self, v: datetime.datetime) -> str:
+            return json_datetime_encoder(v)
+
+    return ModelMixin
+
+
+def make_tag_record_model_mixin() -> type[pdt.BaseModel]:
+    class ModelMixin(pdt.BaseModel):
+        target_sqn: int = Field(
+            sa_column=sa.Column(sa_sqlite.INTEGER, nullable=False),
+            description="Sequence number of the tag record's target",
+        )
+        begin_dt: datetime.datetime = Field(
+            sa_column=sa.Column(SQLiteDateTime, nullable=False),
+            description="Begin datetime of the tag record",
+        )
+        end_dt: datetime.datetime = Field(
+            sa_column=sa.Column(SQLiteDateTime, nullable=False),
+            description="End datetime of the tag record",
+        )
+        tagset_namespace: str | None = Field(
+            sa_column=sa.Column(sa_sqlite.VARCHAR(64), nullable=True),
+            default=None,
+            description="Namespace of the tagset that the tag belongs to",
+        )
+        tagset_version: str | None = Field(
+            sa_column=sa.Column(sa_sqlite.VARCHAR(32), nullable=True),
+            default=None,
+            description="Version of the tagset that the tag belongs to",
+        )
+        tag: str = Field(
+            sa_column=sa.Column(sa_sqlite.VARCHAR(256), nullable=False),
+            description="Tag name",
+        )
+        props: JsonType | None = Field(
+            sa_column=sa.Column(sa_sqlite.JSON, nullable=True),
+            default=None,
+            description="Additional properties of the tag record in JSON format",
+        )
+        flags: int = Field(
+            sa_column=sa.Column(sa_sqlite.INTEGER),
+            default=0,
+            description="Integer bitmask storing status or metadata flags for this tag record",
+        )
 
-class TagRecord(BaseModel):
-    target_sqn: int = Field(
-        sa_column=sa.Column(sa_sqlite.INTEGER, nullable=False),
-        description="Sequence number of the tag record's target",
-    )
-    begin_dt: datetime.datetime = Field(
-        sa_column=sa.Column(sa_sqlite.TIMESTAMP, nullable=False),
-        description="Begin datetime of the tag record",
-    )
-    end_dt: datetime.datetime = Field(
-        sa_column=sa.Column(sa_sqlite.TIMESTAMP, nullable=False),
-        description="End datetime of the tag record",
-    )
-    tagset_namespace: str | None = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(64), nullable=True),
-        default=None,
-        description="Namespace of the tagset that the tag belongs to",
-    )
-    tagset_version: str | None = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(32), nullable=True),
-        default=None,
-        description="Version of the tagset that the tag belongs to",
-    )
-    tag: str = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(256), nullable=False),
-        description="Tag name",
-    )
-    props: JsonType | None = Field(
-        sa_column=sa.Column(sa_sqlite.JSON, nullable=True),
-        default=None,
-        description="Additional properties of the tag record in JSON format",
-    )
-    flags: int = Field(
-        sa_column=sa.Column(sa_sqlite.INTEGER),
-        default=0,
-        description="Integer bitmask storing status or metadata flags for this tag record",
-    )
+        @pdt.field_validator("begin_dt", mode="after")
+        @classmethod
+        def validate_begin_dt(cls, v: datetime.datetime) -> datetime.datetime:
+            validate_dt_timezone(v)
+            return v
+
+        @pdt.field_validator("end_dt", mode="after")
+        @classmethod
+        def validate_end_dt(cls, v: datetime.datetime) -> datetime.datetime:
+            validate_dt_timezone(v)
+            return v
+
+        @pdt.field_validator("tagset_namespace", mode="after")
+        @classmethod
+        def validate_tagset_namespace(cls, v: str | None) -> str | None:
+            if v is not None:
+                validate_snake_case(v)
+            return v
+
+        @pdt.field_validator("tagset_version", mode="after")
+        @classmethod
+        def validate_tagset_version(cls, v: str | None) -> str | None:
+            if v is not None:
+                validate_semver(v)
+            return v
+
+        @pdt.model_validator(mode="after")
+        def validate_begin_dt_end_dt(self) -> Self:
+            if self.begin_dt > self.end_dt:
+                raise ValueError(f"begin_dt '{self.begin_dt}' is greater than end_dt '{self.end_dt}'")
+            return self
+
+        @pdt.field_validator("tag", mode="after")
+        @classmethod
+        def validate_tag(cls, v: str) -> str:
+            validate_colon_tag(v)
+            return v
+
+        @pdt.field_serializer("begin_dt", mode="plain")
+        def serialize_begin_dt(self, v: datetime.datetime) -> str:
+            return json_datetime_encoder(v)
+
+        @pdt.field_serializer("end_dt", mode="plain")
+        def serialize_end_dt(self, v: datetime.datetime) -> str:
+            return json_datetime_encoder(v)
+
+    return ModelMixin
 
-    @pdt.field_validator("begin_dt", mode="after")
-    @classmethod
-    def validate_begin_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        validate_dt_timezone(v, allow_naive=True)
-        return v
-
-    @pdt.field_validator("end_dt", mode="after")
-    @classmethod
-    def validate_end_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        validate_dt_timezone(v, allow_naive=True)
-        return v
-
-    @pdt.field_validator("tagset_namespace", mode="after")
-    @classmethod
-    def validate_tagset_namespace(cls, v: str | None) -> str | None:
-        if v is not None:
-            validate_snake_case(v)
-        return v
 
-    @pdt.field_validator("tagset_version", mode="after")
-    @classmethod
-    def validate_tagset_version(cls, v: str | None) -> str | None:
-        if v is not None:
-            validate_semver(v)
-        return v
+BaseModel = make_base_model()
 
-    @pdt.model_validator(mode="after")
-    def validate_begin_dt_end_dt(self) -> Self:
-        if self.begin_dt > self.end_dt:
-            raise ValueError(f"begin_dt '{self.begin_dt}' is greater than end_dt '{self.end_dt}'")
-        return self
 
-    @pdt.field_validator("tag", mode="after")
-    @classmethod
-    def validate_tag(cls, v: str) -> str:
-        validate_colon_tag(v)
-        return v
+class TagTarget(BaseModel, make_tag_target_model_mixin()):
+    pass
 
-    @pdt.field_serializer("begin_dt", mode="plain")
-    def serialize_begin_dt(self, v: datetime.datetime) -> str:
-        return json_datetime_encoder(v)
 
-    @pdt.field_serializer("end_dt", mode="plain")
-    def serialize_end_dt(self, v: datetime.datetime) -> str:
-        return json_datetime_encoder(v)
+class TagRecord(BaseModel, make_tag_record_model_mixin()):
+    pass
 
 
 class TagTargetTable(TagTarget, make_sequence_model_mixin("sqlite"), table=True):
-    __tablename__ = "tag_target_info"
+    __tablename__ = "tag_target"
 
 
 class TagRecordTable(TagRecord, make_sequence_model_mixin("sqlite"), table=True):
@@ -549,7 +566,7 @@ class TagRecordTable(TagRecord, make_sequence_model_mixin("sqlite"), table=True)
 
 
 if typing.TYPE_CHECKING:
-    class TagTargetTable(SQLModel, SequenceModelMixinProtocol):
+    class TagTarget(BaseModel):
         identifier: sa_orm.Mapped[str] = ...
         tagger_name: sa_orm.Mapped[str] = ...
         tagger_version: sa_orm.Mapped[str] = ...
@@ -558,7 +575,11 @@ if typing.TYPE_CHECKING:
         end_dt: sa_orm.Mapped[datetime.datetime] = ...
 
 
-    class TagRecordTable(SQLModel, SequenceModelMixinProtocol):
+    class TagTargetTable(TagTarget, SequenceModelMixinProtocol):
+        pass
+
+
+    class TagRecord(BaseModel):
         target_sqn: sa_orm.Mapped[int] = ...
         begin_dt: sa_orm.Mapped[datetime.datetime] = ...
         end_dt: sa_orm.Mapped[datetime.datetime] = ...
@@ -569,9 +590,13 @@ if typing.TYPE_CHECKING:
         flags: sa_orm.Mapped[int] = ...
 
 
+    class TagRecordTable(TagRecord, SequenceModelMixinProtocol):
+        pass
+
+
 @singleton
 def tag_cache_file_path() -> pathlib.Path:
-    return pathlib.Path.home() / ".local" / "plus" / "datahub" / "tag_cache" / f"{randomizer().random_alphanumeric(7)}.db"
+    return pathlib.Path.home() / ".local" / "plexus" / "tag_cache" / f"{randomizer().random_alphanumeric(7)}.db"
 
 
 class TagCache(object):
@@ -595,9 +620,13 @@ class TagCache(object):
 
     @contextlib.contextmanager
     def make_session(self) -> Generator[sa_orm.Session, None, None]:
-        with self.thread_lock:
-            with self.conn_maker.make_session() as session:
+        with self.thread_lock, self.conn_maker.make_session(expire_on_commit=False) as session:
+            try:
                 yield session
+                session.commit()
+            except Exception:
+                session.rollback()
+                raise
 
     def get_target(self, target: int | str) -> TagTargetTable | None:
         with self.make_session() as session:
@@ -1019,7 +1048,6 @@ class TargetedTagCache(object):
             session.add(db_tag_record)
             session.commit()
 
-            session.refresh(db_tag_record)
             return chainable(self, db_tag_record)
 
     def add_tag(
@@ -1104,7 +1132,6 @@ class TargetedTagCache(object):
 
             session.commit()
 
-            session.refresh(db_tag_record)
             return chainable(self, db_tag_record)
 
     def remove_tags(
@@ -1158,7 +1185,7 @@ class TargetedTagCache(object):
 
 
 @memorized
-def tag_cache(*, identifier: str | None = None, file_path: str | None = None) -> TagCache:
+def tag_cache(*, identifier: str | None = None, file_path: str | os.PathLike[str] | None = None) -> TagCache:
     """
     Get a ``TagCache`` instance associated with the given identifier. If the identifier is ``None``, return a
     ``TagCache`` instance associated with a default file path. Otherwise, validate the identifier as a snake case

{plexus_python_common-1.0.65 → plexus_python_common-1.0.67}/src/plexus/common/utils/testutils.py

@@ -116,6 +116,7 @@ def patched_postgresql_session_maker(
     base_model: type[SQLModel],
     app: FastAPI,
     session_maker: Callable[[], Generator[sa_orm.Session]],
+    **kwargs,
 ) -> Callable[[pytest.FixtureRequest], Generator[Callable[[], Iterator[sa_orm.Session]]]]:
     """
     Create a pytest fixture that provides a patched session maker for PostgreSQL tests.
@@ -141,7 +142,7 @@ def patched_postgresql_session_maker(
         )
 
         def make_session_maker() -> Iterator[sa_orm.Session]:
-            with cm.make_session(autocommit=False, autoflush=False) as db:
+            with cm.make_session(**kwargs) as db:
                 try:
                     # language=postgresql
                     db.execute(sa.sql.text("SET TIMEZONE TO 'UTC'"))

{plexus_python_common-1.0.65 → plexus_python_common-1.0.67}/src/plexus_python_common.egg-info/PKG-INFO

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