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

perfact/api/pd/model/__init__.py

@@ -0,0 +1,16 @@
+from .pdord import PdOrd, PdOrd_TimeStat
+from .pdordlc import PdOrdLc
+from .pdordlch import PdOrdLch
+from .pdordlct import PdOrdLct
+from .pdordprd import PdOrdPrd
+from .pdunit import PdUnit
+
+__all__ = [
+    "PdUnit",
+    "PdOrdLch",
+    "PdOrdLct",
+    "PdOrdLc",
+    "PdOrdPrd",
+    "PdOrd_TimeStat",
+    "PdOrd",
+]

perfact/api/pd/model/pdord.py

@@ -0,0 +1,47 @@
+from datetime import datetime, timedelta
+from typing import Optional
+
+from perfact.api.base.model import Base, ForeignKey, Mapped, View
+from sqlalchemy import (
+    BigInteger,
+    DateTime,
+    Interval,
+)
+from sqlalchemy.orm import mapped_column
+
+
+class PdOrd(Base):
+    # COLS
+    planmachinetime: Mapped[timedelta | None] = mapped_column(Interval)
+    planstarttime: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    starttime: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    planstoptime: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    stoptime: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    qty: Mapped[float]
+    plancycletime: Mapped[timedelta | None] = mapped_column(Interval)
+    plansetuptime: Mapped[timedelta | None] = mapped_column(Interval)
+
+    # FKS
+    pdunit_id: Mapped[int | None] = mapped_column(ForeignKey("pdunit.id"))
+    pdordlc_id: Mapped[int | None] = mapped_column(ForeignKey("pdordlc.id"))
+    # RELATIONSHIPS
+
+
+# VIEWS
+class PdOrd_TimeStat(View):
+    __tablename__ = "pdord_timestat"
+    id: Mapped[int] = mapped_column(
+        "pdordtimestat_pdord_id", BigInteger, primary_key=True
+    )
+    activetime: Mapped[Optional[timedelta]] = mapped_column(
+        "pdordtimestat_activetime", Interval, nullable=True
+    )
+    cycle_time: Mapped[Optional[timedelta]] = mapped_column(
+        "pdordtimestat_cycle_time", Interval, nullable=True
+    )
+    setuptime: Mapped[Optional[timedelta]] = mapped_column(
+        "pdordtimestat_setuptime", Interval, nullable=True
+    )
+    spentindowntime: Mapped[Optional[timedelta]] = mapped_column(
+        "pdordtimestat_spentindowntime", Interval, nullable=True
+    )

perfact/api/pd/model/pdordlc.py

@@ -0,0 +1,8 @@
+from perfact.api.base.model import Base, Mapped
+from sqlalchemy.orm import mapped_column
+
+
+class PdOrdLc(Base):
+    isexecution: Mapped[bool] = mapped_column(default=False)
+    isactive: Mapped[bool] = mapped_column(default=False)
+    isfinal: Mapped[bool] = mapped_column(default=False)

perfact/api/pd/model/pdordlch.py

@@ -0,0 +1,195 @@
+from datetime import datetime
+from typing import cast
+
+from perfact.api.base.model import Base, ForeignKey, Mapped, relationship
+from perfact.api.pp.model import PpRsrc, PpShft
+from psycopg.types.range import Range
+from sqlalchemy import DateTime, and_, case, func, select
+from sqlalchemy.dialects.postgresql import TSTZRANGE
+from sqlalchemy.ext.hybrid import hybrid_method
+from sqlalchemy.orm import mapped_column
+from sqlalchemy.sql import ColumnElement
+
+from .pdord import PdOrd
+from .pdordlct import PdOrdLct
+
+
+class PdOrdLch(Base):
+    # COLS
+    createtime: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=func.now()
+    )
+    lchtimerange: Mapped[Range[datetime]] = mapped_column(TSTZRANGE)
+
+    # FKS
+    pdunit_id: Mapped[int | None] = mapped_column(ForeignKey("pdunit.id"))
+    pdord_id: Mapped[int] = mapped_column(ForeignKey("pdord.id"))
+    pdordlct_id: Mapped[int] = mapped_column(ForeignKey("pdordlct.id"))
+
+    # RELATIONSHIPS
+    pdordlct: Mapped["PdOrdLct"] = relationship("PdOrdLct")
+    pdord: Mapped["PdOrd"] = relationship("PdOrd")
+
+    @hybrid_method
+    def availability_nominator_eligible_def(self, pdunit_id, /) -> bool:
+        """Python level - boils down to check if this operation history
+        is linked to the workcenter and represents a status change
+        from a status with pdordlc_isexecution"""
+        raise NotImplementedError("Sql expression level only")
+
+    @availability_nominator_eligible_def.expression
+    @classmethod
+    def availability_nominator_eligible(cls, pdunit_id, /) -> ColumnElement[bool]:
+        """SQL level - check definition"""
+        return and_(
+            cls.pdunit_id == pdunit_id,
+            cls.pdordlct.has(PdOrdLct.availability_nominator_eligible.is_(True)),
+        )
+
+    @hybrid_method
+    def availability_denominator_eligible_def(self, pdunit_id, /) -> bool:
+        """Python level - boils down to check if this operation history
+        is linked to the workcenter and represents a status change
+        from a status with pdordlc_isactive(True) and pdordlc_isexecution(False)"""
+        raise NotImplementedError("Sql expression level only")
+
+    @availability_denominator_eligible_def.expression
+    @classmethod
+    def availability_denominator_eligible(cls, pdunit_id, /) -> ColumnElement[bool]:
+        """SQL level - check definition"""
+        return and_(
+            cls.pdunit_id == pdunit_id,
+            cls.pdordlct.has(PdOrdLct.availability_denominator_eligible.is_(True)),
+        )
+
+    @classmethod
+    def availability_valid_intersection_seconds(
+        cls, starttime, stoptime, /
+    ) -> tuple[ColumnElement, ColumnElement[float | None]]:
+        search_range = func.tstzrange(cls.modtime, func.now())
+        intersection = search_range.op("*")(func.tstzrange(starttime, stoptime))
+
+        valid_intersection = cast(
+            ColumnElement[float | None],
+            case(
+                (func.isempty(intersection), None),
+                else_=func.extract(
+                    "epoch", func.upper(intersection) - func.lower(intersection)
+                ),
+            ),
+        )
+        return intersection, valid_intersection
+
+    @classmethod
+    def availability_missing_active_operations_nominator(
+        cls, pdunit_id, starttime, stoptime, /
+    ) -> ColumnElement[float | None]:
+        """To be used only as SQL method.
+        Check if any missing active operations have to be added to availability
+        nominator"""
+        _, valid_intersection = cls.availability_valid_intersection_seconds(
+            starttime, stoptime
+        )
+
+        latest_by_operation = (
+            select(
+                case(
+                    (
+                        cls.pdordlct.has(
+                            PdOrdLct.availability_active_operation_nominator.is_(True)
+                        ),
+                        valid_intersection,
+                    ),
+                    else_=None,
+                ).label("eligible_seconds"),
+            )
+            .select_from(cls)
+            .join(cls.pdord)
+            .where(cls.pdunit_id == pdunit_id)
+            .distinct(PdOrd.id)
+            .order_by(PdOrd.id, cls.id.desc())
+            .subquery()
+        )
+
+        return cast(
+            ColumnElement[float | None],
+            select(func.sum(latest_by_operation.c.eligible_seconds)).scalar_subquery(),
+        )
+
+    @classmethod
+    def availability_missing_active_operations_denominator(
+        cls, pdunit_id, starttime, stoptime, /
+    ) -> ColumnElement[float | None]:
+        """To be used only as SQL method.
+        Check if any missing active operations have to be added to availability
+        denominator"""
+        intersection, _ = cls.availability_valid_intersection_seconds(
+            starttime, stoptime
+        )
+
+        shift_intersection = intersection.op("*")(PpShft.shiftrange)
+        shift_overlap_seconds = cast(
+            ColumnElement[float],
+            select(
+                func.coalesce(
+                    func.sum(
+                        case(
+                            (
+                                func.isempty(shift_intersection),
+                                0.0,
+                            ),
+                            else_=func.extract(
+                                "epoch",
+                                func.upper(shift_intersection)
+                                - func.lower(shift_intersection),
+                            ),
+                        )
+                    ),
+                    0.0,
+                )
+            )
+            .select_from(PpRsrc)
+            .join(PpShft, PpShft.pprsrc_id == PpRsrc.id)
+            .where(PpRsrc.pdunit_id == pdunit_id)
+            .where(intersection.op("&&")(PpShft.shiftrange))
+            .scalar_subquery(),
+        )
+
+        # ONLY entries that are in range of:
+        # intersection between (modtime, func.now()) and given_range
+        # can be removed, used only for ease to read
+        has_shift_overlap = (
+            select(PpShft.id)
+            .select_from(PpRsrc)
+            .join(PpShft, PpShft.pprsrc_id == PpRsrc.id)
+            .where(PpRsrc.pdunit_id == pdunit_id)
+            .where(intersection.op("&&")(PpShft.shiftrange))
+            .exists()
+        )
+
+        latest_by_operation = (
+            select(
+                case(
+                    (
+                        cls.pdordlct.has(
+                            PdOrdLct.availability_active_operation_denominator.is_(True)
+                        )
+                        & has_shift_overlap,
+                        shift_overlap_seconds,
+                    ),
+                    else_=None,
+                ).label("eligible_seconds"),
+            )
+            .select_from(cls)
+            .join(cls.pdord)
+            .where(cls.pdunit_id == pdunit_id)
+            .where(has_shift_overlap)
+            .distinct(PdOrd.id)
+            .order_by(PdOrd.id, cls.id.desc())
+            .subquery()
+        )
+
+        return cast(
+            ColumnElement[float | None],
+            select(func.sum(latest_by_operation.c.eligible_seconds)).scalar_subquery(),
+        )

perfact/api/pd/model/pdordlct.py

@@ -0,0 +1,74 @@
+from typing import Any, cast
+
+from perfact.api.base.model import Base, ForeignKey, Mapped, relationship
+from sqlalchemy import and_
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy.orm import mapped_column
+from sqlalchemy.sql import ColumnElement
+
+from .pdordlc import PdOrdLc
+
+
+class PdOrdLct(Base):
+    # COLS
+    # FKS
+    from_pdordlc_id: Mapped[int] = mapped_column(ForeignKey("pdordlc.id"))
+    to_pdordlc_id: Mapped[int] = mapped_column(ForeignKey("pdordlc.id"))
+
+    # RELATIONSHIPS
+    from_pdordlc: Mapped["PdOrdLc"] = relationship(
+        "PdOrdLc", foreign_keys=[from_pdordlc_id]
+    )
+    to_pdordlc: Mapped["PdOrdLc"] = relationship(
+        "PdOrdLc", foreign_keys=[to_pdordlc_id]
+    )
+
+    @hybrid_property
+    def availability_nominator_eligible_def(self) -> bool:
+        """Python level - check if entry is eligible for availability
+        computation"""
+        raise NotImplementedError("Sql expression level only")
+
+    @availability_nominator_eligible_def.expression
+    def availability_nominator_eligible(cls) -> ColumnElement[bool]:
+        """SQL level - check definition"""
+        return cast(Any, cls.from_pdordlc).has(PdOrdLc.isexecution.is_(True))
+
+    @hybrid_property
+    def availability_denominator_eligible_def(self) -> bool:
+        """Python level - this takes in cosideration that the entries with
+        isexecution(True) have been already computed and added to the denominator"""
+        raise NotImplementedError("Sql expression level only")
+
+    @availability_denominator_eligible_def.expression
+    def availability_denominator_eligible(cls) -> ColumnElement[bool]:
+        """SQL level - check definition"""
+        return and_(
+            cast(Any, cls.from_pdordlc).has(PdOrdLc.isactive.is_(True)),
+            cast(Any, cls.from_pdordlc).has(PdOrdLc.isexecution.is_(False)),
+        )
+
+    @hybrid_property
+    def availability_active_operation_nominator_def(self) -> bool:
+        """Python level - check if the entry has a valid TO_PDORDLC which
+        would then be added to the availability."""
+        raise NotImplementedError("Sql expression level only")
+
+    @availability_active_operation_nominator_def.expression
+    def availability_active_operation_nominator(cls) -> ColumnElement[bool]:
+        """SQL level - check definition"""
+        return cast(Any, cls.to_pdordlc).has(PdOrdLc.isexecution.is_(True))
+
+    @hybrid_property
+    def availability_active_operation_denominator_def(self) -> bool:
+        """Python level - check if the entry has a valid TO_PDORDLC which
+        would then be added to the availability."""
+        raise NotImplementedError("Sql expression level only")
+
+    @availability_active_operation_denominator_def.expression
+    def availability_active_operation_denominator(cls) -> ColumnElement[bool]:
+        """SQL level - check definition"""
+        return and_(
+            cast(Any, cls.to_pdordlc).has(PdOrdLc.isactive.is_(True)),
+            cast(Any, cls.to_pdordlc).has(PdOrdLc.isexecution.is_(False)),
+        )

perfact/api/pd/model/pdordprd.py

@@ -0,0 +1,206 @@
+from datetime import datetime
+from typing import Any, Literal, cast, overload
+
+from perfact.api.base.model import Base, ForeignKey, Mapped, relationship
+from psycopg.types.range import Range
+from sqlalchemy import and_, case, func, select
+from sqlalchemy.dialects.postgresql import TSTZRANGE
+from sqlalchemy.ext.hybrid import hybrid_method, hybrid_property
+from sqlalchemy.orm import mapped_column
+from sqlalchemy.sql import ColumnElement
+from sqlalchemy.sql.elements import SQLCoreOperations
+from sqlalchemy.sql.expression import Extract
+
+from .pdord import PdOrd
+
+
+class PdOrdPrd(Base):
+    # COLS
+    deleted: Mapped[bool]
+    refrange: Mapped[Range[datetime]] = mapped_column(TSTZRANGE, index=True)
+    quantity: Mapped[float]
+    quantitywaste: Mapped[float | None]
+
+    # FKS
+    pdord_id: Mapped[int] = mapped_column(ForeignKey("pdord.id"))
+    pdunit_id: Mapped[int | None] = mapped_column(ForeignKey("pdunit.id"))
+
+    # RELATIONSHIPS
+    pdord: Mapped["PdOrd"] = relationship("PdOrd")
+
+    @hybrid_method
+    def refrange_intersection_def(
+        self, starttime: datetime, stoptime: datetime, seconds: bool = False, /
+    ) -> float | Range[datetime] | None:
+        """Python-level: intersection of the refrance with the given range"""
+        raise NotImplementedError("Sql expression level only")
+
+    _refrange_intersection_def_hybrid = cast(Any, refrange_intersection_def)
+
+    @overload
+    @classmethod
+    def refrange_intersection(
+        cls, starttime: datetime, stoptime: datetime, seconds: Literal[False], /
+    ) -> SQLCoreOperations[Range[datetime] | None]: ...
+    @overload
+    @classmethod
+    def refrange_intersection(
+        cls, starttime: datetime, stoptime: datetime, seconds: Literal[True], /
+    ) -> SQLCoreOperations[float]: ...
+    @_refrange_intersection_def_hybrid.inplace.expression
+    @classmethod
+    def refrange_intersection(
+        cls,
+        starttime: datetime,
+        stoptime: datetime,
+        seconds: bool = False,
+        /,
+    ) -> SQLCoreOperations[float | Range[datetime] | None]:
+        """SQL-level: intersection of the refrance with the given range"""
+        search_range = func.tstzrange(starttime, stoptime, "[)")
+        condition = and_(
+            cast(Any, cls.refrange).is_not(None),
+            cls.refrange.op("&&")(search_range),
+        )
+        intersection = cls.refrange.op("*")(search_range)
+
+        if seconds:
+            length = func.upper(intersection) - func.lower(intersection)
+            return case((condition, func.extract("epoch", length)), else_=0.0)
+        else:
+            return case((condition, intersection), else_=None)
+
+    @hybrid_method
+    def total_quantity_def(self, /) -> float:
+        """Python-level: get total quantity (good + scrap)"""
+        raise NotImplementedError("Sql expression level only")
+
+    @total_quantity_def.expression
+    @classmethod
+    def total_quantity(cls, /) -> ColumnElement[float]:
+        """SQL-level: get total quantity (good + scrap)"""
+        return case(
+            (cls.quantitywaste.is_not(None), cls.quantity + cls.quantitywaste),
+            else_=cls.quantity,
+        )
+
+    @hybrid_method
+    def good_quantity_over_range_def(
+        self, starttime: datetime, stoptime: datetime, /
+    ) -> float:
+        """Python-level: get good quantity over time range"""
+        raise NotImplementedError("Sql expression level only")
+
+    @good_quantity_over_range_def.expression
+    def good_quantity_over_range(
+        cls, starttime: datetime, stoptime: datetime, /
+    ) -> ColumnElement[float]:
+        """SQL-level: get good quantity over time range"""
+        return (
+            cls.refrange_intersection(starttime, stoptime, True)
+            * cls.quantity
+            / cls.actual_time_seconds
+        )
+
+    @hybrid_method
+    def total_quantity_over_range_def(
+        self, starttime: datetime, stoptime: datetime, /
+    ) -> float:
+        """Python-level: get total quantity (good + scrap) over time range"""
+        raise NotImplementedError("Sql expression level only")
+
+    @total_quantity_over_range_def.expression
+    def total_quantity_over_range(
+        cls, starttime: datetime, stoptime: datetime, /
+    ) -> ColumnElement[float]:
+        """SQL-level: get total quantity (good + scrap) over time range"""
+        return (
+            cls.refrange_intersection(starttime, stoptime, True)
+            * cls.total_quantity()
+            / cls.actual_time_seconds
+        )
+
+    @hybrid_method
+    def ideal_time_over_time_range_def(
+        self, starttime: datetime, stoptime: datetime, /
+    ) -> float:
+        """Python-level: how many units would ideally be produced in the timeframe"""
+        raise NotImplementedError("Sql expression level only")
+
+    @ideal_time_over_time_range_def.expression
+    @classmethod
+    def ideal_time_over_time_range(
+        cls, starttime: datetime, stoptime: datetime, /
+    ) -> ColumnElement[float]:
+        """SQL-level: how many units would ideally be produced in the timeframe"""
+        total_q = cls.total_quantity_over_range(starttime, stoptime)
+
+        planmachinetime_q = (
+            select(PdOrd.planmachinetime)
+            .where(PdOrd.id == cls.pdord_id)
+            .correlate(cls)
+            .scalar_subquery()
+        )
+        return case(
+            (
+                planmachinetime_q.is_not(None),
+                func.extract("epoch", planmachinetime_q) * total_q,
+            ),
+            else_=0.0,
+        )
+
+    @hybrid_property
+    def actual_time_seconds_def(self, /) -> Extract:
+        """Python-level: get total actual prod time"""
+        raise NotImplementedError("Sql expression level only")
+
+    @actual_time_seconds_def.expression
+    def actual_time_seconds(cls, /) -> Extract:
+        """SQL-level: get total actual prod time"""
+        return func.extract(
+            "epoch", (func.upper(cls.refrange) - func.lower(cls.refrange))
+        )
+
+    @hybrid_method
+    def actual_time_over_time_range_def(
+        self, starttime: datetime, stoptime: datetime, /
+    ) -> float:
+        """Python-level: get actual prod time in seconds"""
+        raise NotImplementedError("Sql expression level only")
+
+    @actual_time_over_time_range_def.expression
+    def actual_time_over_time_range(
+        cls, starttime: datetime, stoptime: datetime, /
+    ) -> SQLCoreOperations[float]:
+        """SQL-level: get actual prod time in seconds"""
+        return cls.refrange_intersection(starttime, stoptime, True)
+
+    @hybrid_method
+    def performance_eligible_def(self, pdunit_id: int, /) -> bool:
+        """Python-level: check if entry is eligible
+        to be taken in account for performance"""
+        raise NotImplementedError("Sql expression level only")
+
+    @performance_eligible_def.expression
+    def performance_eligible(cls, pdunit_id: int, /) -> ColumnElement[bool]:
+        """SQL-level: check if entry is eligible
+        to be taken in account for performance"""
+        return and_(
+            cast(Any, cls.deleted).is_(False),
+            cast(Any, cls.pdunit_id) == pdunit_id,
+            cast(Any, cls.pdord).has(PdOrd.pdunit_id == pdunit_id),
+        )
+
+    @hybrid_method
+    def quality_eligible_def(self, pdunit_id: int, /) -> bool:
+        """Python-level: check if entry is eligible
+        to be taken in account for quality"""
+        raise NotImplementedError("Sql expression level only")
+
+    @quality_eligible_def.expression
+    def quality_eligible(cls, pdunit_id: int, /) -> ColumnElement[bool]:
+        """SQL-level: check if entry is eligible
+        to be taken in account for quality"""
+        return and_(
+            cast(Any, cls.deleted).is_(False), cast(Any, cls.pdunit_id) == pdunit_id
+        )

perfact/api/pd/model/pdunit.py

@@ -0,0 +1,14 @@
+from datetime import datetime
+
+from perfact.api.base import VisibilityAwareModel
+from perfact.api.base.model import Base, Mapped
+
+
+class PdUnit(Base, VisibilityAwareModel):
+    modtime: Mapped[datetime]
+    author: Mapped[str]
+    name: Mapped[str]
+    num: Mapped[str]
+    overprodmay: Mapped[bool]
+    overprodfactor: Mapped[float]
+    seqnum: Mapped[int]

perfact/api/pd/model/policy.py

@@ -0,0 +1,23 @@
+from perfact.api.base import AuthInfo, VisibilityPolicy
+from sqlalchemy import literal
+from sqlalchemy.sql.elements import ColumnElement
+
+from .pdunit import PdUnit
+
+
+class PdUnitVisibilityPolicy(VisibilityPolicy):
+    """PdUnit is open by default."""
+
+    model = PdUnit
+
+    def filter(self, auth: AuthInfo) -> ColumnElement[bool]:
+        return literal(True)
+
+
+def register_policies(registry: object) -> None:
+    from perfact.api.base import VisibilityPolicyRegistry
+
+    if isinstance(registry, VisibilityPolicyRegistry):
+        registry.register(PdUnit, PdUnitVisibilityPolicy)
+    else:
+        raise RuntimeError("The Policy Registry was not initialized correctly.")

perfact_api_pd-0.2.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: perfact-api-pd
+Version: 0.2
+Summary: PerFact API - pd domain models and services
+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: psycopg[binary]
+Requires-Dist: sqlalchemy
+Requires-Dist: perfact-api-base-model
+Requires-Dist: perfact-api-app
+Requires-Dist: perfact-api-pp
+
+# PerFact API - pd - model
+
+This repository contains the model related to the Pd-module ('Production Execution') of the PerFact software.
+
+## getting started
+As this repository does not contain an own main entrypoint, you have to install this package into the base and run that one.
+Please referer the documentation of the *API Base* to get more informations about how the discovery works and how to include this module to your app bundle.

perfact_api_pd-0.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+perfact/api/pd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+perfact/api/pd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+perfact/api/pd/model/__init__.py,sha256=IokxoiLRN8YgL3zfXH8sUipq2mNpzsAUfAZsSq6fp0s,317
+perfact/api/pd/model/pdord.py,sha256=hSSPWS50A6w9pKXioGJAkvtdkTfMalf5lX4c9d_sh3M,1721
+perfact/api/pd/model/pdordlc.py,sha256=nYLM2XTp7uk3nbEWn7Jij1FNaBQrsL3trnzV4Tdt2R4,288
+perfact/api/pd/model/pdordlch.py,sha256=Ei9AATHC3YR5g9nNUQAVX9rCuvLWeVolPOLR0WBv9IQ,7163
+perfact/api/pd/model/pdordlct.py,sha256=8SNoSMwn4plHnlJM7miK3EONVZPZ9qrmtyG0ZGZ0PC4,3033
+perfact/api/pd/model/pdordprd.py,sha256=GK9xx-4iLF7dym8-TJX-34LbfP7FKTzUv8HDI3ojCds,7703
+perfact/api/pd/model/pdunit.py,sha256=AlKjZA495PRlJfzOBK5BB44FwRlD4F1FfTw7-BFIJHc,358
+perfact/api/pd/model/policy.py,sha256=ymyVWlZwMkNMEET69sW_HQcunErnNFGl4mBzWaTf0Ys,677
+perfact/api/pd/model/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+perfact_api_pd-0.2.dist-info/METADATA,sha256=_V5R78dgymKJN4XKMzPvUxgW5_H18QHm59i5rZWN4tg,993
+perfact_api_pd-0.2.dist-info/WHEEL,sha256=TdQ5LtNwLuxTCjgxN51AgdU5w-KkB9ttmLbzjTH02pg,109
+perfact_api_pd-0.2.dist-info/entry_points.txt,sha256=qG_YI5UUSP_r0rcHtVJQCDfUPnq3Z2IJdjxGq2JxdzI,89
+perfact_api_pd-0.2.dist-info/top_level.txt,sha256=1odO3B1JiDF2Lqgnop8k7K4Xs1y_LdwehM53l1NDOnc,8
+perfact_api_pd-0.2.dist-info/RECORD,,

perfact_api_pd-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-0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[perfact.api.visibility_policies]
+pdunit = perfact.api.pd.model.policy:register_policies

perfact_api_pd-0.2.dist-info/top_level.txt

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