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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perfact-api-pd
-Version: 0.2
+Version: 0.3
 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.3}/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.2 → perfact_api_pd-0.3}/src/perfact/api/pd/model/pdordlch.py

@@ -31,7 +31,9 @@ class PdOrdLch(Base):
     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 +49,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.3}/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.3/src/perfact/api/pd/services/__init__.py

@@ -0,0 +1,13 @@
+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__ = [
+    "get_time_performance_data",
+    "get_time_performance_data_v2",
+    "get_time_performance_data_v3",
+    "get_time_performance_data_v4",
+]

perfact_api_pd-0.3/src/perfact/api/pd/services/pdunitperformance_orm.py

@@ -0,0 +1,425 @@
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, Mapping, Sequence
+
+from perfact.api.pd.model.pdord import PdOrd
+from perfact.api.pd.model.pdord import PdOrd_TimeStat as PdOrdTimeStat
+from perfact.api.pd.model.pdordlc import PdOrdLc
+from perfact.api.pd.model.pdordlch import PdOrdLch
+from perfact.api.pd.model.pdordlct import PdOrdLct
+from perfact.api.pd.model.pdordprd import PdOrdPrd
+from sqlalchemy import bindparam, func, select, text
+from sqlalchemy.engine import RowMapping
+from sqlalchemy.orm import Session, aliased
+
+
+def _safe_delta(end: Any, start: Any):
+    if end and start:
+        return (end - start).total_seconds()
+    return None
+
+
+def _td_to_sec(td: Any):
+    return td.total_seconds() if td is not None else None
+
+
+def _process_performance_in_pure_python(raw_data: Mapping[Any, Any]):
+    """
+    Takes a dictionary of raw database columns and calculates
+    all time management and performance metrics in pure python
+    """
+    now = datetime.now(timezone.utc)
+    planned_start = raw_data.get("pdord_planstarttime") or raw_data.get(
+        "pdord_starttime"
+    )
+    planned_end = raw_data.get("pdord_planstoptime") or raw_data.get("pdord_stoptime")
+    actual_start_time = raw_data.get("actual_start_time")
+    actual_end_time = raw_data.get("actual_end_time")
+
+    if actual_start_time is not None:
+        estimated_start = actual_start_time
+    elif planned_start is not None and planned_start < now:
+        estimated_start = now
+    else:
+        estimated_start = planned_start
+
+    pdord_qty = float(raw_data.get("pdord_qty") or 0)
+    produced_qty = float(raw_data.get("produced_quantity") or 0)
+    active_time = raw_data.get("pdordtimestat_activetime")
+
+    if actual_end_time is not None:
+        estimated_end = actual_end_time
+    elif (
+        actual_start_time is not None
+        and active_time is not None
+        and pdord_qty > 0
+        and produced_qty > 0
+    ):
+        extrapolated_seconds = active_time.total_seconds() * (pdord_qty / produced_qty)
+        estimated_end = actual_start_time + timedelta(seconds=extrapolated_seconds)
+    elif (
+        actual_start_time is not None
+        and planned_end is not None
+        and planned_start is not None
+    ):
+        planned_duration = planned_end - planned_start
+        estimated_end = actual_start_time + planned_duration
+    elif (
+        actual_start_time is None
+        and planned_start is not None
+        and planned_end is not None
+        and planned_start < now
+    ):
+        planned_duration = planned_end - planned_start
+        estimated_end = now + planned_duration
+    else:
+        estimated_end = planned_end
+
+    remaining_time_seconds = None
+    if (
+        actual_start_time is not None
+        and active_time is not None
+        and pdord_qty > 0
+        and produced_qty > 0
+    ):
+        calc_remaining = (
+            active_time.total_seconds() * (pdord_qty / produced_qty)
+            - active_time.total_seconds()
+        )
+        remaining_time_seconds = max(0.0, calc_remaining)
+
+    delta_start_seconds = _safe_delta(estimated_start, planned_start)
+    delta_end_seconds = _safe_delta(estimated_end, planned_end)
+    delta_planned_duration = _safe_delta(planned_end, planned_start)
+
+    dur_est = _safe_delta(estimated_end, estimated_start)
+    dur_plan = _safe_delta(planned_end, planned_start)
+    estimated_duration = _safe_delta(estimated_end, estimated_start)
+    delta_duration_seconds = (
+        (dur_est - dur_plan) if (dur_est is not None and dur_plan is not None) else None
+    )
+
+    planned_cycle = _td_to_sec(raw_data.get("pdord_plancycletime"))
+    current_cycle = _td_to_sec(raw_data.get("pdordtimestat_cycle_time"))
+
+    planned_setup = _td_to_sec(raw_data.get("pdord_plansetuptime"))
+    current_setup = _td_to_sec(raw_data.get("pdordtimestat_setuptime"))
+
+    return {
+        "time_management": {
+            "estimated_start": estimated_start,
+            "estimated_end": estimated_end,
+            "delta_start_seconds": delta_start_seconds,
+            "delta_end_seconds": delta_end_seconds,
+            "delta_planned_duration_seconds": delta_planned_duration,
+            "estimated_duration_seconds": estimated_duration,
+            "delta_duration_seconds": delta_duration_seconds,
+        },
+        "operation_status": {
+            "running_time_seconds": _td_to_sec(active_time),
+            "remaining_time_seconds": remaining_time_seconds,
+            "downtime_seconds": _td_to_sec(
+                raw_data.get("pdordtimestat_spentindowntime")
+            ),
+        },
+        "performance": {
+            "cycle_time": {
+                "planned_seconds": planned_cycle,
+                "current_seconds": current_cycle,
+                "delta_seconds": (current_cycle - planned_cycle)
+                if (current_cycle is not None and planned_cycle is not None)
+                else None,
+            },
+            "setup_time": {
+                "current_seconds": current_setup,
+                "delta_seconds": (current_setup - planned_setup)
+                if (current_setup is not None and planned_setup is not None)
+                else None,
+            },
+        },
+    }
+
+
+def get_time_performance_data_v3(session: Session, pdord_ids: Sequence[int]):
+    raw_fetch_sql = text(
+        """
+        select
+            pdord_id,
+            pdord_planstarttime,
+            pdord_starttime,
+            pdord_planstoptime,
+            pdord_stoptime,
+            pdord_qty,
+            pdord_plancycletime,
+            pdord_plansetuptime,
+
+            pdordtimestat_activetime,
+            pdordtimestat_cycle_time,
+            pdordtimestat_setuptime,
+            pdordtimestat_spentindowntime,
+
+            -- Grab current state flags directly from the lifecycle table
+            pdordlc_isactive as is_active_state,
+            pdordlc_isfinal as is_final_state,
+
+            (select sum(pdordprd_quantity)
+            from pdordprd where pdordprd_pdord_id = pdord_id) as produced_quantity,
+
+            (select min(pdordlch_createtime)
+             from pdordlch
+             join pdordlct on pdordlch_pdordlct_id = pdordlct_id
+             join pdordlc from_lc on from_lc.pdordlc_id = pdordlct_from_pdordlc_id
+             join pdordlc to_lc on to_lc.pdordlc_id = pdordlct_to_pdordlc_id
+             where pdordlch_pdord_id = pdord_id
+                and from_lc.pdordlc_isactive = false
+                and to_lc.pdordlc_isactive = true) as actual_start_time,
+             (select max(pdordlch_createtime)
+              from pdordlch
+              join pdordlct on pdordlch_pdordlct_id = pdordlct_id
+              join pdordlc to_lc on to_lc.pdordlc_id = pdordlct_to_pdordlc_id
+              where pdordlch_pdord_id = pdord_id
+                and to_lc.pdordlc_isfinal = true) as actual_end_time
+          from pdord
+          join pdordlc on pdordlc_id = pdord_pdordlc_id
+          left join pdord_timestat on pdordtimestat_pdord_id = pdord_id
+          where pdord_id in :pdord_id_array
+          """
+    )
+
+    params = {"pdord_id_array": pdord_ids}
+    stm = raw_fetch_sql.bindparams(bindparam("pdord_id_array", expanding=True))
+    resultset = session.execute(stm, params).mappings().fetchall()
+
+    return {
+        str(row["pdord_id"]): _process_performance_in_pure_python(row)
+        for row in resultset
+    }
+
+
+def get_time_performance_data_v2(session: Session, pdord_ids: Sequence[int]):
+
+    from_lc = aliased(PdOrdLc)
+    to_lc = aliased(PdOrdLc)
+
+    prd_sq = (
+        select(func.sum(PdOrdPrd.quantity))
+        .where(PdOrdPrd.pdord_id == PdOrd.id)
+        .scalar_subquery()
+        .label("produced_quantity")
+    )
+
+    start_sq = (
+        select(func.min(PdOrdLch.createtime))
+        .select_from(PdOrdLch)
+        .join(PdOrdLct, PdOrdLch.pdordlct_id == PdOrdLct.id)
+        .join(from_lc, from_lc.id == PdOrdLct.from_pdordlc_id)
+        .join(to_lc, to_lc.id == PdOrdLct.to_pdordlc_id)
+        .where(
+            PdOrdLch.pdord_id == PdOrd.id,
+            from_lc.isactive.is_(False),
+            to_lc.isactive,
+        )
+        .scalar_subquery()
+        .label("actual_start_time")
+    )
+
+    end_sq = (
+        select(func.max(PdOrdLch.createtime))
+        .select_from(PdOrdLch)
+        .join(PdOrdLct, PdOrdLch.pdordlct_id == PdOrdLct.id)
+        .join(to_lc, to_lc.id == PdOrdLct.to_pdordlc_id)
+        .where(PdOrdLch.pdord_id == PdOrd.id, to_lc.isfinal)
+        .scalar_subquery()
+        .label("actual_end_time")
+    )
+
+    stm = (
+        select(
+            PdOrd.id.label("pdord_id"),
+            PdOrd.planstarttime.label("pdord_planstarttime"),
+            PdOrd.starttime.label("pdord_starttime"),
+            PdOrd.planstoptime.label("pdord_planstoptime"),
+            PdOrd.stoptime.label("pdord_stoptime"),
+            PdOrd.qty.label("pdord_qty"),
+            PdOrd.plancycletime.label("pdord_plancycletime"),
+            PdOrd.plansetuptime.label("pdord_plansetuptime"),
+            PdOrdTimeStat.activetime.label("pdordtimestat_activetime"),
+            PdOrdTimeStat.cycle_time.label("pdordtimestat_cycle_time"),
+            PdOrdTimeStat.setuptime.label("pdordtimestat_setuptime"),
+            PdOrdTimeStat.spentindowntime.label("pdordtimestat_spentindowntime"),
+            PdOrdLc.isactive.label("is_active_state"),
+            PdOrdLc.isfinal.label("is_final_state"),
+            prd_sq,
+            start_sq,
+            end_sq,
+        )
+        .join(PdOrdLc, PdOrdLc.id == PdOrd.pdordlc_id)
+        .outerjoin(PdOrdTimeStat, PdOrdTimeStat.id == PdOrd.id)
+        .where(PdOrd.id.in_(pdord_ids))
+    )
+
+    resultset = session.execute(stm).mappings().fetchall()
+
+    return {
+        str(row["pdord_id"]): _process_performance_in_pure_python(row)
+        for row in resultset
+    }
+
+
+def get_time_performance_data_v4(session: Session, pdord_ids: Sequence[int]):
+    pdords = (
+        session.execute(
+            select(
+                PdOrd.id,
+                PdOrd.pdordlc_id,
+                PdOrd.planstarttime,
+                PdOrd.starttime,
+                PdOrd.planstoptime,
+                PdOrd.stoptime,
+                PdOrd.qty,
+                PdOrd.plancycletime,
+                PdOrd.plansetuptime,
+            ).where(PdOrd.id.in_(pdord_ids))
+        )
+        .mappings()
+        .all()
+    )
+    if not pdords:
+        return {}
+
+    pdord_ids = [pdord["id"] for pdord in pdords]
+    pdord_lc_ids = {pdord["pdordlc_id"] for pdord in pdords}
+
+    timestats = (
+        session.execute(
+            select(
+                PdOrdTimeStat.id,
+                PdOrdTimeStat.activetime,
+                PdOrdTimeStat.cycle_time,
+                PdOrdTimeStat.setuptime,
+                PdOrdTimeStat.spentindowntime,
+            ).where(PdOrdTimeStat.id.in_(pdord_ids))
+        )
+        .mappings()
+        .all()
+    )
+    timestat_by_pdord_id = {row["id"]: row for row in timestats}
+
+    prd_rows = session.execute(
+        select(PdOrdPrd.pdord_id, PdOrdPrd.quantity).where(
+            PdOrdPrd.pdord_id.in_(pdord_ids)
+        )
+    ).all()
+    produced_by_pdord_id: dict[int, float] = {}
+    for prd_pdord_id, prd_quantity in prd_rows:
+        produced_by_pdord_id[prd_pdord_id] = produced_by_pdord_id.get(
+            prd_pdord_id, 0.0
+        ) + float(prd_quantity or 0.0)
+
+    lch_rows = (
+        session.execute(
+            select(PdOrdLch.pdord_id, PdOrdLch.pdordlct_id, PdOrdLch.createtime).where(
+                PdOrdLch.pdord_id.in_(pdord_ids)
+            )
+        )
+        .mappings()
+        .all()
+    )
+
+    lct_ids = {row["pdordlct_id"] for row in lch_rows}
+    lct_rows = (
+        session.execute(
+            select(PdOrdLct.id, PdOrdLct.from_pdordlc_id, PdOrdLct.to_pdordlc_id).where(
+                PdOrdLct.id.in_(lct_ids)
+            )
+        )
+        .mappings()
+        .all()
+        if lct_ids
+        else []
+    )
+    lct_by_id = {row["id"]: row for row in lct_rows}
+
+    transition_lc_ids = {
+        lc_id
+        for row in lct_rows
+        for lc_id in (row["from_pdordlc_id"], row["to_pdordlc_id"])
+    }
+    all_lc_ids = pdord_lc_ids | transition_lc_ids
+    lc_rows = (
+        session.execute(
+            select(PdOrdLc.id, PdOrdLc.isactive, PdOrdLc.isfinal).where(
+                PdOrdLc.id.in_(all_lc_ids)
+            )
+        )
+        .mappings()
+        .all()
+        if all_lc_ids
+        else []
+    )
+    lc_by_id = {row["id"]: row for row in lc_rows}
+
+    history_by_pdord_id: dict[int, list[RowMapping]] = {}
+    for row in lch_rows:
+        history_by_pdord_id.setdefault(row["pdord_id"], []).append(row)
+
+    result: Dict[str, Any] = {}
+    for pdord in pdords:
+        actual_start_time = None
+        actual_end_time = None
+
+        for history in history_by_pdord_id.get(pdord["id"], []):
+            transition = lct_by_id.get(history["pdordlct_id"])
+            if transition is None:
+                continue
+
+            from_lc = lc_by_id.get(transition["from_pdordlc_id"])
+            to_lc = lc_by_id.get(transition["to_pdordlc_id"])
+
+            if (
+                from_lc is not None
+                and to_lc is not None
+                and (from_lc["isactive"] is False)
+                and bool(to_lc["isactive"])
+            ):
+                if (
+                    actual_start_time is None
+                    or history["createtime"] < actual_start_time
+                ):
+                    actual_start_time = history["createtime"]
+
+            if to_lc is not None and bool(to_lc["isfinal"]):
+                if actual_end_time is None or history["createtime"] > actual_end_time:
+                    actual_end_time = history["createtime"]
+
+        timestat = timestat_by_pdord_id.get(pdord["id"])
+        order_lc = lc_by_id.get(pdord["pdordlc_id"])
+        raw_data = {
+            "pdord_id": pdord["id"],
+            "pdord_planstarttime": pdord["planstarttime"],
+            "pdord_starttime": pdord["starttime"],
+            "pdord_planstoptime": pdord["planstoptime"],
+            "pdord_stoptime": pdord["stoptime"],
+            "pdord_qty": pdord["qty"],
+            "pdord_plancycletime": pdord["plancycletime"],
+            "pdord_plansetuptime": pdord["plansetuptime"],
+            "pdordtimestat_activetime": (
+                None if timestat is None else timestat["activetime"]
+            ),
+            "pdordtimestat_cycle_time": (
+                None if timestat is None else timestat["cycle_time"]
+            ),
+            "pdordtimestat_setuptime": (
+                None if timestat is None else timestat["setuptime"]
+            ),
+            "pdordtimestat_spentindowntime": (
+                None if timestat is None else timestat["spentindowntime"]
+            ),
+            "is_active_state": None if order_lc is None else order_lc["isactive"],
+            "is_final_state": None if order_lc is None else order_lc["isfinal"],
+            "produced_quantity": produced_by_pdord_id.get(pdord["id"], 0.0),
+            "actual_start_time": actual_start_time,
+            "actual_end_time": actual_end_time,
+        }
+        result[str(pdord["id"])] = _process_performance_in_pure_python(raw_data)
+
+    return result