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

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

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

@@ -3,6 +3,7 @@ from perfact.api.main.dbsession import APIRouter
 
 from .kpi import mount as kpi_mount
 from .pdunit import mount as pdunitmount
+from .pdunitlch import mount as pdunitlch_mount
 from .performancedata import mount as performancemount
 
 routes = APIRouter()
@@ -12,6 +13,7 @@ routes_pdord = APIRouter()
 def mount(app: FastAPI):
     kpi_mount(routes)
     pdunitmount(routes)
+    pdunitlch_mount(routes)
     performancemount(routes_pdord)
     app.include_router(routes, prefix="/pd")
     app.include_router(routes_pdord, prefix="/pd/pdord")

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

@@ -0,0 +1,133 @@
+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.4/src/perfact/api/pd_fastapi/pdunitlch.py

@@ -0,0 +1,143 @@
+import datetime
+from typing import Optional, Sequence
+
+from fastapi import HTTPException
+from perfact.api.base.model import PydanticBase
+from perfact.api.main import Auth, DBSession, require_roles
+from perfact.api.main.dbsession import APIRouter
+from perfact.api.pd.model import PdOrdLc, PdOrdLch, PdOrdLct, 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()
+
+
+class PdUnitLcGet(PydanticBase):
+    name: str
+    seqnum: Optional[int]
+
+
+class PdUnitLctGet(PydanticBase):
+    name: str
+    from_pdunitlc_id: int
+    to_pdunitlc_id: int
+
+
+class PdOrdLcGet(PydanticBase):
+    name: str
+    isactive: bool
+    isexecution: bool
+    isfinal: bool
+    issetup: bool
+    isdowntime: bool
+
+
+class PdOrdLctGet(PydanticBase):
+    name: str
+    from_pdordlc_id: int
+    to_pdordlc_id: int
+
+
+class PdOrdLchGet(PydanticBase):
+    pdunit_id: Optional[int]
+    pdordlct_id: int
+    pdord_id: int
+
+
+class PdUnitLchEntryGet(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    createtime: datetime.datetime
+    pdunitlct_name: str
+    pdunitlc_name: str
+    pdord_num: Optional[str]
+
+
+@routes.get(
+    "/pdunitlc",
+    tags=["pd"],
+    summary="Get all PdUnitLc",
+    response_model=Sequence[PdUnitLcGet],
+)
+@require_roles("PdRead")
+def pdunitlc_get_all(session: DBSession, auth: Auth) -> Sequence[PdUnitLc]:
+    return session.execute(select(PdUnitLc)).scalars().all()
+
+
+@routes.get(
+    "/pdunitlct",
+    tags=["pd"],
+    summary="Get all PdUnitLct",
+    response_model=Sequence[PdUnitLctGet],
+)
+@require_roles("PdRead")
+def pdunitlct_get_all(session: DBSession, auth: Auth) -> Sequence[PdUnitLct]:
+    return session.execute(select(PdUnitLct)).scalars().all()
+
+
+@routes.get(
+    "/pdordlc",
+    tags=["pd"],
+    summary="Get all PdOrdLc",
+    response_model=Sequence[PdOrdLcGet],
+)
+@require_roles("PdRead")
+def pdordlc_get_all(session: DBSession, auth: Auth) -> Sequence[PdOrdLc]:
+    return session.execute(select(PdOrdLc)).scalars().all()
+
+
+@routes.get(
+    "/pdordlct",
+    tags=["pd"],
+    summary="Get all PdOrdLct",
+    response_model=Sequence[PdOrdLctGet],
+)
+@require_roles("PdRead")
+def pdordlct_get_all(session: DBSession, auth: Auth) -> Sequence[PdOrdLct]:
+    return session.execute(select(PdOrdLct)).scalars().all()
+
+
+@routes.get(
+    "/pdordlch",
+    tags=["pd"],
+    summary="Get all PdOrdLch",
+    response_model=Sequence[PdOrdLchGet],
+)
+@require_roles("PdRead")
+def pdordlch_get_all(session: DBSession, auth: Auth) -> Sequence[PdOrdLch]:
+    return session.execute(select(PdOrdLch)).scalars().all()
+
+
+@routes.get(
+    "/pdunitlch",
+    tags=["pd"],
+    summary="Get PdUnitLch history for a production unit",
+    response_model=list[PdUnitLchEntryGet],
+)
+@require_roles("PdRead")
+def pdunitlch_get(
+    session: DBSession,
+    auth: Auth,
+    pdunit_id: Optional[int] = None,
+    pdunit_num: Optional[str] = None,
+    duration_s: Optional[int] = None,
+    starttime: Optional[datetime.datetime] = None,
+    endtime: Optional[datetime.datetime] = None,
+) -> list[UnitLchHistoryEntry]:
+    try:
+        return get_unit_lch_history(
+            session,
+            pdunit_id=pdunit_id,
+            pdunit_num=pdunit_num,
+            starttime=starttime,
+            endtime=endtime,
+            duration_s=duration_s,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    except LookupError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+def mount(app: APIRouter) -> None:
+    app.include_router(routes)

perfact_api_pd_fastapi-0.4/src/perfact/api/pd_fastapi/performancedata.py

@@ -0,0 +1,121 @@
+from datetime import datetime
+from typing import Dict, Optional, Sequence
+
+from perfact.api.main.auth import Auth, require_roles
+from perfact.api.main.dbsession import APIRouter, DBSession
+from perfact.api.pd.services.pdunitperformance_orm import (
+    get_time_performance_data_v2,
+    get_time_performance_data_v3,
+    get_time_performance_data_v4,
+)
+from perfact.api.pd.services.pdunitperformance_plainsql import (
+    get_time_performance_data as get_time_performance_data_plain,
+)
+from pydantic import BaseModel
+
+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]
+
+
+@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 {}
+
+    return get_time_performance_data_plain(session, pdord_ids)
+
+
+@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 {}
+    return get_time_performance_data_v2(session, pdord_ids)
+
+
+@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 {}
+
+    return get_time_performance_data_v3(session, pdord_ids)
+
+
+@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 {}
+
+    return get_time_performance_data_v4(session, pdord_ids)
+
+
+def mount(app: APIRouter):
+    app.include_router(routes)

{perfact_api_pd_fastapi-0.2 → perfact_api_pd_fastapi-0.4}/src/perfact_api_pd_fastapi.egg-info/PKG-INFO

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

@@ -3,8 +3,8 @@ pyproject.toml
 tox.ini
 src/perfact/api/pd_fastapi/__init__.py
 src/perfact/api/pd_fastapi/kpi.py
-src/perfact/api/pd_fastapi/locustfile.py
 src/perfact/api/pd_fastapi/pdunit.py
+src/perfact/api/pd_fastapi/pdunitlch.py
 src/perfact/api/pd_fastapi/performancedata.py
 src/perfact/api/pd_fastapi/py.typed
 src/perfact_api_pd_fastapi.egg-info/PKG-INFO
@@ -12,4 +12,9 @@ src/perfact_api_pd_fastapi.egg-info/SOURCES.txt
 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
+src/perfact_api_pd_fastapi.egg-info/top_level.txt
+tests/locustfile.py
+tests/test_init.py
+tests/test_kpi.py
+tests/test_pdunit.py
+tests/test_performance.py

perfact_api_pd_fastapi-0.4/tests/test_init.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+from perfact.api.pd_fastapi import mount
+
+
+def test_mount_adds_pd_and_pdord_routes() -> None:
+    app = FastAPI()
+
+    mount(app)
+
+    paths = {route.path for route in app.routes}
+    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.4/tests/test_kpi.py

@@ -0,0 +1,105 @@
+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

perfact_api_pd_fastapi-0.4/tests/test_pdunit.py

@@ -0,0 +1,53 @@
+import asyncio
+from unittest.mock import Mock
+
+import pytest
+from fastapi import HTTPException
+from perfact.api.main.dbsession import APIRouter
+from perfact.api.pd.model import PdUnit
+from perfact.api.pd_fastapi import pdunit
+from sqlalchemy import literal
+
+
+class _Policy:
+    def __init__(self, predicate):
+        self._predicate = predicate
+        self.auth_calls = []
+
+    def filter(self, auth):
+        self.auth_calls.append(auth)
+        return self._predicate
+
+
+class _Visibility:
+    def __init__(self, policy):
+        self.policy = policy
+        self.model_calls = []
+
+    def get(self, model):
+        self.model_calls.append(model)
+        return self.policy
+
+
+def test_pdunit_get_all_requires_authentication() -> None:
+    policy = _Policy(literal(True))
+    visibility = _Visibility(policy)
+    session = Mock()
+
+    with pytest.raises(HTTPException, match="Not authenticated") as exc_info:
+        asyncio.run(
+            pdunit.pdunit_get_all(session=session, auth=None, visibility=visibility)
+        )
+
+    assert exc_info.value.status_code == 401
+    assert visibility.model_calls == [PdUnit]
+    session.execute.assert_not_called()
+
+
+def test_mount_includes_pdunit_route() -> None:
+    app_router = APIRouter()
+
+    pdunit.mount(app_router)
+
+    paths = {route.path for route in app_router.routes}
+    assert "/pdunit" in paths

perfact_api_pd_fastapi-0.4/tests/test_performance.py

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

{perfact_api_pd_fastapi-0.2 → perfact_api_pd_fastapi-0.4}/tox.ini

@@ -32,3 +32,4 @@ commands =
     bandit --configfile {toxinidir}/../bandit.yml -r src
     mypy src
     # pytest --doctest-modules --cov-branch --cov=src --cov-report=term-missing {posargs:src}
+    pytest --cov-branch --cov=perfact.api.pd_fastapi --cov-report=term-missing --cov-fail-under=100  {posargs:src}