perfact-api-pd 0.2__tar.gz → 0.4__tar.gz

{perfact_api_pd-0.2 → perfact_api_pd-0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perfact-api-pd
-Version: 0.2
+Version: 0.4
 Summary: PerFact API - pd domain models and services
 Author-email: Viktor Dick <viktor.dick@perfact.de>
 License-Expression: GPL-2.0-or-later
@@ -11,9 +11,13 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: psycopg[binary]
 Requires-Dist: sqlalchemy
-Requires-Dist: perfact-api-base-model
+Requires-Dist: perfact-api-base
 Requires-Dist: perfact-api-app
 Requires-Dist: perfact-api-pp
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-postgresql; extra == "test"
 
 # PerFact API - pd - model
 

{perfact_api_pd-0.2 → perfact_api_pd-0.4}/pyproject.toml

@@ -18,13 +18,20 @@ classifiers = [
 dependencies = [
     "psycopg[binary]",
     "sqlalchemy",
-    "perfact-api-base-model",
+    "perfact-api-base",
     "perfact-api-app",
     "perfact-api-pp",
 ]
 dynamic = ["version"]
 requires-python = ">=3.10"
 
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-cov",
+    "pytest-postgresql",
+]
+
 [project.scripts]
 
 [tool.distutils.bdist_wheel]

perfact_api_pd-0.4/src/perfact/api/pd/model/__init__.py

@@ -0,0 +1,30 @@
+from .pdord import PdOrd, PdOrd_TimeStat
+from .pdordhd import PdOrdHd
+from .pdordhdlc import PdOrdHdLc
+from .pdordlc import PdOrdLc
+from .pdordlch import PdOrdLch
+from .pdordlct import PdOrdLct
+from .pdordprd import PdOrdPrd
+from .pdordtype import PdOrdType
+from .pdunit import PdUnit
+from .pdunitgroup import PdUnitGroup
+from .pdunitlc import PdUnitLc
+from .pdunitlch import PdUnitLch
+from .pdunitlct import PdUnitLct
+
+__all__ = [
+    "PdUnit",
+    "PdUnitGroup",
+    "PdUnitLc",
+    "PdUnitLct",
+    "PdUnitLch",
+    "PdOrdLch",
+    "PdOrdLct",
+    "PdOrdLc",
+    "PdOrdPrd",
+    "PdOrd_TimeStat",
+    "PdOrd",
+    "PdOrdHd",
+    "PdOrdHdLc",
+    "PdOrdType",
+]

{perfact_api_pd-0.2 → perfact_api_pd-0.4}/src/perfact/api/pd/model/pdord.py

@@ -12,6 +12,7 @@ from sqlalchemy.orm import mapped_column
 
 class PdOrd(Base):
     # COLS
+    num: Mapped[str]
     planmachinetime: Mapped[timedelta | None] = mapped_column(Interval)
     planstarttime: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     starttime: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
@@ -24,6 +25,7 @@ class PdOrd(Base):
     # FKS
     pdunit_id: Mapped[int | None] = mapped_column(ForeignKey("pdunit.id"))
     pdordlc_id: Mapped[int | None] = mapped_column(ForeignKey("pdordlc.id"))
+    pdordhd_id: Mapped[int | None] = mapped_column(ForeignKey("pdordhd.id"))
     # RELATIONSHIPS
 
 

perfact_api_pd-0.4/src/perfact/api/pd/model/pdordhd.py

@@ -0,0 +1,32 @@
+import datetime
+
+from perfact.api.base.model import Base, ForeignKey, Mapped, relationship
+from sqlalchemy import DateTime
+from sqlalchemy.orm import mapped_column
+
+from .pdordhdlc import PdOrdHdLc
+
+
+class PdOrdHd(Base):
+    num: Mapped[str]
+    pdordhdlc_id: Mapped[int] = mapped_column(ForeignKey("pdordhdlc.id"))
+    overdeliverytol: Mapped[float] = mapped_column(default=0.0)
+    underdeliverytol: Mapped[float] = mapped_column(default=0.0)
+    planstarttime: Mapped[datetime.datetime | None] = mapped_column(
+        DateTime(timezone=True)
+    )
+    planstoptime: Mapped[datetime.datetime | None] = mapped_column(
+        DateTime(timezone=True)
+    )
+    mtart_id: Mapped[int | None]
+    quantity: Mapped[float | None]
+    fileattr_id: Mapped[int | None]
+    pprt_id: Mapped[int | None]
+    description: Mapped[str | None]
+    mtartversion: Mapped[str | None]
+    releasedate: Mapped[datetime.datetime | None] = mapped_column(
+        DateTime(timezone=True)
+    )
+    planreference_pdunit_id: Mapped[int | None] = mapped_column(ForeignKey("pdunit.id"))
+
+    pdordhdlc: Mapped["PdOrdHdLc"] = relationship("PdOrdHdLc")

perfact_api_pd-0.4/src/perfact/api/pd/model/pdordhdlc.py

@@ -0,0 +1,11 @@
+from perfact.api.base.model import Base, Mapped
+from sqlalchemy.orm import mapped_column
+
+
+class PdOrdHdLc(Base):
+    name: Mapped[str]
+    deleted: Mapped[bool] = mapped_column(default=False)
+    isinitial: Mapped[bool] = mapped_column(default=False)
+    lockpdordlc: Mapped[bool] = mapped_column(default=False)
+    description: Mapped[str | None]
+    seqnum: Mapped[int | None]

perfact_api_pd-0.4/src/perfact/api/pd/model/pdordlc.py

@@ -0,0 +1,27 @@
+from perfact.api.base.model import Base, Mapped
+from sqlalchemy.orm import mapped_column
+
+
+class PdOrdLc(Base):
+    name: Mapped[str]
+    seqnum: Mapped[int]
+    allowprovisioning: Mapped[bool] = mapped_column(default=True)
+    deleted: Mapped[bool] = mapped_column(default=False)
+    isinitial: Mapped[bool] = mapped_column(default=False)
+    intermui: Mapped[bool] = mapped_column(default=False)
+    isexecutable: Mapped[bool] = mapped_column(default=False)
+    isdemand: Mapped[bool] = mapped_column(default=False)
+    mayamendbom: Mapped[bool] = mapped_column(default=False)
+    mayassignpdunit: Mapped[bool] = mapped_column(default=True)
+    mayeditplantime: Mapped[bool] = mapped_column(default=True)
+    maysplitoperation: Mapped[bool] = mapped_column(default=False)
+    maystoremtbom: Mapped[bool] = mapped_column(default=False)
+    mayplaninpdunit: Mapped[bool] = mapped_column(default=True)
+    isfinal: Mapped[bool] = mapped_column(default=False)
+    isactive: Mapped[bool] = mapped_column(default=False)
+    isexecution: Mapped[bool] = mapped_column(default=False)
+    issetup: Mapped[bool] = mapped_column(default=False)
+    isdowntime: Mapped[bool] = mapped_column(default=False)
+    mayassigntssm: Mapped[bool] = mapped_column(default=False)
+    showequipmentassign: Mapped[bool] = mapped_column(default=False)
+    description: Mapped[str | None]

{perfact_api_pd-0.2 → perfact_api_pd-0.4}/src/perfact/api/pd/model/pdordlch.py

@@ -25,13 +25,16 @@ class PdOrdLch(Base):
     pdunit_id: Mapped[int | None] = mapped_column(ForeignKey("pdunit.id"))
     pdord_id: Mapped[int] = mapped_column(ForeignKey("pdord.id"))
     pdordlct_id: Mapped[int] = mapped_column(ForeignKey("pdordlct.id"))
+    pdordhd_id: Mapped[int | None] = mapped_column(ForeignKey("pdordhd.id"))
 
     # RELATIONSHIPS
     pdordlct: Mapped["PdOrdLct"] = relationship("PdOrdLct")
     pdord: Mapped["PdOrd"] = relationship("PdOrd")
 
     @hybrid_method
-    def availability_nominator_eligible_def(self, pdunit_id, /) -> bool:
+    def availability_nominator_eligible_def(
+        self, pdunit_id, /
+    ) -> bool:  # pragma: no cover
         """Python level - boils down to check if this operation history
         is linked to the workcenter and represents a status change
         from a status with pdordlc_isexecution"""
@@ -47,7 +50,9 @@ class PdOrdLch(Base):
         )
 
     @hybrid_method
-    def availability_denominator_eligible_def(self, pdunit_id, /) -> bool:
+    def availability_denominator_eligible_def(
+        self, pdunit_id, /
+    ) -> bool:  # pragma: no cover
         """Python level - boils down to check if this operation history
         is linked to the workcenter and represents a status change
         from a status with pdordlc_isactive(True) and pdordlc_isexecution(False)"""

{perfact_api_pd-0.2 → perfact_api_pd-0.4}/src/perfact/api/pd/model/pdordlct.py

@@ -11,6 +11,24 @@ from .pdordlc import PdOrdLc
 
 class PdOrdLct(Base):
     # COLS
+    name: Mapped[str]
+    validate: Mapped[bool] = mapped_column(default=True)
+    deleted: Mapped[bool] = mapped_column(default=False)
+    confirmsummary: Mapped[bool] = mapped_column(default=False)
+    hideinterminalui: Mapped[bool] = mapped_column(default=False)
+    triggeronperiodicsignalfail: Mapped[bool] = mapped_column(default=False)
+    isautocontinue: Mapped[bool] = mapped_column(default=False)
+    checkassignedqty: Mapped[bool] = mapped_column(default=False)
+    confirmunderdelivery: Mapped[bool] = mapped_column(default=False)
+    needsconfirm: Mapped[bool] = mapped_column(default=False)
+    checktoolstatus: Mapped[bool] = mapped_column(default=False)
+    automationsenditreport: Mapped[bool] = mapped_column(default=False)
+    definition: Mapped[str | None]
+    coded: Mapped[bool | None]
+    preference: Mapped[int | None]
+    progname: Mapped[str | None]
+    blpath: Mapped[str | None]
+
     # FKS
     from_pdordlc_id: Mapped[int] = mapped_column(ForeignKey("pdordlc.id"))
     to_pdordlc_id: Mapped[int] = mapped_column(ForeignKey("pdordlc.id"))

{perfact_api_pd-0.2 → perfact_api_pd-0.4}/src/perfact/api/pd/model/pdordprd.py

@@ -2,16 +2,18 @@ from datetime import datetime
 from typing import Any, Literal, cast, overload
 
 from perfact.api.base.model import Base, ForeignKey, Mapped, relationship
+from perfact.api.pp.model import PpRsrc, PpShft
 from psycopg.types.range import Range
 from sqlalchemy import and_, case, func, select
 from sqlalchemy.dialects.postgresql import TSTZRANGE
 from sqlalchemy.ext.hybrid import hybrid_method, hybrid_property
-from sqlalchemy.orm import mapped_column
+from sqlalchemy.orm import Session, mapped_column
 from sqlalchemy.sql import ColumnElement
 from sqlalchemy.sql.elements import SQLCoreOperations
 from sqlalchemy.sql.expression import Extract
 
 from .pdord import PdOrd
+from .pdordlch import PdOrdLch
 
 
 class PdOrdPrd(Base):
@@ -60,7 +62,7 @@ class PdOrdPrd(Base):
         search_range = func.tstzrange(starttime, stoptime, "[)")
         condition = and_(
             cast(Any, cls.refrange).is_not(None),
-            cls.refrange.op("&&")(search_range),
+            cast(Any, cls.refrange).op("&&")(search_range),
         )
         intersection = cls.refrange.op("*")(search_range)
 
@@ -176,31 +178,152 @@ class PdOrdPrd(Base):
         return cls.refrange_intersection(starttime, stoptime, True)
 
     @hybrid_method
-    def performance_eligible_def(self, pdunit_id: int, /) -> bool:
+    def performance_eligible_def(
+        self, pdunit_id: int, starttime: datetime, stoptime: datetime, /
+    ) -> bool:
         """Python-level: check if entry is eligible
         to be taken in account for performance"""
         raise NotImplementedError("Sql expression level only")
 
     @performance_eligible_def.expression
-    def performance_eligible(cls, pdunit_id: int, /) -> ColumnElement[bool]:
+    def performance_eligible(
+        cls, pdunit_id: int, starttime: datetime, stoptime: datetime, /
+    ) -> ColumnElement[bool]:
         """SQL-level: check if entry is eligible
         to be taken in account for performance"""
+        search_range = func.tstzrange(starttime, stoptime, "[)")
         return and_(
             cast(Any, cls.deleted).is_(False),
             cast(Any, cls.pdunit_id) == pdunit_id,
             cast(Any, cls.pdord).has(PdOrd.pdunit_id == pdunit_id),
+            cast(Any, cls.refrange).is_not(None),
+            cast(Any, cls.refrange).op("&&")(search_range),
         )
 
     @hybrid_method
-    def quality_eligible_def(self, pdunit_id: int, /) -> bool:
+    def quality_eligible_def(
+        self, pdunit_id: int, starttime: datetime, stoptime: datetime, /
+    ) -> bool:
         """Python-level: check if entry is eligible
         to be taken in account for quality"""
         raise NotImplementedError("Sql expression level only")
 
     @quality_eligible_def.expression
-    def quality_eligible(cls, pdunit_id: int, /) -> ColumnElement[bool]:
+    def quality_eligible(
+        cls, pdunit_id: int, starttime: datetime, stoptime: datetime, /
+    ) -> ColumnElement[bool]:
         """SQL-level: check if entry is eligible
         to be taken in account for quality"""
+        search_range = func.tstzrange(starttime, stoptime, "[)")
         return and_(
-            cast(Any, cls.deleted).is_(False), cast(Any, cls.pdunit_id) == pdunit_id
+            cast(Any, cls.deleted).is_(False),
+            cast(Any, cls.pdunit_id) == pdunit_id,
+            cast(Any, cls.refrange).is_not(None),
+            cast(Any, cls.refrange).op("&&")(search_range),
         )
+
+    @staticmethod
+    def oee_performance_computation(
+        session: Session, pdunit_id: int, starttime: datetime, stoptime: datetime, /
+    ) -> float:
+        """OEE function for computation of performance."""
+        result = session.execute(
+            select(
+                func.coalesce(
+                    func.sum(PdOrdPrd.ideal_time_over_time_range(starttime, stoptime)),
+                    0.0,
+                )
+                / func.nullif(
+                    func.coalesce(
+                        func.sum(
+                            PdOrdPrd.actual_time_over_time_range(starttime, stoptime)
+                        ),
+                        0.0,
+                    ),
+                    0.0,
+                )
+            ).where(
+                PdOrdPrd.performance_eligible(pdunit_id, starttime, stoptime).is_(True)
+            )
+        ).scalar()
+        return float(result or 0.0)
+
+    @staticmethod
+    def oee_quality_computation(
+        session: Session, pdunit_id: int, starttime: datetime, stoptime: datetime, /
+    ) -> float | None:
+        """OEE function computation for quality. None when no production data."""
+        return session.execute(
+            select(
+                func.coalesce(
+                    func.sum(PdOrdPrd.good_quantity_over_range(starttime, stoptime)),
+                    0.0,
+                )
+                / func.nullif(
+                    func.coalesce(
+                        func.sum(
+                            PdOrdPrd.total_quantity_over_range(starttime, stoptime)
+                        ),
+                        0.0,
+                    ),
+                    0.0,
+                )
+            ).where(PdOrdPrd.quality_eligible(pdunit_id, starttime, stoptime).is_(True))
+        ).scalar()
+
+    @staticmethod
+    def oee_availability_computation(
+        session: Session, pdunit_id: int, starttime: datetime, stoptime: datetime, /
+    ) -> float:
+        """OEE function for computation of availability"""
+        search_range = func.tstzrange(starttime, stoptime)
+        n_intersection = PdOrdLch.lchtimerange.op("*")(search_range)
+        in_seconds = func.extract(
+            "epoch", func.upper(n_intersection) - func.lower(n_intersection)
+        )
+
+        current_available_time_nq = session.scalar(
+            select(
+                PdOrdLch.availability_missing_active_operations_nominator(
+                    pdunit_id, starttime, stoptime
+                )
+            )
+        )
+        current_available_time_n = float(current_available_time_nq or 0.0)
+
+        current_available_time_dq = session.scalar(
+            select(
+                PdOrdLch.availability_missing_active_operations_denominator(
+                    pdunit_id, starttime, stoptime
+                )
+            )
+        )
+        current_available_time_d = float(current_available_time_dq or 0.0)
+
+        # nominator calculation
+        nominator_q = session.execute(
+            select(func.coalesce(func.sum(in_seconds), 0.0))
+            .where(PdOrdLch.availability_nominator_eligible(pdunit_id).is_(True))
+            .where(PdOrdLch.lchtimerange.op("&&")(search_range))
+        ).scalar()
+        nominator = float(nominator_q or 0.0) + current_available_time_n
+
+        # denominator calculation
+        d_intersection = n_intersection.op("*")(PpShft.shiftrange)
+        in_seconds = func.extract(
+            "epoch", func.upper(d_intersection) - func.lower(d_intersection)
+        )
+        denominator_q = session.execute(
+            select(func.coalesce(func.sum(in_seconds), 1.0))
+            .select_from(PdOrdLch)
+            .join(PpRsrc, PpRsrc.pdunit_id == pdunit_id)
+            .join(PpShft, PpShft.pdunit_id == PpRsrc.id)
+            .where(PdOrdLch.availability_denominator_eligible(pdunit_id).is_(True))
+            .where(PdOrdLch.lchtimerange.op("&&")(search_range))
+            .where(n_intersection.op("&&")(PpShft.shiftrange))
+        ).scalar()
+        denominator = nominator + float(denominator_q or 0.0) + current_available_time_d
+
+        availability = nominator / denominator
+
+        return float(availability)

perfact_api_pd-0.4/src/perfact/api/pd/model/pdordtype.py

@@ -0,0 +1,9 @@
+from perfact.api.base.model import Base, Mapped
+from sqlalchemy.orm import mapped_column
+
+
+class PdOrdType(Base):
+    name: Mapped[str]
+    shortcut: Mapped[str]
+    allowemptyclose: Mapped[bool] = mapped_column(default=True)
+    enablewhordreplanning: Mapped[bool] = mapped_column(default=False)

perfact_api_pd-0.4/src/perfact/api/pd/model/pdunit.py

@@ -0,0 +1,69 @@
+from datetime import datetime, timedelta
+
+from perfact.api.base import VisibilityAwareModel
+from perfact.api.base.model import Base, ForeignKey, Mapped, relationship
+from sqlalchemy import Interval, select
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Session, mapped_column
+
+from .pdordlch import PdOrdLch
+from .pdunitgroup import PdUnitGroup
+from .pdunitlc import PdUnitLc
+
+
+class PdUnit(Base, VisibilityAwareModel):
+    modtime: Mapped[datetime]
+    author: Mapped[str]
+    name: Mapped[str | None]
+    num: Mapped[str]
+    overprodmay: Mapped[bool] = mapped_column(default=True)
+    overprodfactor: Mapped[float] = mapped_column(default=1.0)
+    seqnum: Mapped[int | None]
+    strictsequence: Mapped[bool] = mapped_column(default=True)
+    timetrack: Mapped[bool] = mapped_column(default=True)
+    qmreport: Mapped[bool] = mapped_column(default=True)
+    statereport: Mapped[bool] = mapped_column(default=False)
+    wastereport: Mapped[bool] = mapped_column(default=True)
+    propagateuseup: Mapped[bool] = mapped_column(default=True)
+    propagateoutput: Mapped[bool] = mapped_column(default=True)
+    useoutputwhcntr: Mapped[bool] = mapped_column(default=False)
+    maychooseorder: Mapped[bool] = mapped_column(default=True)
+    allowparallelprocessing: Mapped[bool] = mapped_column(default=False)
+    showsetupbarcodes: Mapped[bool] = mapped_column(default=False)
+    periodicsignalcheck: Mapped[bool] = mapped_column(default=False)
+    perscapacity: Mapped[int] = mapped_column(default=1)
+    output_whobjlc_id: Mapped[int] = mapped_column(default=1)
+    autoreportgood: Mapped[bool] = mapped_column(default=False)
+    autoreportnone: Mapped[bool] = mapped_column(default=False)
+    whloc_id: Mapped[int | None]
+    periodicsignalextfactor: Mapped[float | None]
+    mincycletime: Mapped[timedelta | None] = mapped_column(Interval)
+    input_whloc_id: Mapped[int | None]
+    extref: Mapped[dict | None] = mapped_column(JSONB)
+    fileattr_id: Mapped[int | None]
+    tssubjectmatter_id: Mapped[int | None]
+    pdplant_id: Mapped[int | None]
+
+    # FKS
+    pdunitgroup_id: Mapped[int | None] = mapped_column(ForeignKey("pdunitgroup.id"))
+    pdunitlc_id: Mapped[int | None] = mapped_column(ForeignKey("pdunitlc.id"))
+
+    # RELATIONSHIPS
+    pdunitgroup: Mapped[PdUnitGroup | None] = relationship("PdUnitGroup")
+    pdunitlc: Mapped[PdUnitLc | None] = relationship("PdUnitLc")
+
+    def get_last_pdordlch_entry_for_timestamp(
+        self, session: Session, timestamp: datetime
+    ) -> PdOrdLch | None:
+        """Return the most recent PdOrdLch entry for this unit at or before `timestamp`.
+
+        Queries the DB with LIMIT 1 instead of loading the full relationship,
+        so memory usage is O(1) regardless of history size.
+        """
+        return session.scalars(
+            select(PdOrdLch)
+            .where(PdOrdLch.pdunit_id == self.id)
+            .where(PdOrdLch.createtime <= timestamp)
+            .order_by(PdOrdLch.createtime.desc())
+            .limit(1)
+        ).first()

perfact_api_pd-0.4/src/perfact/api/pd/model/pdunitgroup.py

@@ -0,0 +1,25 @@
+from perfact.api.base.model import Base, ForeignKey, Mapped, relationship
+from sqlalchemy.orm import mapped_column
+
+
+class PdUnitGroup(Base):
+    name: Mapped[str]
+    num: Mapped[str]
+    whsite_id: Mapped[int]
+    sharedorders: Mapped[bool] = mapped_column(default=False)
+    deleted: Mapped[bool] = mapped_column(default=False)
+    whloc_id: Mapped[int | None]
+    parent_pdunitgroup_id: Mapped[int | None] = mapped_column(
+        ForeignKey("pdunitgroup.id")
+    )
+
+    parent: Mapped["PdUnitGroup | None"] = relationship(
+        "PdUnitGroup",
+        foreign_keys="[PdUnitGroup.parent_pdunitgroup_id]",
+        back_populates="children",
+        remote_side="[PdUnitGroup.id]",
+    )
+    children: Mapped[list["PdUnitGroup"]] = relationship(
+        "PdUnitGroup",
+        back_populates="parent",
+    )

perfact_api_pd-0.4/src/perfact/api/pd/model/pdunitlc.py

@@ -0,0 +1,10 @@
+from perfact.api.base.model import Base, Mapped
+from sqlalchemy.orm import mapped_column
+
+
+class PdUnitLc(Base):
+    name: Mapped[str]
+    deleted: Mapped[bool] = mapped_column(default=False)
+    isinitial: Mapped[bool] = mapped_column(default=False)
+    description: Mapped[str | None]
+    seqnum: Mapped[int | None]

perfact_api_pd-0.4/src/perfact/api/pd/model/pdunitlch.py

@@ -0,0 +1,24 @@
+import datetime
+
+from perfact.api.base.model import Base, ForeignKey, Mapped, relationship
+from sqlalchemy import DateTime, Interval
+from sqlalchemy.orm import mapped_column
+
+from .pdunit import PdUnit
+from .pdunitlct import PdUnitLct
+
+
+class PdUnitLch(Base):
+    # COLS
+    createtime: Mapped[datetime.datetime] = mapped_column(
+        DateTime(timezone=True), default=datetime.datetime.now
+    )
+    lchtimespent: Mapped[datetime.timedelta | None] = mapped_column(Interval)
+
+    # FKS
+    pdunit_id: Mapped[int] = mapped_column(ForeignKey("pdunit.id"))
+    pdunitlct_id: Mapped[int] = mapped_column(ForeignKey("pdunitlct.id"))
+
+    # RELATIONSHIPS
+    pdunit: Mapped[PdUnit] = relationship("PdUnit")
+    pdunitlct: Mapped[PdUnitLct] = relationship("PdUnitLct")

perfact_api_pd-0.4/src/perfact/api/pd/model/pdunitlct.py

@@ -0,0 +1,25 @@
+from perfact.api.base.model import Base, ForeignKey, Mapped, relationship
+from sqlalchemy.orm import mapped_column
+
+from .pdunitlc import PdUnitLc
+
+
+class PdUnitLct(Base):
+    name: Mapped[str]
+    from_pdunitlc_id: Mapped[int] = mapped_column(ForeignKey("pdunitlc.id"))
+    to_pdunitlc_id: Mapped[int] = mapped_column(ForeignKey("pdunitlc.id"))
+    validate: Mapped[bool] = mapped_column(default=True)
+    deleted: Mapped[bool] = mapped_column(default=False)
+    hideinofficeui: Mapped[bool] = mapped_column(default=False)
+    definition: Mapped[str | None]
+    coded: Mapped[bool | None]
+    preference: Mapped[int | None]
+    progname: Mapped[str | None]
+    blpath: Mapped[str | None]
+
+    from_pdunitlc: Mapped["PdUnitLc"] = relationship(
+        "PdUnitLc", foreign_keys=[from_pdunitlc_id]
+    )
+    to_pdunitlc: Mapped["PdUnitLc"] = relationship(
+        "PdUnitLc", foreign_keys=[to_pdunitlc_id]
+    )

perfact_api_pd-0.4/src/perfact/api/pd/services/__init__.py

@@ -0,0 +1,16 @@
+from .pdunitlch import UnitLchHistoryEntry, get_unit_lch_history
+from .pdunitperformance_orm import (
+    get_time_performance_data_v2,
+    get_time_performance_data_v3,
+    get_time_performance_data_v4,
+)
+from .pdunitperformance_plainsql import get_time_performance_data
+
+__all__ = [
+    "UnitLchHistoryEntry",
+    "get_unit_lch_history",
+    "get_time_performance_data",
+    "get_time_performance_data_v2",
+    "get_time_performance_data_v3",
+    "get_time_performance_data_v4",
+]