plexus-python-common 1.0.54__tar.gz → 1.0.55__tar.gz

{plexus_python_common-1.0.54 → plexus_python_common-1.0.55}/PKG-INFO

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

{plexus_python_common-1.0.54 → plexus_python_common-1.0.55}/src/plexus/common/utils/ormutils.py

@@ -1,4 +1,5 @@
 import datetime
+from collections.abc import Iterable, Sequence
 from typing import Protocol, Self
 
 import pydantic as pdt
@@ -7,7 +8,8 @@ import sqlalchemy.dialects.postgresql as sa_pg
 import sqlalchemy.dialects.sqlite as sa_sqlite
 import sqlalchemy.exc as sa_exc
 import sqlalchemy.orm as sa_orm
-from iker.common.utils.dbutils import dialects
+from iker.common.utils.dbutils import dialects, orm_to_dict
+from iker.common.utils.iterutils import head
 from sqlmodel import Field, SQLModel
 
 from plexus.common.utils.datautils import validate_dt_timezone
@@ -17,6 +19,7 @@ __all__ = [
     "compare_postgresql_types",
     "compare_sqlite_types",
     "model_name_of",
+    "print_model_results",
     "validate_model_extended",
     "collect_model_tables",
     "model_copy_from",
@@ -137,13 +140,56 @@ def compare_sqlite_types(type_a, type_b) -> bool:
     }
 
 
-def model_name_of(model: type[SQLModel], fallback_classname: bool = True) -> str | None:
+def model_name_of(model: type[SQLModel] | SQLModel, fallback_classname: bool = True) -> str | None:
     table_name = getattr(model, "__tablename__")
-    if not table_name:
-        return model.__name__ if fallback_classname else None
+    if not table_name and fallback_classname:
+        return getattr(model, "__name__") if isinstance(model, type) else getattr(model.__class__, "__name__")
     return table_name
 
 
+def print_model_results(results: Iterable[SQLModel | Sequence[SQLModel]]):
+    """
+    Pretty-print an iterable of ``SQLModel`` instances or sequences of ``SQLModel`` instances in a tabular format
+    using the ``rich`` library.
+
+    :param results: An iterable of ``SQLModel`` instances or sequences of ``SQLModel`` instances to print.
+    """
+    results = list(results)
+    if not results:
+        print("Query results: (empty)")
+        return
+
+    first_result = head(results)
+
+    cols = [f"{model_name_of(db_model)}.{key}"
+            for db_model in (first_result if isinstance(first_result, Sequence) else [first_result])
+            for key in orm_to_dict(db_model).keys()]
+
+    rows = [
+        {f"{model_name_of(db_model)}.{key}": str(value)
+         for db_model in (result if isinstance(result, Sequence) else (result,))
+         for key, value in orm_to_dict(db_model).items()}
+        for result in results
+    ]
+
+    col_widths = [len(col) for col in cols]
+    for row in rows:
+        for i, col in enumerate(cols):
+            col_widths[i] = max(col_widths[i], len(str(row.get(col, ""))))
+
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console()
+    table = Table(show_header=True)
+    for col, col_width in zip(cols, col_widths):
+        table.add_column(col, min_width=col_width)
+    for row in rows:
+        table.add_row(*[str(row.get(col)) for col in cols])
+
+    console.print(table, crop=False)
+
+
 def validate_model_extended(model_base: type[SQLModel], model_extended: type[SQLModel]) -> bool:
     """
     Validates if ``model_extended`` is an extension of ``model_base`` by checking if all fields in ``model_base``

{plexus_python_common-1.0.54 → plexus_python_common-1.0.55}/src/plexus/common/utils/tagutils.py

@@ -40,9 +40,9 @@ __all__ = [
     "populate_tagset",
     "predefined_tagsets",
     "render_tagset_markdown_readme",
-    "TagTargetInfo",
+    "TagTarget",
     "TagRecord",
-    "TagTargetInfoTable",
+    "TagTargetTable",
     "TagRecordTable",
     "tag_cache_file_path",
     "TagCache",
@@ -295,10 +295,10 @@ def render_tagset_markdown_readme(tagset: Tagset) -> str:
 BaseModel = make_base_model()
 
 
-class TagTargetInfo(BaseModel):
-    name: str = Field(
+class TagTarget(BaseModel):
+    identifier: str = Field(
         sa_column=sa.Column(sa_sqlite.VARCHAR(256), nullable=False, unique=True),
-        description="Name of the tag target",
+        description="Identifier of the tag target",
     )
     tagger_name: str = Field(
         sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=False),
@@ -321,9 +321,9 @@ class TagTargetInfo(BaseModel):
         description="End datetime of the target range associated with the tag record",
     )
 
-    @pdt.field_validator("name", mode="after")
+    @pdt.field_validator("identifier", mode="after")
     @classmethod
-    def validate_name(cls, v: str) -> str:
+    def validate_identifier(cls, v: str) -> str:
         validate_slash_tag(v)
         return v
 
@@ -412,7 +412,7 @@ class TagRecord(BaseModel):
         return v
 
 
-class TagTargetInfoTable(TagTargetInfo, make_sequence_model_mixin("sqlite"), table=True):
+class TagTargetTable(TagTarget, make_sequence_model_mixin("sqlite"), table=True):
     __tablename__ = "tag_target_info"
 
 
@@ -421,8 +421,8 @@ class TagRecordTable(TagRecord, make_sequence_model_mixin("sqlite"), table=True)
 
 
 if typing.TYPE_CHECKING:
-    class TagTargetInfoTable(SQLModel, SequenceModelMixinProtocol):
-        name: sa_orm.Mapped[str] = ...
+    class TagTargetTable(SQLModel, SequenceModelMixinProtocol):
+        identifier: sa_orm.Mapped[str] = ...
         tagger_name: sa_orm.Mapped[str] = ...
         tagger_version: sa_orm.Mapped[str] = ...
         vehicle_name: sa_orm.Mapped[str] = ...
@@ -468,63 +468,63 @@ class TagCache(object):
             with self.conn_maker.make_session() as session:
                 yield session
 
-    def get_target(self, name: str) -> TagTargetInfoTable | None:
+    def get_target(self, identifier: str) -> TagTargetTable | None:
         with self.make_session() as session:
-            return session.query(TagTargetInfoTable).filter(TagTargetInfoTable.name == name).one_or_none()
+            return session.query(TagTargetTable).filter(TagTargetTable.identifier == identifier).one_or_none()
 
     def query_targets(
         self,
-        name: str | None = None,
+        identifier: str | None = None,
         tagger_name: str | None = None,
         tagger_version: str | None = None,
         vehicle_name: str | None = None,
         begin_dt: datetime.datetime | None = None,
         end_dt: datetime.datetime | None = None,
-    ) -> list[TagTargetInfoTable]:
+    ) -> list[TagTargetTable]:
         with self.make_session() as session:
-            query = session.query(TagTargetInfoTable)
-            if name:
-                query = query.filter(TagTargetInfoTable.name == name)
+            query = session.query(TagTargetTable)
+            if identifier:
+                query = query.filter(TagTargetTable.identifier == identifier)
             if tagger_name:
-                query = query.filter(TagTargetInfoTable.tagger_name == tagger_name)
+                query = query.filter(TagTargetTable.tagger_name == tagger_name)
             if tagger_version:
-                query = query.filter(TagTargetInfoTable.tagger_version == tagger_version)
+                query = query.filter(TagTargetTable.tagger_version == tagger_version)
             if vehicle_name:
-                query = query.filter(TagTargetInfoTable.vehicle_name == vehicle_name)
+                query = query.filter(TagTargetTable.vehicle_name == vehicle_name)
             if begin_dt:
-                query = query.filter(TagTargetInfoTable.end_dt >= begin_dt)
+                query = query.filter(TagTargetTable.end_dt >= begin_dt)
             if end_dt:
-                query = query.filter(TagTargetInfoTable.begin_dt <= end_dt)
+                query = query.filter(TagTargetTable.begin_dt <= end_dt)
 
             return query.all()
 
     def add_target(
         self,
-        name: str,
+        identifier: str,
         tagger_name: str,
         tagger_version: str,
         vehicle_name: str,
         begin_dt: datetime.datetime,
         end_dt: datetime.datetime,
-    ) -> TagTargetInfoTable:
+    ) -> TagTargetTable:
         with self.make_session() as session:
-            target_info = TagTargetInfo(
-                name=name,
+            target_info = TagTarget(
+                identifier=identifier,
                 tagger_name=tagger_name,
                 tagger_version=tagger_version,
                 vehicle_name=vehicle_name,
                 begin_dt=begin_dt,
                 end_dt=end_dt,
             )
-            db_target_info = clone_sequence_model_instance(TagTargetInfoTable, target_info)
+            db_target_info = clone_sequence_model_instance(TagTargetTable, target_info)
             session.add(db_target_info)
             session.commit()
 
-        return self.get_target(name)
+        return self.get_target(identifier)
 
     def remove_targets(
         self,
-        name: str | None = None,
+        identifier: str | None = None,
         tagger_name: str | None = None,
         tagger_version: str | None = None,
         vehicle_name: str | None = None,
@@ -532,19 +532,19 @@ class TagCache(object):
         end_dt: datetime.datetime | None = None,
     ):
         with self.make_session() as session:
-            query = session.query(TagTargetInfoTable)
-            if name:
-                query = query.filter(TagTargetInfoTable.name == name)
+            query = session.query(TagTargetTable)
+            if identifier:
+                query = query.filter(TagTargetTable.identifier == identifier)
             if tagger_name:
-                query = query.filter(TagTargetInfoTable.tagger_name == tagger_name)
+                query = query.filter(TagTargetTable.tagger_name == tagger_name)
             if tagger_version:
-                query = query.filter(TagTargetInfoTable.tagger_version == tagger_version)
+                query = query.filter(TagTargetTable.tagger_version == tagger_version)
             if vehicle_name:
-                query = query.filter(TagTargetInfoTable.vehicle_name == vehicle_name)
+                query = query.filter(TagTargetTable.vehicle_name == vehicle_name)
             if begin_dt:
-                query = query.filter(TagTargetInfoTable.end_dt >= begin_dt)
+                query = query.filter(TagTargetTable.end_dt >= begin_dt)
             if end_dt:
-                query = query.filter(TagTargetInfoTable.begin_dt <= end_dt)
+                query = query.filter(TagTargetTable.begin_dt <= end_dt)
 
             query.delete()
             session.commit()
@@ -552,7 +552,7 @@ class TagCache(object):
             (
                 session
                 .query(TagRecordTable)
-                .filter(TagRecordTable.target_sqn.notin_(session.query(TagTargetInfoTable.sqn)))
+                .filter(TagRecordTable.target_sqn.notin_(session.query(TagTargetTable.sqn)))
                 .delete()
             )
             session.commit()
@@ -611,7 +611,7 @@ class TagCache(object):
         end_dt: datetime.datetime | None = None,
         tag_pattern: str | None = None,
         *,
-        target_name: str | None = None,
+        target_identifier: str | None = None,
         target_tagger_name: str | None = None,
         target_tagger_version: str | None = None,
         target_vehicle_name: str | None = None,
@@ -620,7 +620,7 @@ class TagCache(object):
         tagsets: Sequence[Tagset] | None = None,
         tagset_inverted: bool = False,
         batch_size: int = 1000,
-    ) -> Generator[tuple[TagRecordTable, TagTargetInfoTable], None, None]:
+    ) -> Generator[tuple[TagRecordTable, TagTargetTable], None, None]:
         """
         Query tag records along with their target info in the cache with optional filters.
 
@@ -628,7 +628,7 @@ class TagCache(object):
         :param end_dt: Filter by end time (inclusive)
         :param tag_pattern: Filter by tag name pattern (SQL LIKE syntax, e.g. "dummy_tag:%" to match all tags starting
         with "dummy_tag:")
-        :param target_name: Filter by target name (exact match)
+        :param target_identifier: Filter by target identifier (exact match)
         :param target_tagger_name: Filter by target tagger name (exact match)
         :param target_tagger_version: Filter by target tagger version (exact match)
         :param target_vehicle_name: Filter by target vehicle name (exact match)
@@ -643,8 +643,8 @@ class TagCache(object):
         with self.make_session() as session:
             query = (
                 session
-                .query(TagRecordTable, TagTargetInfoTable)
-                .join(TagTargetInfoTable, TagRecordTable.target_sqn == TagTargetInfoTable.sqn)
+                .query(TagRecordTable, TagTargetTable)
+                .join(TagTargetTable, TagRecordTable.target_sqn == TagTargetTable.sqn)
             )
             if begin_dt:
                 query = query.filter(TagRecordTable.end_dt >= begin_dt)
@@ -652,18 +652,18 @@ class TagCache(object):
                 query = query.filter(TagRecordTable.begin_dt <= end_dt)
             if tag_pattern:
                 query = query.filter(TagRecordTable.tag.like(f"{escape_sql_like(tag_pattern)}%", escape="\\"))
-            if target_name:
-                query = query.filter(TagTargetInfoTable.name == target_name)
+            if target_identifier:
+                query = query.filter(TagTargetTable.identifier == target_identifier)
             if target_tagger_name:
-                query = query.filter(TagTargetInfoTable.tagger_name == target_tagger_name)
+                query = query.filter(TagTargetTable.tagger_name == target_tagger_name)
             if target_tagger_version:
-                query = query.filter(TagTargetInfoTable.tagger_version == target_tagger_version)
+                query = query.filter(TagTargetTable.tagger_version == target_tagger_version)
             if target_vehicle_name:
-                query = query.filter(TagTargetInfoTable.vehicle_name == target_vehicle_name)
+                query = query.filter(TagTargetTable.vehicle_name == target_vehicle_name)
             if target_begin_dt:
-                query = query.filter(TagTargetInfoTable.end_dt >= target_begin_dt)
+                query = query.filter(TagTargetTable.end_dt >= target_begin_dt)
             if target_end_dt:
-                query = query.filter(TagTargetInfoTable.begin_dt <= target_end_dt)
+                query = query.filter(TagTargetTable.begin_dt <= target_end_dt)
             if tagsets:
                 if tagset_inverted:
                     query = query.filter(
@@ -717,7 +717,7 @@ class TagCache(object):
     def clear(self):
         with self.make_session() as session:
             session.execute(sa.delete(TagRecordTable))
-            session.execute(sa.delete(TagTargetInfoTable))
+            session.execute(sa.delete(TagTargetTable))
             session.commit()
 
     def append_to(self, target_file_path: str, *, overwrite: bool = False):
@@ -740,9 +740,9 @@ class TagCache(object):
             return
 
         with src.make_session() as src_session, dst.make_session() as dst_session:
-            src_targets = src_session.query(TagTargetInfoTable).all()
+            src_targets = src_session.query(TagTargetTable).all()
             dst_targets = [
-                clone_sequence_model_instance(TagTargetInfoTable, db_tag_target_info, clear_meta_fields=True)
+                clone_sequence_model_instance(TagTargetTable, db_tag_target_info, clear_meta_fields=True)
                 for db_tag_target_info in src_targets
             ]
             dst_session.add_all(dst_targets)
@@ -764,14 +764,14 @@ class TagCache(object):
 
 
 class TargetedTagCache(object):
-    def __init__(self, cache: TagCache, target_info: TagTargetInfoTable):
+    def __init__(self, cache: TagCache, target_info: TagTargetTable):
         self.target_info = target_info
         self.cache = cache
 
     @contextlib.contextmanager
     def make_session(self) -> Generator[sa_orm.Session, None, None]:
         with self.cache.make_session() as session:
-            if not session.query(TagTargetInfoTable).filter(TagTargetInfoTable.sqn == self.target_info.sqn).first():
+            if not session.query(TagTargetTable).filter(TagTargetTable.sqn == self.target_info.sqn).first():
                 raise ValueError(f"target info with sqn '{self.target_info.sqn}' is no longer present in cache")
             yield session
 

{plexus_python_common-1.0.54 → plexus_python_common-1.0.55}/src/plexus_python_common.egg-info/PKG-INFO

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