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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.66
+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.66 → plexus_python_common-1.0.67}/src/plexus/common/utils/ormutils.py

@@ -468,10 +468,10 @@ def model_revision_type(dialect: str | None = None) -> sa.types.TypeEngine[int]:
 
 # 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
+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]:
@@ -483,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,
@@ -503,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,
@@ -573,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,
@@ -676,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,

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

@@ -27,7 +27,7 @@ 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
@@ -46,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",
@@ -376,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(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_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)
-        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
+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(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",
-    )
+        @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)
-        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
+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):
@@ -550,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] = ...
@@ -559,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] = ...
@@ -570,6 +590,10 @@ 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" / "plexus" / "tag_cache" / f"{randomizer().random_alphanumeric(7)}.db"

{plexus_python_common-1.0.66 → 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.66
+Version: 1.0.67
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13