perfact-api-pd-fastapi 0.2__py2.py3-none-any.whl

perfact/api/pd_fastapi/__init__.py

@@ -0,0 +1,17 @@
+from fastapi import FastAPI
+from perfact.api.main.dbsession import APIRouter
+
+from .kpi import mount as kpi_mount
+from .pdunit import mount as pdunitmount
+from .performancedata import mount as performancemount
+
+routes = APIRouter()
+routes_pdord = APIRouter()
+
+
+def mount(app: FastAPI):
+    kpi_mount(routes)
+    pdunitmount(routes)
+    performancemount(routes_pdord)
+    app.include_router(routes, prefix="/pd")
+    app.include_router(routes_pdord, prefix="/pd/pdord")

perfact/api/pd_fastapi/kpi.py

@@ -0,0 +1,226 @@
+from datetime import datetime
+from typing import Annotated
+
+from perfact.api.main.auth import require_roles
+from perfact.api.main.dbsession import APIRouter, DBSession
+from perfact.api.pd.model import PdOrdLch, PdOrdPrd
+from perfact.api.pp.model import PpRsrc, PpShft
+from pydantic import BeforeValidator
+from sqlalchemy import func, select
+
+routes = APIRouter()
+
+
+def parse_datetime_with_UTC_offset(value: str) -> datetime:
+    try:
+        return datetime.fromisoformat(value)
+    except ValueError:
+        raise ValueError(
+            f"Invalid datetime format. \
+            Expected: yyyy-mm-ddThh:mm:ss.sssss+HH:00, got: {value}"
+        )
+
+
+UTCOffsetDatetime = Annotated[datetime, BeforeValidator(parse_datetime_with_UTC_offset)]
+
+
+def availability_computation(
+    session: DBSession, 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)
+
+
+@routes.get("/kpi/oee/availability", tags=["pd"], summary="Route for OEE availability")
+@require_roles("PdKpi")
+def oee_availability(
+    session: DBSession,
+    pdunit_id: int,
+    # ex w timezone "2025-05-20T13:54:15.555103+03:00"
+    # ex wo timezone "2025-05-20T13:54:15.555103"
+    starttime: datetime,
+    # ex w timezone "2025-05-22T11:53:13.561411+03:00"
+    # ex wo timezone "2025-05-22T11:53:13.561411"
+    stoptime: datetime,
+) -> float:
+    """
+    Route for OEE availability
+    Uses the availability_computation function
+    Returns single floating point value
+    """
+
+    result = availability_computation(session, pdunit_id, starttime, stoptime)
+
+    return result
+
+
+def performance_computation(
+    session: DBSession, pdunit_id: int, starttime: datetime, stoptime: datetime, /
+) -> float:
+    """OEE function for computation of performance"""
+    performance = 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).is_(True))
+    ).scalar()
+
+    if not performance:
+        performance = 0
+
+    return float(performance)
+
+
+@routes.get("/kpi/oee/performance", tags=["pd"], summary="Route for OEE performance")
+@require_roles("PdKpi")
+def oee_performance(
+    session: DBSession,
+    pdunit_id: int,
+    # ex w timezone "2025-05-20T13:54:15.555103+03:00"
+    # ex wo timezone "2025-05-20T13:54:15.555103"
+    starttime: datetime,
+    # ex w timezone "2025-05-22T11:53:13.561411+03:00"
+    # ex wo timezone "2025-05-22T11:53:13.561411"
+    stoptime: datetime,
+) -> float:
+    """
+    Route for OEE availability
+    Uses the performance_computation function
+    Returns single floating point value
+    """
+    result = performance_computation(session, pdunit_id, starttime, stoptime)
+
+    return result
+
+
+def quality_computation(
+    session: DBSession, pdunit_id: int, starttime: datetime, stoptime: datetime, /
+) -> float:
+    """OEE function computation for quality"""
+    quality = session.execute(
+        select(
+            func.sum(PdOrdPrd.good_quantity_over_range(starttime, stoptime))
+            / func.sum(PdOrdPrd.total_quantity_over_range(starttime, stoptime))
+        ).where(PdOrdPrd.quality_eligible(pdunit_id).is_(True))
+    ).scalar()
+
+    if not quality:
+        quality = 0
+
+    return float(quality)
+
+
+@routes.get("/kpi/oee/quality", tags=["pd"], summary="Route for OEE quality")
+# response_model=Sequence[PdordlchGet])
+@require_roles("PdKpi")
+def oee_quality(
+    session: DBSession,
+    pdunit_id: int,
+    # ex w timezone "2025-05-20T13:54:15.555103+03:00"
+    # ex wo timezone "2025-05-20T13:54:15.555103"
+    starttime: datetime,
+    # ex w timezone "2025-05-22T11:53:13.561411+03:00"
+    # ex wo timezone "2025-05-22T11:53:13.561411"
+    stoptime: datetime,
+) -> float:
+    """
+    Route for OEE quality
+    Uses the quality_computation function
+    Returns single floating point value
+    """
+    result = quality_computation(session, pdunit_id, starttime, stoptime)
+
+    return result
+
+
+@routes.get("/kpi/oee", tags=["pd"], summary="OEE calculation")
+# response_model=Sequence[PdordlchGet])
+@require_roles("PdKpi")
+def oee_calculation(
+    session: DBSession,
+    pdunit_id: int,
+    # ex w timezone "2025-05-20T13:54:15.555103+03:00"
+    # ex wo timezone "2025-05-20T13:54:15.555103"
+    starttime: datetime,
+    # ex w timezone "2025-05-22T11:53:13.561411+03:00"
+    # ex wo timezone "2025-05-22T11:53:13.561411"
+    stoptime: datetime,
+) -> dict:
+    """
+    OEE route for complete calculations: availability, performance, quality
+    Returns dict/json type response containing
+    all results under their specific category
+    """
+    availability = availability_computation(session, pdunit_id, starttime, stoptime)
+    performance = performance_computation(session, pdunit_id, starttime, stoptime)
+    quality = quality_computation(session, pdunit_id, starttime, stoptime)
+    oee = availability * performance * quality
+
+    return {
+        "availability": availability,
+        "performance": performance,
+        "quality": quality,
+        "oee": oee,
+    }
+
+
+def mount(app: APIRouter):
+    app.include_router(routes)

perfact/api/pd_fastapi/locustfile.py

@@ -0,0 +1,72 @@
+"""
+Locust load test for all three /get_time_performance_data endpoints.
+- Each task POSTs a JSON array of pdunit_ids to one endpoint.
+- Payloads are generated once per user, reused for all endpoints.
+- Tracks comparative performance and error rates.
+"""
+
+import json
+import os
+from itertools import cycle
+
+from locust import HttpUser, between, task
+
+API_BASE = os.getenv("API_BASE_PATH", "/api/pd/pdord")
+ALL_ENDPOINTS = [
+    "/get_time_performance_data_v1",  # Pure SQL
+    "/get_time_performance_data_v2",  # ORM
+    "/get_time_performance_data_v3",  # Pure Python SQL
+    "/get_time_performance_data_v4",  # Pure Python ORM
+]
+PDUNIT_ID_POOL = list(range(2000, 3001))
+PDUNITS_PER_REQUEST = 10
+
+API_KEY = os.getenv("API_KEY")
+API_KEY_HEADER = os.getenv("API_KEY_HEADER", "Authorization")
+API_KEY_PREFIX = os.getenv("API_KEY_PREFIX", "Apikey")
+
+
+class PdUnitPerformanceUser(HttpUser):
+    wait_time = between(0.5, 2.0)
+
+    def on_start(self):
+        self.client.trust_env = False
+        pool_len = len(PDUNIT_ID_POOL)
+        start = abs(hash((os.getpid(), id(self)))) % pool_len
+        self.pdunit_ids = [
+            PDUNIT_ID_POOL[(start + i) % pool_len] for i in range(PDUNITS_PER_REQUEST)
+        ]
+        self.headers = {"Content-Type": "application/json"}
+        if API_KEY:
+            self.headers[API_KEY_HEADER] = f"{API_KEY_PREFIX} {API_KEY}"
+        self.endpoint_cycle = cycle(ALL_ENDPOINTS)
+
+    @task
+    def post_next_endpoint(self):
+        self._post_to_endpoint(next(self.endpoint_cycle))
+
+    def _post_to_endpoint(self, endpoint):
+        url = API_BASE + endpoint
+        payload = json.dumps(self.pdunit_ids)
+        with self.client.post(
+            url,
+            data=payload,
+            headers=self.headers,
+            catch_response=True,
+            name=endpoint,
+        ) as resp:
+            if resp.status_code != 200:
+                resp.failure(f"{endpoint} failed: {resp.status_code}")
+            else:
+                try:
+                    data = resp.json()
+                    if not isinstance(data, dict):
+                        resp.failure(f"{endpoint} returned non-dict response")
+                except Exception as e:
+                    resp.failure(f"{endpoint} invalid JSON: {e}")
+
+
+# How to use currently:
+# locust -f locustfile.py --host http://127.0.0.1:8000
+# --web-host 127.0.0.1 --web-port 8010
+# add your key export API_KEY='your_key'

perfact/api/pd_fastapi/pdunit.py

@@ -0,0 +1,42 @@
+from typing import Optional, Sequence
+
+from fastapi import HTTPException
+from perfact.api.base.model import PydanticBase
+from perfact.api.main import Auth, DBSession, VisibilityRegistryDep, require_roles
+from perfact.api.main.dbsession import APIRouter
+from perfact.api.pd.model import PdUnit
+from sqlalchemy import select
+
+routes = APIRouter()
+
+
+class PdUnitGet(PydanticBase):
+    name: Optional[str]
+    num: str
+    overprodmay: bool
+    overprodfactor: float
+    seqnum: Optional[int]
+
+
+@routes.get(
+    "/pdunit",
+    tags=["pd"],
+    summary="Get all visible PdUnit",
+    response_model=Sequence[PdUnitGet],
+)
+@require_roles("PdRead")
+def pdunit_get_all(
+    session: DBSession, auth: Auth, visibility: VisibilityRegistryDep
+) -> Sequence[PdUnit]:
+    """
+    returns all PdUnit which the current user is allowed to see.
+    """
+    policy = visibility.get(PdUnit)
+    if auth is None:
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    return session.execute(select(PdUnit).filter(policy.filter(auth))).scalars().all()
+
+
+def mount(app: APIRouter):
+    app.include_router(routes)

perfact/api/pd_fastapi/performancedata.py

@@ -0,0 +1,701 @@
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, Mapping, Optional, Sequence
+
+from perfact.api.main.auth import Auth, require_roles
+from perfact.api.main.dbsession import APIRouter, DBSession
+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 pydantic import BaseModel
+from sqlalchemy import bindparam, func, select, text
+from sqlalchemy.engine import RowMapping
+from sqlalchemy.orm import aliased
+
+routes = APIRouter()
+
+
+class PdUnitPerformanceGetTime(BaseModel):
+    estimated_start: Optional[datetime]
+    estimated_end: Optional[datetime]
+    delta_start_seconds: Optional[float]
+    delta_end_seconds: Optional[float]
+    delta_planned_duration_seconds: Optional[float]
+    estimated_duration_seconds: Optional[float]
+    delta_duration_seconds: Optional[float]
+
+
+class PdUnitPerformanceGetStatus(BaseModel):
+    running_time_seconds: Optional[float]
+    remaining_time_seconds: Optional[float]
+    downtime_seconds: Optional[float]
+
+
+class PdUnitPerformanceGetPerformanceTime(BaseModel):
+    planned_seconds: Optional[float]
+    current_seconds: Optional[float]
+    delta_seconds: Optional[float]
+
+
+class PdUnitPerformanceGetPerformanceTimeSetup(BaseModel):
+    current_seconds: Optional[float]
+    delta_seconds: Optional[float]
+
+
+class PdUnitPerformanceGetPerformance(BaseModel):
+    cycle_time: Optional[PdUnitPerformanceGetPerformanceTime]
+    setup_time: Optional[PdUnitPerformanceGetPerformanceTimeSetup]
+
+
+class PdUnitPerformanceGet(BaseModel):
+    time_management: Optional[PdUnitPerformanceGetTime]
+    operation_status: Optional[PdUnitPerformanceGetStatus]
+    performance: Optional[PdUnitPerformanceGetPerformance]
+
+
+def parse_performance_row(data_row):
+    return {
+        "time_management": {
+            "estimated_start": data_row.estimated_actual_start_raw,
+            "estimated_end": data_row.estimated_end_raw,
+            "delta_start_seconds": data_row.delta_start_seconds,
+            "delta_end_seconds": data_row.delta_end_seconds,
+            "delta_planned_duration_seconds": data_row.delta_planned_duration_seconds,
+            "estimated_duration_seconds": data_row.estimated_duration_seconds,
+            "delta_duration_seconds": data_row.delta_duration_seconds,
+        },
+        "operation_status": {
+            "running_time_seconds": data_row.running_time_seconds,
+            "remaining_time_seconds": data_row.remaining_time_seconds,
+            "downtime_seconds": data_row.downtime_seconds,
+        },
+        # Performance Metrics
+        "performance": {
+            "cycle_time": {
+                "planned_seconds": data_row.planned_cycle_time_seconds,
+                "current_seconds": data_row.current_cycle_time_seconds,
+                "delta_seconds": data_row.delta_cycle_time_seconds,
+            },
+            "setup_time": {
+                "current_seconds": data_row.current_setup_time_seconds,
+                "delta_seconds": data_row.delta_setup_time_seconds,
+            },
+        },
+    }
+
+
+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
+
+
+@routes.post(
+    "/get_time_performance_data_v1",
+    tags=["pd"],
+    summary="get_time_performance_data - variant 1 (Pure SQL)",
+    response_model=Dict[str, PdUnitPerformanceGet],
+)
+@require_roles("PdRead")
+def get_time_performance_data_1(
+    session: DBSession, auth: Auth, pdord_ids: Sequence[int]
+):
+    if not pdord_ids:
+        return {}
+
+    stm = text(
+        """
+    -- Get time management and performance overview data for a specific production order
+with base_data as (
+  select
+    pdord.*,
+    pdordlc.*,
+    pdordtimestat_activetime,
+    pdordtimestat_exectime,
+    pdordtimestat_setuptime,
+    pdordtimestat_spentindowntime,
+    pdordtimestat_cycle_time,
+    -- Pre-calculate commonly used values
+    coalesce(pdord_planstarttime, pdord_starttime) as planned_start,
+    coalesce(pdord_planstoptime, pdord_stoptime) as planned_end,
+    (select sum(pdordprd_quantity) from pdordprd where pdordprd_pdord_id = pdord_id) as produced_quantity
+
+  from pdord
+
+  join pdordlc
+    on pdordlc_id = pdord_pdordlc_id
+
+  left
+  join pdord_timestat
+    on pdordtimestat_pdord_id = pdord_id
+
+  where pdord_id = any(:pdord_id_array)
+),
+actual_start_calc as (
+  select
+    *,
+    -- Calculate actual start time - when operation transitioned from non-active to active state
+    (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,
+
+    -- Calculate actual end time - when operation transitioned to final state
+    (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 base_data
+),
+time_calculations as (
+  select
+    *,
+    -- Estimated start calculation based on execution state
+    case
+      -- If operation has transitioned to active state, use actual start
+      when actual_start_time is not null then
+        actual_start_time
+      -- If operation has not started but is overdue, use current time
+      when planned_start is not null and planned_start < now() then
+        now()
+      -- If operation has not started and not overdue, use planned start
+      else planned_start
+    end as estimated_start
+  from actual_start_calc
+),
+final_calculations as (
+  select
+    *,
+    -- Estimated end calculation based on execution state
+    case
+      -- If operation is completed (final state), use actual end time
+      when actual_end_time is not null then
+        actual_end_time
+      -- If operation is in a state that is considered active and has corresponding time data
+      when actual_start_time is not null and pdordtimestat_activetime is not null and pdord_qty > 0 and produced_quantity > 0 then
+        -- Actual start + estimated total running time
+        actual_start_time + (pdordtimestat_activetime * (pdord_qty::float / produced_quantity::float))
+      -- If operation has been in execution but no execution time available, use time difference from planned
+      when actual_start_time is not null and planned_end is not null and planned_start is not null then
+        actual_start_time + (planned_end - planned_start)
+      -- If operation has not started but is overdue, use current time + planned duration
+      when actual_start_time is null and planned_start is not null and planned_end is not null and planned_start < now() then
+        now() + (planned_end - planned_start)
+      -- Default: use planned end
+      else planned_end
+    end as estimated_end,
+    -- Cycle time calculations
+    extract(epoch from pdord_plancycletime)::float as planned_cycle_time_seconds,
+
+    -- Calculate current cycle time if operation has been in an active state and has produced parts
+    extract(epoch from pdordtimestat_cycle_time)::float
+      as current_cycle_time_seconds
+  from time_calculations
+)
+select
+  pdord_id,
+  -- Return calculated timestamps
+  estimated_start as estimated_actual_start_raw,
+  estimated_end as estimated_end_raw,
+
+  -- Delta calculations
+  extract(epoch from (estimated_start - planned_start))::float as delta_start_seconds,
+
+  extract(epoch from (estimated_end - planned_end))::float as delta_end_seconds,
+
+  extract(epoch from (planned_end - planned_start))::float as delta_planned_duration_seconds,
+
+  -- Duration calculations
+  extract(epoch from (estimated_end - estimated_start))::float as estimated_duration_seconds,
+
+  extract(epoch from ((estimated_end - estimated_start) - (planned_end - planned_start)))::float as delta_duration_seconds,
+
+  -- Time statistics based on active operation state
+  extract(epoch from pdordtimestat_activetime)::float as running_time_seconds,
+
+  case
+    -- Calculate remaining time only if operation has been in an active state and has produced parts
+    when actual_start_time is not null and pdordtimestat_activetime is not null and pdord_qty > 0 and produced_quantity > 0 then
+      greatest(0, extract(epoch from (
+        pdordtimestat_activetime * (pdord_qty::float / produced_quantity::float) - pdordtimestat_activetime
+      ))::float)
+    else null
+  end as remaining_time_seconds,
+
+  planned_cycle_time_seconds,
+  current_cycle_time_seconds,
+  current_cycle_time_seconds - planned_cycle_time_seconds as delta_cycle_time_seconds,
+
+  -- Setup time calculations - total accumulated setup time
+  extract(epoch from pdordtimestat_setuptime)::float as current_setup_time_seconds,
+
+  extract(epoch from (pdordtimestat_setuptime - pdord_plansetuptime))::float as delta_setup_time_seconds,
+
+  -- Downtime - total accumulated downtime
+  extract(epoch from pdordtimestat_spentindowntime)::float as downtime_seconds
+
+from final_calculations
+    """  # noqa: E501
+    )
+    params = {"pdord_id_array": pdord_ids}
+    resultset = session.execute(stm, params).fetchall()
+    return {str(res.pdord_id): parse_performance_row(res) for res in resultset}
+
+
+@routes.post(
+    "/get_time_performance_data_v2",
+    tags=["pd"],
+    summary="get_time_performance_data_ variant 2 (ORM)",
+    response_model=Dict[str, PdUnitPerformanceGet],
+)
+@require_roles("PdRead")
+def get_time_performance_data_2(
+    session: DBSession, auth: Auth, pdord_ids: Sequence[int]
+):
+    if not pdord_ids:
+        return {}
+
+    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
+    }
+
+
+@routes.post(
+    "/get_time_performance_data_v3",
+    tags=["pd"],
+    summary="get_time_performance_data_ variant 3 (Pure Python SQL)",
+    response_model=Dict[str, PdUnitPerformanceGet],
+)
+@require_roles("PdRead")
+def get_time_performance_data_3(
+    session: DBSession, auth: Auth, pdord_ids: Sequence[int]
+):
+    if not pdord_ids:
+        return {}
+
+    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
+    }
+
+
+@routes.post(
+    "/get_time_performance_data_v4",
+    tags=["pd"],
+    summary="get_time_performance_data_ variant 4 (Pure Python ORM)",
+    response_model=Dict[str, PdUnitPerformanceGet],
+)
+@require_roles("PdRead")
+def get_time_performance_data_4(
+    session: DBSession, auth: Auth, pdord_ids: Sequence[int]
+):
+    if not pdord_ids:
+        return {}
+
+    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, PdUnitPerformanceGet] = {}
+    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
+
+
+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 mount(app: APIRouter):
+    app.include_router(routes)

perfact_api_pd_fastapi-0.2.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: perfact-api-pd-fastapi
+Version: 0.2
+Summary: PerFact API - SQLAlchemy+FastAPI pd apis package
+Author-email: Viktor Dick <viktor.dick@perfact.de>
+License-Expression: GPL-2.0-or-later
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: SQL
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi[standard-no-fastapi-cloud-cli]
+Requires-Dist: perfact-api-pp
+Requires-Dist: perfact-api-pd
+Requires-Dist: perfact-api-main
+
+# PerFact API - pd - APIs
+
+This package contains all APIs related to the Pd-module ('Production Execution') of the PerFact software.
+All available APIs are added to the main OpenAPI specification automatically.
+
+## getting started
+This module is discovered and hosted by the `PythonPackages/perfact-api-base`.
+As this package does not contain an own main entrypoint, you have to install it into the base and run that one.
+Please refer to the documentation of the *API Base* to get more information about how the discovery works and how to include this module to your app bundle.
+If everything is working, you should see this module be added to your bundle instance in the log:
+```
+2026-[...] - auth.app - INFO - start plugin discovery
+[...]
+2026-[...] - auth.app - INFO - try to include plugin: perfact.api.pd_fastapi:mount
+[...] 
+2026-[...] - auth.app - INFO - finished discovery and include: X plugins
+```

perfact_api_pd_fastapi-0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+perfact/api/pd_fastapi/__init__.py,sha256=_VdCnj9Tz8pE2kf0YBi3UW8RnrsEw4NY35S0jeD5Bjs,469
+perfact/api/pd_fastapi/kpi.py,sha256=CS270_GT2EoFjA24JIrQM4d2hdIOISKmWWV-IbXIaoI,7342
+perfact/api/pd_fastapi/locustfile.py,sha256=rFm-nNfEfR6P_Hu0Ya8kGiIjwDDwg5YUxor15HsOCKI,2413
+perfact/api/pd_fastapi/pdunit.py,sha256=5GFnXY6DGo_0XVavjJ1r3f43sLl1dqUYPGgZjHdL6iM,1113
+perfact/api/pd_fastapi/performancedata.py,sha256=EI5TF3zrZm43DfrpUbkrQefT1tA-u157-fccajqna4U,24997
+perfact/api/pd_fastapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+perfact_api_pd_fastapi-0.2.dist-info/METADATA,sha256=YPp2LQWAJftNv8DT7joggVtRxEfbzz9h92R_q-d8Sfo,1464
+perfact_api_pd_fastapi-0.2.dist-info/WHEEL,sha256=TdQ5LtNwLuxTCjgxN51AgdU5w-KkB9ttmLbzjTH02pg,109
+perfact_api_pd_fastapi-0.2.dist-info/entry_points.txt,sha256=lpsMh9vjZWuc0C2jAPNCVFS5Et8qZ0g2hhVN0haqCys,48
+perfact_api_pd_fastapi-0.2.dist-info/top_level.txt,sha256=1odO3B1JiDF2Lqgnop8k7K4Xs1y_LdwehM53l1NDOnc,8
+perfact_api_pd_fastapi-0.2.dist-info/RECORD,,

perfact_api_pd_fastapi-0.2.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

perfact_api_pd_fastapi-0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[perfact.api]
+pd = perfact.api.pd_fastapi:mount

perfact_api_pd_fastapi-0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+perfact