perfact-api-pd-fastapi 0.5__tar.gz → 0.6__tar.gz

{perfact_api_pd_fastapi-0.5 → perfact_api_pd_fastapi-0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perfact-api-pd-fastapi
-Version: 0.5
+Version: 0.6
 Summary: PerFact API - SQLAlchemy+FastAPI pd apis package
 Author-email: Viktor Dick <viktor.dick@perfact.de>
 License-Expression: GPL-2.0-or-later

perfact_api_pd_fastapi-0.6/src/perfact/api/pd_fastapi/kpi.py

@@ -0,0 +1,221 @@
+from datetime import datetime
+from typing import Annotated, Optional
+
+from fastapi import HTTPException
+from perfact.api.main import Auth, VisibilityRegistryDep
+from perfact.api.main.auth import require_roles
+from perfact.api.main.dbsession import APIRouter, DBSession
+from perfact.api.pd.model.pdunit import PdUnit
+from perfact.api.pd.services.oee.availability import compute_availability
+from perfact.api.pd.services.oee.breakdown import oee_breakdown_computation
+from perfact.api.pd.services.oee.prod_metrics import (
+    compute_performance,
+    compute_quality,
+)
+from perfact.api.pd.services.oee.prod_records import get_prod_records
+from perfact.api.pd.services.oee.state_spans import get_state_spans
+from perfact.api.pd.services.oee.summary import oee_workcenter_time_computation
+from pydantic import BaseModel, BeforeValidator
+from sqlalchemy import select
+
+routes = APIRouter()
+
+
+def _require_visible_unit(
+    session: DBSession,
+    auth: Auth,
+    visibility: VisibilityRegistryDep,
+    pdunit_id: int,
+) -> PdUnit:
+    """Fetch PdUnit with visibility policy applied. Raise 404 if not found or hidden."""
+    policy = visibility.get(PdUnit)
+    unit = session.scalar(
+        select(PdUnit).where(PdUnit.id == pdunit_id).where(policy.filter(auth))
+    )
+    if unit is None:
+        raise HTTPException(status_code=404)
+    return unit
+
+
+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)]
+
+
+@routes.get("/kpi/oee/availability", tags=["pd"], summary="Route for OEE availability")
+@require_roles("PdKpi")
+def oee_availability(
+    session: DBSession,
+    auth: Auth,
+    visibility: VisibilityRegistryDep,
+    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
+    """
+
+    unit = _require_visible_unit(session, auth, visibility, pdunit_id)
+    spans = get_state_spans(session, pdunit_id, starttime, stoptime)
+    shifts = list(session.scalars(unit.shifts_in_range_stmt(starttime, stoptime)).all())
+    return compute_availability(spans, shifts, starttime, stoptime)
+
+
+@routes.get("/kpi/oee/performance", tags=["pd"], summary="Route for OEE performance")
+@require_roles("PdKpi")
+def oee_performance(
+    session: DBSession,
+    auth: Auth,
+    visibility: VisibilityRegistryDep,
+    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
+    """
+    _require_visible_unit(session, auth, visibility, pdunit_id)
+    records = get_prod_records(session, pdunit_id, starttime, stoptime)
+    spans = get_state_spans(session, pdunit_id, starttime, stoptime)
+    isexecution_spans = [s for s in spans if s.isexecution]
+    return compute_performance(
+        records, starttime, stoptime, isexecution_spans=isexecution_spans
+    )
+
+
+@routes.get("/kpi/oee/quality", tags=["pd"], summary="Route for OEE quality")
+# response_model=Sequence[PdordlchGet])
+@require_roles("PdKpi")
+def oee_quality(
+    session: DBSession,
+    auth: Auth,
+    visibility: VisibilityRegistryDep,
+    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 | None:
+    """
+    Route for OEE quality
+    Uses the quality_computation function
+    Returns single floating point value
+    """
+    _require_visible_unit(session, auth, visibility, pdunit_id)
+    records = get_prod_records(session, pdunit_id, starttime, stoptime)
+    return compute_quality(records, starttime, stoptime)
+
+
+class OEECalculationResponse(BaseModel):
+    """Response model for GET /kpi/oee.
+
+    Includes A/P/Q/OEE values plus workcenter-level time breakdown and
+    quantity aggregates across all operations in the requested window.
+    See ADR 0003.
+    """
+
+    availability: float
+    performance: float
+    quality: float | None
+    oee: float | None
+    planned_machine_time_seconds: float
+    unplanned_downtime_seconds: float
+    setup_time_deviation_seconds: float
+    productive_time_seconds: float
+    pdordprd_quantitytotal: float
+    pdordprd_quantity: float
+
+
+@routes.get("/kpi/oee", tags=["pd"], summary="OEE calculation")
+@require_roles("PdKpi")
+def oee_calculation(
+    session: DBSession,
+    auth: Auth,
+    visibility: VisibilityRegistryDep,
+    pdunit_id: int,
+    starttime: datetime,
+    stoptime: datetime,
+) -> OEECalculationResponse:
+    """OEE with time breakdown and quantity aggregates for one work centre."""
+    unit = _require_visible_unit(session, auth, visibility, pdunit_id)
+    spans = get_state_spans(session, pdunit_id, starttime, stoptime)
+    shifts = list(session.scalars(unit.shifts_in_range_stmt(starttime, stoptime)).all())
+    availability = compute_availability(spans, shifts, starttime, stoptime)
+    prod_records = get_prod_records(session, pdunit_id, starttime, stoptime)
+    isexecution_spans = [s for s in spans if s.isexecution]
+    performance = compute_performance(
+        prod_records, starttime, stoptime, isexecution_spans=isexecution_spans
+    )
+    quality = compute_quality(prod_records, starttime, stoptime)
+    oee = availability * performance * quality if quality is not None else None
+    summary = oee_workcenter_time_computation(session, pdunit_id, starttime, stoptime)
+    return OEECalculationResponse(
+        availability=availability,
+        performance=performance,
+        quality=quality,
+        oee=oee,
+        **summary.__dict__,
+    )
+
+
+class OEEBreakdownResponse(BaseModel):
+    pdord_id: int
+    pdord_num: str
+    planned_machine_time_seconds: float
+    unplanned_downtime_seconds: float
+    setup_time_deviation_seconds: float
+    productive_time_seconds: float
+    availability: float
+    performance: float
+    quality: float | None
+    oee: float | None
+    pdordprd_quantitytotal: float
+    pdordprd_quantity: float
+    equipment: list[str]
+    mtart_num: Optional[str]
+    mtart_name: Optional[str]
+    operation_start: Optional[datetime]
+    operation_end: Optional[datetime]
+
+
+@routes.get("/kpi/oee/breakdown", tags=["pd"], summary="Per-operation OEE breakdown")
+@require_roles("PdKpi")
+def oee_breakdown(
+    session: DBSession,
+    auth: Auth,
+    visibility: VisibilityRegistryDep,
+    pdunit_id: int,
+    starttime: datetime,
+    stoptime: datetime,
+) -> list[OEEBreakdownResponse]:
+    """Return one OEE row per operation that had active time on the given unit."""
+    _require_visible_unit(session, auth, visibility, pdunit_id)
+    rows = oee_breakdown_computation(session, pdunit_id, starttime, stoptime)
+    return [OEEBreakdownResponse(**row.__dict__) for row in rows]
+
+
+def mount(app: APIRouter):
+    app.include_router(routes)

{perfact_api_pd_fastapi-0.5 → perfact_api_pd_fastapi-0.6}/src/perfact_api_pd_fastapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perfact-api-pd-fastapi
-Version: 0.5
+Version: 0.6
 Summary: PerFact API - SQLAlchemy+FastAPI pd apis package
 Author-email: Viktor Dick <viktor.dick@perfact.de>
 License-Expression: GPL-2.0-or-later

{perfact_api_pd_fastapi-0.5 → perfact_api_pd_fastapi-0.6}/src/perfact_api_pd_fastapi.egg-info/SOURCES.txt

@@ -13,6 +13,9 @@ src/perfact_api_pd_fastapi.egg-info/dependency_links.txt
 src/perfact_api_pd_fastapi.egg-info/entry_points.txt
 src/perfact_api_pd_fastapi.egg-info/requires.txt
 src/perfact_api_pd_fastapi.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/helpers.py
 tests/locustfile.py
 tests/test_init.py
 tests/test_kpi.py

perfact_api_pd_fastapi-0.6/tests/helpers.py

@@ -0,0 +1,17 @@
+from fastapi.routing import APIRoute, _IncludedRouter
+
+
+def collect_paths(router, prefix: str = "") -> set[str]:
+    """Recursively collect route paths from a router, handling _IncludedRouter wrappers.
+
+    FastAPI ≥ 0.115 lazily wraps included routers as _IncludedRouter instead of
+    immediately flattening them into APIRoute instances in the parent routes list.
+    """
+    paths: set[str] = set()
+    for route in router.routes:
+        if isinstance(route, APIRoute):
+            paths.add(prefix + route.path)
+        elif isinstance(route, _IncludedRouter):
+            sub_prefix = prefix + (route.include_context.prefix or "")
+            paths |= collect_paths(route.original_router, sub_prefix)
+    return paths

{perfact_api_pd_fastapi-0.5 → perfact_api_pd_fastapi-0.6}/tests/test_init.py

@@ -1,13 +1,15 @@
 from fastapi import FastAPI
 from perfact.api.pd_fastapi import mount
 
+from .helpers import collect_paths
+
 
 def test_mount_adds_pd_and_pdord_routes() -> None:
     app = FastAPI()
 
     mount(app)
 
-    paths = {route.path for route in app.routes}
+    paths = collect_paths(app)
     assert "/pd/kpi/oee" in paths
     assert "/pd/pdunit" in paths
     assert "/pd/pdord/get_time_performance_data_v1" in paths

perfact_api_pd_fastapi-0.6/tests/test_kpi.py

@@ -0,0 +1,333 @@
+import asyncio
+from datetime import datetime, timezone
+from unittest.mock import Mock
+
+import pytest
+from perfact.api.main.dbsession import APIRouter
+from perfact.api.pd.services.oee.breakdown import OEEBreakdownRow
+from perfact.api.pd.services.oee.state_spans import StateSpan
+from perfact.api.pd.services.oee.summary import OEEWorkcenterSummary
+from perfact.api.pd_fastapi import kpi
+from psycopg.types.range import Range as PsycopgRange
+from sqlalchemy.orm import Session
+
+
+def test_parse_datetime_with_utc_offset_accepts_isoformat() -> None:
+    value = "2025-05-20T13:54:15.555103+03:00"
+
+    parsed = kpi.parse_datetime_with_UTC_offset(value)
+
+    assert parsed == datetime.fromisoformat(value)
+
+
+def test_parse_datetime_with_utc_offset_rejects_invalid_input() -> None:
+    with pytest.raises(ValueError, match="Invalid datetime format"):
+        kpi.parse_datetime_with_UTC_offset("not-a-datetime")
+
+
+def test_oee_performance_route_delegates_to_compute_performance(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """oee_performance delegates to get_prod_records, get_state_spans,
+    and compute_performance."""
+    session: Session = Mock()
+    auth = Mock()
+    visibility = Mock()
+    pdunit_id = 7
+    starttime = datetime(2025, 1, 1, tzinfo=timezone.utc)
+    stoptime = datetime(2025, 1, 2, tzinfo=timezone.utc)
+    expected = 0.82
+
+    monkeypatch.setattr(kpi, "_require_visible_unit", lambda *_: Mock())
+    monkeypatch.setattr(kpi, "get_prod_records", lambda *_: [])
+    monkeypatch.setattr(kpi, "get_state_spans", lambda *_: [])
+    monkeypatch.setattr(
+        kpi,
+        "compute_performance",
+        lambda records, start, stop, isexecution_spans=None: expected,
+    )
+
+    coro = kpi.oee_performance(
+        session, auth, visibility, pdunit_id, starttime, stoptime
+    )
+    result: float = asyncio.run(coro)  # type: ignore[arg-type]
+
+    assert result == expected
+
+
+def test_oee_quality_route_delegates_to_compute_quality(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """oee_quality delegates to get_prod_records and compute_quality."""
+    session: Session = Mock()
+    auth = Mock()
+    visibility = Mock()
+    pdunit_id = 7
+    starttime = datetime(2025, 1, 1, tzinfo=timezone.utc)
+    stoptime = datetime(2025, 1, 2, tzinfo=timezone.utc)
+    expected = 0.97
+
+    monkeypatch.setattr(kpi, "_require_visible_unit", lambda *_: Mock())
+    monkeypatch.setattr(kpi, "get_prod_records", lambda *_: [])
+    monkeypatch.setattr(kpi, "compute_quality", lambda records, start, stop: expected)
+
+    coro = kpi.oee_quality(session, auth, visibility, pdunit_id, starttime, stoptime)
+    result: float | None = asyncio.run(coro)  # type: ignore[arg-type]
+
+    assert result == expected
+
+
+def test_oee_availability_delegates_to_compute_availability(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """oee_availability delegates to get_state_spans and compute_availability."""
+    session: Session = Mock()
+    session.scalars.return_value.all.return_value = []  # type: ignore[attr-defined]
+    auth = Mock()
+    visibility = Mock()
+    pdunit_id = 7
+    starttime = datetime(2025, 1, 1, tzinfo=timezone.utc)
+    stoptime = datetime(2025, 1, 2, tzinfo=timezone.utc)
+    expected = 0.91
+    captured: list[tuple] = []
+
+    def fake_get_state_spans(s, uid, start, stop):
+        captured.append(("get_state_spans", uid, start, stop))
+        return []
+
+    def fake_compute_availability(spans, shifts, start, stop):
+        captured.append(("compute_availability", start, stop))
+        return expected
+
+    monkeypatch.setattr(kpi, "_require_visible_unit", lambda *_: Mock())
+    monkeypatch.setattr(kpi, "get_state_spans", fake_get_state_spans)
+    monkeypatch.setattr(kpi, "compute_availability", fake_compute_availability)
+
+    coro = kpi.oee_availability(
+        session, auth, visibility, pdunit_id, starttime, stoptime
+    )
+    result: float = asyncio.run(coro)  # type: ignore[arg-type]
+
+    assert result == expected
+    assert ("get_state_spans", pdunit_id, starttime, stoptime) in captured
+    assert ("compute_availability", starttime, stoptime) in captured
+
+
+def test_oee_calculation_returns_combined_values(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Route returns OEECalculationResponse combining A/P/Q and workcenter time
+    summary.
+    """
+    session: Session = Mock()
+    pdunit_id = 3
+    starttime = datetime(2025, 2, 1, tzinfo=timezone.utc)
+    stoptime = datetime(2025, 2, 2, tzinfo=timezone.utc)
+    fake_summary = OEEWorkcenterSummary(
+        planned_machine_time_seconds=100.0,
+        unplanned_downtime_seconds=50.0,
+        setup_time_deviation_seconds=10.0,
+        productive_time_seconds=200.0,
+        pdordprd_quantitytotal=10.0,
+        pdordprd_quantity=9.0,
+    )
+
+    auth = Mock()
+    visibility = Mock()
+    session.scalars.return_value.all.return_value = []  # type: ignore[attr-defined]
+    monkeypatch.setattr(kpi, "_require_visible_unit", lambda *_: Mock())
+    monkeypatch.setattr(kpi, "get_state_spans", lambda *_: [])
+    monkeypatch.setattr(kpi, "compute_availability", lambda *_, **__: 0.5)
+    monkeypatch.setattr(kpi, "get_prod_records", lambda *_: [])
+    monkeypatch.setattr(kpi, "compute_performance", lambda *_, **__: 0.8)
+    monkeypatch.setattr(kpi, "compute_quality", lambda *_: 0.9)
+    monkeypatch.setattr(kpi, "oee_workcenter_time_computation", lambda *_: fake_summary)
+
+    result: kpi.OEECalculationResponse = asyncio.run(
+        kpi.oee_calculation(session, auth, visibility, pdunit_id, starttime, stoptime)  # type: ignore[arg-type]
+    )
+
+    assert result.availability == 0.5
+    assert result.performance == 0.8
+    assert result.quality == 0.9
+    assert result.oee == pytest.approx(0.36)
+    assert result.planned_machine_time_seconds == 100.0
+    assert result.unplanned_downtime_seconds == 50.0
+    assert result.setup_time_deviation_seconds == 10.0
+    assert result.productive_time_seconds == 200.0
+    assert result.pdordprd_quantitytotal == 10.0
+    assert result.pdordprd_quantity == 9.0
+
+
+def test_oee_performance_route_passes_only_isexecution_spans(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """oee_performance passes only isexecution spans to compute_performance.
+
+    Non-execution spans (e.g. setup) must be excluded so that production records
+    recorded during setup are not included in the performance numerator/denominator.
+    """
+    session: Session = Mock()
+    auth = Mock()
+    visibility = Mock()
+    pdunit_id = 7
+    starttime = datetime(2025, 1, 1, tzinfo=timezone.utc)
+    stoptime = datetime(2025, 1, 2, tzinfo=timezone.utc)
+
+    dummy_range: PsycopgRange[datetime] = PsycopgRange(None, None)
+    exec_span = StateSpan(
+        pdord_id=1, range=dummy_range, isactive=True, isexecution=True
+    )
+    setup_span = StateSpan(
+        pdord_id=1, range=dummy_range, isactive=True, isexecution=False
+    )
+    captured_isexecution_spans: list[StateSpan] = []
+
+    monkeypatch.setattr(kpi, "_require_visible_unit", lambda *_: Mock())
+    monkeypatch.setattr(kpi, "get_prod_records", lambda *_: [])
+    monkeypatch.setattr(kpi, "get_state_spans", lambda *_: [exec_span, setup_span])
+
+    def fake_compute_performance(records, start, stop, isexecution_spans=None):
+        captured_isexecution_spans.extend(isexecution_spans or [])
+        return 0.82
+
+    monkeypatch.setattr(kpi, "compute_performance", fake_compute_performance)
+
+    coro = kpi.oee_performance(
+        session, auth, visibility, pdunit_id, starttime, stoptime
+    )
+    asyncio.run(coro)  # type: ignore[arg-type]
+
+    assert exec_span in captured_isexecution_spans
+    assert setup_span not in captured_isexecution_spans
+
+
+def test_oee_calculation_performance_uses_only_isexecution_spans(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """oee_calculation passes only isexecution spans to compute_performance.
+
+    Non-execution spans must be excluded so the work-centre performance matches
+    the per-operation breakdown performance for single-operation scenarios.
+    """
+    session: Session = Mock()
+    session.scalars.return_value.all.return_value = []  # type: ignore[attr-defined]
+    auth = Mock()
+    visibility = Mock()
+    pdunit_id = 3
+    starttime = datetime(2025, 2, 1, tzinfo=timezone.utc)
+    stoptime = datetime(2025, 2, 2, tzinfo=timezone.utc)
+
+    dummy_range: PsycopgRange[datetime] = PsycopgRange(None, None)
+    exec_span = StateSpan(
+        pdord_id=1, range=dummy_range, isactive=True, isexecution=True
+    )
+    setup_span = StateSpan(
+        pdord_id=1, range=dummy_range, isactive=True, isexecution=False
+    )
+    captured_isexecution_spans: list[StateSpan] = []
+
+    monkeypatch.setattr(kpi, "_require_visible_unit", lambda *_: Mock())
+    monkeypatch.setattr(kpi, "get_state_spans", lambda *_: [exec_span, setup_span])
+    monkeypatch.setattr(kpi, "compute_availability", lambda *_, **__: 0.9)
+    monkeypatch.setattr(kpi, "get_prod_records", lambda *_: [])
+
+    def fake_compute_performance(records, start, stop, isexecution_spans=None):
+        captured_isexecution_spans.extend(isexecution_spans or [])
+        return 0.8
+
+    monkeypatch.setattr(kpi, "compute_performance", fake_compute_performance)
+    monkeypatch.setattr(kpi, "compute_quality", lambda *_: 0.9)
+    monkeypatch.setattr(
+        kpi,
+        "oee_workcenter_time_computation",
+        lambda *_: OEEWorkcenterSummary(
+            planned_machine_time_seconds=0.0,
+            unplanned_downtime_seconds=0.0,
+            setup_time_deviation_seconds=0.0,
+            productive_time_seconds=0.0,
+            pdordprd_quantitytotal=0.0,
+            pdordprd_quantity=0.0,
+        ),
+    )
+
+    coro = kpi.oee_calculation(
+        session, auth, visibility, pdunit_id, starttime, stoptime
+    )
+    asyncio.run(coro)  # type: ignore[arg-type]
+
+    assert exec_span in captured_isexecution_spans
+    assert setup_span not in captured_isexecution_spans
+
+
+def test_mount_includes_kpi_routes() -> None:
+    from .helpers import collect_paths
+
+    app_router = APIRouter()
+
+    kpi.mount(app_router)
+
+    paths = collect_paths(app_router)
+    assert "/kpi/oee/availability" in paths
+    assert "/kpi/oee/performance" in paths
+    assert "/kpi/oee/quality" in paths
+    assert "/kpi/oee" in paths
+    assert "/kpi/oee/breakdown" in paths
+
+
+def test_oee_breakdown_route_delegates_to_service(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Route delegates to oee_breakdown_computation and returns its result."""
+    session: Session = Mock()
+    pdunit_id = 5
+    starttime = datetime(2025, 3, 1, tzinfo=timezone.utc)
+    stoptime = datetime(2025, 3, 2, tzinfo=timezone.utc)
+    fake_row = OEEBreakdownRow(
+        pdord_id=1,
+        pdord_num="OP-001",
+        planned_machine_time_seconds=600.0,
+        unplanned_downtime_seconds=120.0,
+        setup_time_deviation_seconds=60.0,
+        productive_time_seconds=3000.0,
+        availability=0.9,
+        performance=0.85,
+        quality=0.95,
+        oee=0.9 * 0.85 * 0.95,
+        pdordprd_quantitytotal=10.0,
+        pdordprd_quantity=9.0,
+        equipment=["TOOL-1"],
+        mtart_num="MAT-001",
+        mtart_name="Material One",
+        operation_start=datetime(2025, 3, 1, 6, tzinfo=timezone.utc),
+        operation_end=datetime(2025, 3, 1, 18, tzinfo=timezone.utc),
+    )
+    captured: list[tuple] = []
+
+    def fake_breakdown(s, u, start, stop):
+        captured.append((s, u, start, stop))
+        return [fake_row]
+
+    auth = Mock()
+    visibility = Mock()
+    monkeypatch.setattr(kpi, "_require_visible_unit", lambda *_: Mock())
+    monkeypatch.setattr(kpi, "oee_breakdown_computation", fake_breakdown)
+
+    result: list[kpi.OEEBreakdownResponse] = asyncio.run(
+        kpi.oee_breakdown(session, auth, visibility, pdunit_id, starttime, stoptime)  # type: ignore[arg-type]
+    )
+
+    assert captured == [(session, pdunit_id, starttime, stoptime)]
+    assert len(result) == 1
+    assert result[0].pdord_id == 1
+    assert result[0].pdord_num == "OP-001"
+    assert result[0].availability == 0.9
+    assert result[0].performance == 0.85
+    assert result[0].quality == 0.95
+    assert result[0].pdordprd_quantitytotal == 10.0
+    assert result[0].pdordprd_quantity == 9.0
+    assert result[0].equipment == ["TOOL-1"]
+    assert result[0].mtart_num == "MAT-001"
+    assert result[0].mtart_name == "Material One"
+    assert result[0].operation_start == datetime(2025, 3, 1, 6, tzinfo=timezone.utc)
+    assert result[0].operation_end == datetime(2025, 3, 1, 18, tzinfo=timezone.utc)

{perfact_api_pd_fastapi-0.5 → perfact_api_pd_fastapi-0.6}/tests/test_pdunit.py

@@ -36,7 +36,7 @@ def test_pdunit_get_all_requires_authentication() -> None:
 
     with pytest.raises(HTTPException, match="Not authenticated") as exc_info:
         asyncio.run(
-            pdunit.pdunit_get_all(session=session, auth=None, visibility=visibility)
+            pdunit.pdunit_get_all(session=session, auth=None, visibility=visibility)  # type: ignore[arg-type]
         )
 
     assert exc_info.value.status_code == 401
@@ -45,9 +45,11 @@ def test_pdunit_get_all_requires_authentication() -> None:
 
 
 def test_mount_includes_pdunit_route() -> None:
+    from .helpers import collect_paths
+
     app_router = APIRouter()
 
     pdunit.mount(app_router)
 
-    paths = {route.path for route in app_router.routes}
+    paths = collect_paths(app_router)
     assert "/pdunit" in paths

{perfact_api_pd_fastapi-0.5 → perfact_api_pd_fastapi-0.6}/tests/test_performance.py

@@ -1,13 +1,15 @@
-from fastapi import APIRouter
+from perfact.api.main.dbsession import APIRouter
 from perfact.api.pd_fastapi import performancedata as perf
 
+from .helpers import collect_paths
+
 
 def test_mount_includes_performance_routes() -> None:
     app_router = APIRouter()
 
     perf.mount(app_router)
 
-    paths = {route.path for route in app_router.routes}
+    paths = collect_paths(app_router)
     assert "/get_time_performance_data_v1" in paths
     assert "/get_time_performance_data_v2" in paths
     assert "/get_time_performance_data_v3" in paths

perfact_api_pd_fastapi-0.5/src/perfact/api/pd_fastapi/kpi.py

@@ -1,133 +0,0 @@
-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 PdOrdPrd
-from pydantic import BeforeValidator
-
-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)]
-
-
-@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 = PdOrdPrd.oee_availability_computation(
-        session, pdunit_id, starttime, stoptime
-    )
-
-    return result
-
-
-@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 = PdOrdPrd.oee_performance_computation(
-        session, pdunit_id, starttime, stoptime
-    )
-
-    return result
-
-
-@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 | None:
-    """
-    Route for OEE quality
-    Uses the quality_computation function
-    Returns single floating point value
-    """
-    result = PdOrdPrd.oee_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 = PdOrdPrd.oee_availability_computation(
-        session, pdunit_id, starttime, stoptime
-    )
-    performance = PdOrdPrd.oee_performance_computation(
-        session, pdunit_id, starttime, stoptime
-    )
-    quality = PdOrdPrd.oee_quality_computation(session, pdunit_id, starttime, stoptime)
-    oee = availability * performance * quality if quality is not None else None
-
-    return {
-        "availability": availability,
-        "performance": performance,
-        "quality": quality,
-        "oee": oee,
-    }
-
-
-def mount(app: APIRouter):
-    app.include_router(routes)

perfact_api_pd_fastapi-0.5/tests/test_kpi.py

@@ -1,105 +0,0 @@
-import asyncio
-from datetime import datetime, timezone
-
-import pytest
-from perfact.api.main.dbsession import APIRouter
-from perfact.api.pd_fastapi import kpi
-
-
-def test_parse_datetime_with_utc_offset_accepts_isoformat() -> None:
-    value = "2025-05-20T13:54:15.555103+03:00"
-
-    parsed = kpi.parse_datetime_with_UTC_offset(value)
-
-    assert parsed == datetime.fromisoformat(value)
-
-
-def test_parse_datetime_with_utc_offset_rejects_invalid_input() -> None:
-    with pytest.raises(ValueError, match="Invalid datetime format"):
-        kpi.parse_datetime_with_UTC_offset("not-a-datetime")
-
-
-@pytest.mark.parametrize(
-    ("route_func", "computation_name", "expected"),
-    [
-        (kpi.oee_availability, "oee_availability_computation", 0.91),
-        (kpi.oee_performance, "oee_performance_computation", 0.82),
-        (kpi.oee_quality, "oee_quality_computation", 0.97),
-    ],
-)
-def test_single_kpi_routes_delegate_to_model(
-    monkeypatch: pytest.MonkeyPatch,
-    route_func,
-    computation_name: str,
-    expected: float,
-) -> None:
-    session = object()
-    pdunit_id = 7
-    starttime = datetime(2025, 1, 1, tzinfo=timezone.utc)
-    stoptime = datetime(2025, 1, 2, tzinfo=timezone.utc)
-    captured: list[tuple[object, int, datetime, datetime]] = []
-
-    def fake_computation(
-        local_session, local_pdunit_id, local_starttime, local_stoptime
-    ):
-        captured.append(
-            (local_session, local_pdunit_id, local_starttime, local_stoptime)
-        )
-        return expected
-
-    monkeypatch.setattr(
-        kpi.PdOrdPrd,
-        computation_name,
-        staticmethod(fake_computation),
-    )
-
-    result = asyncio.run(route_func(session, pdunit_id, starttime, stoptime))
-
-    assert result == expected
-    assert captured == [(session, pdunit_id, starttime, stoptime)]
-
-
-def test_oee_calculation_returns_combined_values(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    session = object()
-    pdunit_id = 3
-    starttime = datetime(2025, 2, 1, tzinfo=timezone.utc)
-    stoptime = datetime(2025, 2, 2, tzinfo=timezone.utc)
-
-    monkeypatch.setattr(
-        kpi.PdOrdPrd,
-        "oee_availability_computation",
-        staticmethod(lambda *_: 0.5),
-    )
-    monkeypatch.setattr(
-        kpi.PdOrdPrd,
-        "oee_performance_computation",
-        staticmethod(lambda *_: 0.8),
-    )
-    monkeypatch.setattr(
-        kpi.PdOrdPrd,
-        "oee_quality_computation",
-        staticmethod(lambda *_: 0.9),
-    )
-
-    result = asyncio.run(kpi.oee_calculation(session, pdunit_id, starttime, stoptime))
-
-    assert result == {
-        "availability": 0.5,
-        "performance": 0.8,
-        "quality": 0.9,
-        "oee": 0.36000000000000004,
-    }
-
-
-def test_mount_includes_kpi_routes() -> None:
-    app_router = APIRouter()
-
-    kpi.mount(app_router)
-
-    paths = {route.path for route in app_router.routes}
-    assert "/kpi/oee/availability" in paths
-    assert "/kpi/oee/performance" in paths
-    assert "/kpi/oee/quality" in paths
-    assert "/kpi/oee" in paths