perfact-api-pd-fastapi 1.4__tar.gz → 1.6__tar.gz

{perfact_api_pd_fastapi-1.4 → perfact_api_pd_fastapi-1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perfact-api-pd-fastapi
-Version: 1.4
+Version: 1.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-1.4 → perfact_api_pd_fastapi-1.6}/src/perfact/api/pd_fastapi/kpi.py

@@ -1,9 +1,7 @@
 from datetime import datetime
-from typing import Annotated, Optional
+from typing import Annotated, Optional, TypeAlias
 
-from fastapi import HTTPException, Query, status
-from perfact.api.base import VisibilityPolicy
-from perfact.api.main import Auth, VisibilityRegistryDep
+from perfact.api.main import require_visible, require_visible_list
 from perfact.api.main.auth import require_roles
 from perfact.api.main.dbsession import APIRouter, DBSession
 from perfact.api.pd.model.pdunit import PdUnit
@@ -23,42 +21,12 @@ from perfact.api.pd.services.oee.trend import (
     get_oee_trend_candidate_days,
 )
 from pydantic import BaseModel, BeforeValidator
-from sqlalchemy import select
 
 routes = APIRouter()
 routes_assignd = 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 _filter_visible_pdunit_ids(
-    session: DBSession,
-    auth: Auth,
-    policy: VisibilityPolicy,
-    pdunit_ids: list[int],
-) -> list[int]:
-    """Return only PdUnit IDs visible to the current user."""
-    return list(
-        session.scalars(
-            select(PdUnit.id)
-            .where(PdUnit.id.in_(pdunit_ids))
-            .where(policy.filter(auth))
-        ).all()
-    )
+VisiblePdUnit: TypeAlias = require_visible(PdUnit, "pdunit_id")  # type: ignore[valid-type]
+VisiblePdUnits: TypeAlias = require_visible_list(PdUnit, "pdunit_ids")  # type: ignore[valid-type]
 
 
 def parse_datetime_with_UTC_offset(value: str) -> datetime:
@@ -77,15 +45,9 @@ UTCOffsetDatetime = Annotated[datetime, BeforeValidator(parse_datetime_with_UTC_
 @routes.get("/kpi/oee/availability", tags=["pd"], summary="Route for OEE availability")
 @require_roles("PdKpi")
 def oee_availability(
+    unit: VisiblePdUnit,
     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:
     """
@@ -94,8 +56,7 @@ def oee_availability(
     Returns single floating point value
     """
 
-    unit = _require_visible_unit(session, auth, visibility, pdunit_id)
-    spans = get_state_spans(session, pdunit_id, starttime, stoptime)
+    spans = get_state_spans(session, unit.id, starttime, stoptime)
     shifts = list(session.scalars(unit.shifts_in_range_stmt(starttime, stoptime)).all())
     return compute_availability(spans, shifts, starttime, stoptime)
 
@@ -103,15 +64,9 @@ def oee_availability(
 @routes.get("/kpi/oee/performance", tags=["pd"], summary="Route for OEE performance")
 @require_roles("PdKpi")
 def oee_performance(
+    unit: VisiblePdUnit,
     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:
     """
@@ -119,9 +74,8 @@ def oee_performance(
     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)
+    records = get_prod_records(session, unit.id, starttime, stoptime)
+    spans = get_state_spans(session, unit.id, starttime, stoptime)
     isexecution_spans = [s for s in spans if s.isexecution]
     return compute_performance(
         records, starttime, stoptime, isexecution_spans=isexecution_spans
@@ -132,15 +86,9 @@ def oee_performance(
 # response_model=Sequence[PdordlchGet])
 @require_roles("PdKpi")
 def oee_quality(
+    unit: VisiblePdUnit,
     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:
     """
@@ -148,8 +96,7 @@ def 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)
+    records = get_prod_records(session, unit.id, starttime, stoptime)
     return compute_quality(records, starttime, stoptime)
 
 
@@ -176,26 +123,23 @@ class OEECalculationResponse(BaseModel):
 @routes.get("/kpi/oee", tags=["pd"], summary="OEE calculation")
 @require_roles("PdKpi")
 def oee_calculation(
+    unit: VisiblePdUnit,
     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)
+    spans = get_state_spans(session, unit.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)
+    prod_records = get_prod_records(session, unit.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)
+    summary = oee_workcenter_time_computation(session, unit.id, starttime, stoptime)
     return OEECalculationResponse(
         availability=availability,
         performance=performance,
@@ -228,16 +172,13 @@ class OEEBreakdownResponse(BaseModel):
 @routes.get("/kpi/oee/breakdown", tags=["pd"], summary="Per-operation OEE breakdown")
 @require_roles("PdKpi")
 def oee_breakdown(
+    unit: VisiblePdUnit,
     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)
+    rows = oee_breakdown_computation(session, unit.id, starttime, stoptime)
     return [OEEBreakdownResponse(**row.__dict__) for row in rows]
 
 
@@ -278,21 +219,13 @@ def oee_trend_aggregation(
 @require_roles("PdKpi")
 def pdunit_downtime_calculation(
     session: DBSession,
-    auth: Auth,
-    visibility: VisibilityRegistryDep,
+    units: VisiblePdUnits,
     starttime: datetime,
     endtime: datetime,
-    pdunit_ids: list[int] = Query(),
 ) -> list:
-    if auth is None:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
-    if not pdunit_ids:
-        return []
-    policy = visibility.get(PdUnit)
-    pdunit_ids = _filter_visible_pdunit_ids(session, auth, policy, pdunit_ids)
-    if not pdunit_ids:
+    if not units:
         return []
-    return get_failure_times(session, pdunit_ids, starttime, endtime)
+    return get_failure_times(session, [u.id for u in units], starttime, endtime)
 
 
 def mount(app: APIRouter):

{perfact_api_pd_fastapi-1.4 → perfact_api_pd_fastapi-1.6}/src/perfact/api/pd_fastapi/pdunitlch.py

@@ -1,21 +1,31 @@
 import datetime
 from typing import Optional, Sequence
 
-from fastapi import HTTPException
+from fastapi import HTTPException, Query
 from perfact.api.base.model import PydanticBase
-from perfact.api.main import Auth, DBSession, require_roles
+from perfact.api.main import Auth, DBSession, VisibilityRegistryDep, require_roles
 from perfact.api.main.dbsession import APIRouter
-from perfact.api.pd.model import PdOrdLc, PdOrdLch, PdOrdLct, PdUnitLc, PdUnitLct
+from perfact.api.pd.model import (
+    PdOrdLc,
+    PdOrdLch,
+    PdOrdLct,
+    PdUnit,
+    PdUnitLc,
+    PdUnitLct,
+)
 from perfact.api.pd.services.pdunitlch import UnitLchHistoryEntry, get_unit_lch_history
 from pydantic import BaseModel, ConfigDict
 from sqlalchemy import select
 
 routes = APIRouter()
 
+MAX_SAMPLE_COUNT = 9_000
+
 
 class PdUnitLcGet(PydanticBase):
     name: str
     seqnum: Optional[int]
+    color: Optional[str]
 
 
 class PdUnitLctGet(PydanticBase):
@@ -31,6 +41,7 @@ class PdOrdLcGet(PydanticBase):
     isfinal: bool
     issetup: bool
     isdowntime: bool
+    color: Optional[str]
 
 
 class PdOrdLctGet(PydanticBase):
@@ -51,6 +62,7 @@ class PdUnitLchEntryGet(BaseModel):
     pdunitlct_name: str
     pdunitlc_name: str
     pdord_num: Optional[str]
+    pdordlc_name: Optional[str]
 
 
 @routes.get(
@@ -118,20 +130,49 @@ def pdordlch_get_all(session: DBSession, auth: Auth) -> Sequence[PdOrdLch]:
 def pdunitlch_get(
     session: DBSession,
     auth: Auth,
+    visibility: VisibilityRegistryDep,
     pdunit_id: Optional[int] = None,
     pdunit_num: Optional[str] = None,
-    duration_s: Optional[int] = None,
+    sample_count: Optional[int] = Query(default=None, ge=1, le=MAX_SAMPLE_COUNT),
     starttime: Optional[datetime.datetime] = None,
     endtime: Optional[datetime.datetime] = None,
 ) -> list[UnitLchHistoryEntry]:
+    # Resolve unit from id or num
+    if pdunit_id is not None:
+        unit = session.get(PdUnit, pdunit_id)
+    elif pdunit_num is not None:
+        unit = session.execute(
+            select(PdUnit).where(PdUnit.num == pdunit_num)
+        ).scalar_one_or_none()
+    else:
+        raise HTTPException(status_code=422, detail="Provide pdunit_id or pdunit_num")
+
+    if unit is None:
+        raise HTTPException(
+            status_code=404,
+            detail=f"PdUnit not found: {pdunit_id or pdunit_num!r}",
+        )
+
+    # Visibility check applies regardless of which lookup path was used
+    try:
+        policy = visibility.get(PdUnit)
+    except KeyError:
+        raise RuntimeError("No visibility policy registered for PdUnit")
+    if (
+        session.scalar(
+            select(PdUnit).where(PdUnit.id == unit.id).where(policy.filter(auth))
+        )
+        is None
+    ):
+        raise HTTPException(status_code=404)
+
     try:
         return get_unit_lch_history(
             session,
-            pdunit_id=pdunit_id,
-            pdunit_num=pdunit_num,
+            pdunit_id=unit.id,
             starttime=starttime,
             endtime=endtime,
-            duration_s=duration_s,
+            sample_count=sample_count,
         )
     except ValueError as exc:
         raise HTTPException(status_code=422, detail=str(exc)) from exc

{perfact_api_pd_fastapi-1.4 → perfact_api_pd_fastapi-1.6}/src/perfact_api_pd_fastapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perfact-api-pd-fastapi
-Version: 1.4
+Version: 1.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-1.4 → perfact_api_pd_fastapi-1.6}/src/perfact_api_pd_fastapi.egg-info/SOURCES.txt

@@ -23,4 +23,5 @@ tests/locustfile.py
 tests/test_init.py
 tests/test_kpi.py
 tests/test_pdunit.py
+tests/test_pdunitlch.py
 tests/test_performance.py

{perfact_api_pd_fastapi-1.4 → perfact_api_pd_fastapi-1.6}/src/perfact_api_pd_fastapi.egg-info/scm_file_list.json

@@ -17,6 +17,7 @@
     "tests/__init__.py",
     "tests/test_pdunit.py",
     "tests/conftest.py",
+    "tests/test_pdunitlch.py",
     "tests/test_performance.py"
   ]
 }

{perfact_api_pd_fastapi-1.4 → perfact_api_pd_fastapi-1.6}/src/perfact_api_pd_fastapi.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "1.4",
+  "tag": "1.6",
   "distance": 0,
-  "node": "g8c9d4d7ac004f19cc8b564c3a6de4fe62487385e",
+  "node": "ga99427348d94eb18ecb59ec9b9318de2b5a77d5b",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-07-03"

{perfact_api_pd_fastapi-1.4 → perfact_api_pd_fastapi-1.6}/tests/test_kpi.py

@@ -31,14 +31,13 @@ def test_oee_performance_route_delegates_to_compute_performance(
     """oee_performance delegates to get_prod_records, get_state_spans,
     and compute_performance."""
     session: Session = Mock()
-    auth = Mock()
-    visibility = Mock()
     pdunit_id = 7
+    unit = Mock()
+    unit.id = pdunit_id
     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(
@@ -47,9 +46,7 @@ def test_oee_performance_route_delegates_to_compute_performance(
         lambda records, start, stop, isexecution_spans=None: expected,
     )
 
-    coro = kpi.oee_performance(
-        session, auth, visibility, pdunit_id, starttime, stoptime
-    )
+    coro = kpi.oee_performance(unit, session, starttime, stoptime)
     result: float = asyncio.run(coro)  # type: ignore[arg-type]
 
     assert result == expected
@@ -60,18 +57,17 @@ def test_oee_quality_route_delegates_to_compute_quality(
 ) -> None:
     """oee_quality delegates to get_prod_records and compute_quality."""
     session: Session = Mock()
-    auth = Mock()
-    visibility = Mock()
     pdunit_id = 7
+    unit = Mock()
+    unit.id = pdunit_id
     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)
+    coro = kpi.oee_quality(unit, session, starttime, stoptime)
     result: float | None = asyncio.run(coro)  # type: ignore[arg-type]
 
     assert result == expected
@@ -83,9 +79,9 @@ def test_oee_availability_delegates_to_compute_availability(
     """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
+    unit = Mock()
+    unit.id = pdunit_id
     starttime = datetime(2025, 1, 1, tzinfo=timezone.utc)
     stoptime = datetime(2025, 1, 2, tzinfo=timezone.utc)
     expected = 0.91
@@ -99,13 +95,10 @@ def test_oee_availability_delegates_to_compute_availability(
         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
-    )
+    coro = kpi.oee_availability(unit, session, starttime, stoptime)
     result: float = asyncio.run(coro)  # type: ignore[arg-type]
 
     assert result == expected
@@ -132,10 +125,9 @@ def test_oee_calculation_returns_combined_values(
         pdordprd_quantity=9.0,
     )
 
-    auth = Mock()
-    visibility = Mock()
+    unit = Mock()
+    unit.id = pdunit_id
     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 *_: [])
@@ -144,7 +136,7 @@ def test_oee_calculation_returns_combined_values(
     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]
+        kpi.oee_calculation(unit, session, starttime, stoptime)  # type: ignore[arg-type]
     )
 
     assert result.availability == 0.5
@@ -168,9 +160,9 @@ def test_oee_performance_route_passes_only_isexecution_spans(
     recorded during setup are not included in the performance numerator/denominator.
     """
     session: Session = Mock()
-    auth = Mock()
-    visibility = Mock()
     pdunit_id = 7
+    unit = Mock()
+    unit.id = pdunit_id
     starttime = datetime(2025, 1, 1, tzinfo=timezone.utc)
     stoptime = datetime(2025, 1, 2, tzinfo=timezone.utc)
 
@@ -183,7 +175,6 @@ def test_oee_performance_route_passes_only_isexecution_spans(
     )
     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])
 
@@ -193,9 +184,7 @@ def test_oee_performance_route_passes_only_isexecution_spans(
 
     monkeypatch.setattr(kpi, "compute_performance", fake_compute_performance)
 
-    coro = kpi.oee_performance(
-        session, auth, visibility, pdunit_id, starttime, stoptime
-    )
+    coro = kpi.oee_performance(unit, session, starttime, stoptime)
     asyncio.run(coro)  # type: ignore[arg-type]
 
     assert exec_span in captured_isexecution_spans
@@ -212,9 +201,9 @@ def test_oee_calculation_performance_uses_only_isexecution_spans(
     """
     session: Session = Mock()
     session.scalars.return_value.all.return_value = []  # type: ignore[attr-defined]
-    auth = Mock()
-    visibility = Mock()
     pdunit_id = 3
+    unit = Mock()
+    unit.id = pdunit_id
     starttime = datetime(2025, 2, 1, tzinfo=timezone.utc)
     stoptime = datetime(2025, 2, 2, tzinfo=timezone.utc)
 
@@ -227,7 +216,6 @@ def test_oee_calculation_performance_uses_only_isexecution_spans(
     )
     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 *_: [])
@@ -251,9 +239,7 @@ def test_oee_calculation_performance_uses_only_isexecution_spans(
         ),
     )
 
-    coro = kpi.oee_calculation(
-        session, auth, visibility, pdunit_id, starttime, stoptime
-    )
+    coro = kpi.oee_calculation(unit, session, starttime, stoptime)
     asyncio.run(coro)  # type: ignore[arg-type]
 
     assert exec_span in captured_isexecution_spans
@@ -308,13 +294,12 @@ def test_oee_breakdown_route_delegates_to_service(
         captured.append((s, u, start, stop))
         return [fake_row]
 
-    auth = Mock()
-    visibility = Mock()
-    monkeypatch.setattr(kpi, "_require_visible_unit", lambda *_: Mock())
+    unit = Mock()
+    unit.id = pdunit_id
     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]
+        kpi.oee_breakdown(unit, session, starttime, stoptime)  # type: ignore[arg-type]
     )
 
     assert captured == [(session, pdunit_id, starttime, stoptime)]

perfact_api_pd_fastapi-1.6/tests/test_pdunitlch.py

@@ -0,0 +1,76 @@
+import datetime
+from types import SimpleNamespace
+
+from perfact.api.main.dbsession import APIRouter
+from perfact.api.pd.services.pdunitlch import UnitLchHistoryEntry
+from perfact.api.pd_fastapi import pdunitlch
+
+MODTIME = datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc)
+
+
+def test_pdunitlcget_exposes_color() -> None:
+    row = SimpleNamespace(
+        id=1, author=None, modtime=MODTIME, name="Production", seqnum=1, color="#0f0"
+    )
+
+    serialized = pdunitlch.PdUnitLcGet.model_validate(row)
+
+    assert serialized.color == "#0f0"
+
+
+def test_pdordlcget_exposes_color() -> None:
+    row = SimpleNamespace(
+        id=1,
+        author=None,
+        modtime=MODTIME,
+        name="Running",
+        isactive=True,
+        isexecution=False,
+        isfinal=False,
+        issetup=False,
+        isdowntime=False,
+        color="#f00",
+    )
+
+    serialized = pdunitlch.PdOrdLcGet.model_validate(row)
+
+    assert serialized.color == "#f00"
+
+
+def test_pdunitlchentryget_exposes_pdordlc_name() -> None:
+    entry = UnitLchHistoryEntry(
+        createtime=datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc),
+        pdunitlct_name="start",
+        pdunitlc_name="running",
+        pdord_num="ORD-1",
+        pdordlc_name="active",
+    )
+
+    serialized = pdunitlch.PdUnitLchEntryGet.model_validate(entry)
+
+    assert serialized.pdordlc_name == "active"
+
+
+def test_pdunitlchentryget_pdordlc_name_none_when_no_active_operation() -> None:
+    entry = UnitLchHistoryEntry(
+        createtime=datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc),
+        pdunitlct_name="start",
+        pdunitlc_name="running",
+        pdord_num=None,
+        pdordlc_name=None,
+    )
+
+    serialized = pdunitlch.PdUnitLchEntryGet.model_validate(entry)
+
+    assert serialized.pdordlc_name is None
+
+
+def test_mount_includes_pdunitlch_route() -> None:
+    from .helpers import collect_paths
+
+    app_router = APIRouter()
+
+    pdunitlch.mount(app_router)
+
+    paths = collect_paths(app_router)
+    assert "/pdunitlch" in paths