zepben.ewb 1.0.0__py3-none-any.whl

zepben/ewb/model/cim/iec61970/base/core/connectivity_node.py

@@ -0,0 +1,105 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ["ConnectivityNode"]
+
+from typing import Generator, List, TYPE_CHECKING
+
+from zepben.ewb.dataclassy import dataclass
+from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+from zepben.ewb.util import get_by_mrid, ngen
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.core.terminal import Terminal
+
+
+@dataclass(slots=False)
+class ConnectivityNode(IdentifiedObject):
+    """
+    Connectivity nodes are points where terminals of AC conducting equipment are connected together with zero impedance.
+    """
+    # noinspection PyDunderSlots
+    __slots__ = ["_terminals", "__weakref__"]
+    _terminals: List[Terminal] = []
+
+    def __init__(self, terminals: List[Terminal] = None, **kwargs):
+        super(ConnectivityNode, self).__init__(**kwargs)
+        if terminals:
+            for term in terminals:
+                self.add_terminal(term)
+
+    def __iter__(self):
+        return iter(self._terminals)
+
+    def num_terminals(self):
+        """
+        Get the number of `Terminal`s for this `ConnectivityNode`.
+        """
+        return len(self._terminals)
+
+    @property
+    def terminals(self) -> Generator[Terminal, None, None]:
+        """
+        The `Terminal`s attached to this `ConnectivityNode`
+        """
+        return ngen(self._terminals)
+
+    def get_terminal(self, mrid: str) -> Terminal:
+        """
+        Get the `Terminal` for this `ConnectivityNode` identified by `mrid`
+
+        `mrid` The mRID of the required `Terminal`
+        Returns The `Terminal` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._terminals, mrid)
+
+    def add_terminal(self, terminal: Terminal) -> ConnectivityNode:
+        """
+        Associate a `terminal.Terminal` with this `ConnectivityNode`
+
+        `terminal` The `Terminal` to add. Will only add to this object if it is not already associated.
+        Returns A reference to this `ConnectivityNode` to allow fluent use.
+        Raises `ValueError` if another `Terminal` with the same `mrid` already exists for this `ConnectivityNode`.
+        """
+        if self._validate_reference(terminal, self.get_terminal, "A Terminal"):
+            return self
+
+        self._terminals.append(terminal)
+        return self
+
+    def remove_terminal(self, terminal: Terminal) -> ConnectivityNode:
+        """
+        Disassociate `terminal` from this `ConnectivityNode`.
+
+        `terminal` The `Terminal` to disassociate from this `ConnectivityNode`.
+        Returns A reference to this `ConnectivityNode` to allow fluent use.
+        Raises `ValueError` if `terminal` was not associated with this `ConnectivityNode`.
+        """
+        self._terminals.remove(terminal)
+        return self
+
+    def clear_terminals(self) -> ConnectivityNode:
+        """
+        Clear all terminals.
+        Returns A reference to this `ConnectivityNode` to allow fluent use.
+        """
+        self._terminals.clear()
+        return self
+
+    def is_switched(self):
+        return self.get_switch() is not None
+
+    def get_switch(self):
+        for term in self._terminals:
+            try:
+                # All switches should implement is_open
+                _ = term.conducting_equipment.is_open()
+                return term.conducting_equipment
+            except AttributeError:
+                pass
+        return None

zepben/ewb/model/cim/iec61970/base/core/connectivity_node_container.py

@@ -0,0 +1,15 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["ConnectivityNodeContainer"]
+
+from zepben.ewb.model.cim.iec61970.base.core.power_system_resource import PowerSystemResource
+
+
+class ConnectivityNodeContainer(PowerSystemResource):
+    """
+    A base class for all objects that may contain connectivity nodes or topological nodes.
+    """
+    pass

zepben/ewb/model/cim/iec61970/base/core/curve.py

@@ -0,0 +1,125 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["Curve"]
+
+from typing import Optional, List, Generator
+
+from zepben.ewb.model.cim.iec61970.base.core.curve_data import CurveData
+from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+from zepben.ewb.util import require, ngen, nlen, safe_remove
+
+
+class Curve(IdentifiedObject):
+    """
+    The Curve class is a multipurpose functional relationship between an independent variable (X-axis) and dependent (Y-axis) variables.
+    """
+
+    _data: Optional[List[CurveData]] = None
+
+    def __init__(self, data: List[CurveData] = None, **kwargs):
+        """
+        `data` A list of `CurveData`s to associate with this `Curve`.
+        """
+        super(Curve, self).__init__(**kwargs)
+        if data:
+            for curve_data in data:
+                self.add_curve_data(curve_data)
+
+    @property
+    def data(self) -> Generator[CurveData, None, None]:
+        """
+        The point data values that define this curve, sorted by `x_value` in ascending order.
+        """
+        return ngen(self._data)
+
+    def num_data(self):
+        """Return the number of :class:`CurveData` associated with this :class:`Curve`."""
+        return nlen(self._data)
+
+    def get_data(self, x: float) -> CurveData:
+        """
+        Get the :class:`CurveData` for this :class:`Curve` identified by its `x_value`.
+
+        :param x: The X value of the required :class:`CurveData`.
+        :returns: The :class:`CurveData` with the specified `x` if it exists.
+        :raises KeyError: When no `CurveData` was found with `x`.
+        """
+        if self._data:
+            curve_data = next((it for it in self._data if it.x_value == x), None)
+            if curve_data:
+                return curve_data
+        raise KeyError(x)
+
+    def __getitem__(self, x: float) -> CurveData:
+        """
+        Get the :class:`CurveData` for this :class:`Curve` identified by its `x_value`.
+
+        :param x: The X value of the required :class:`CurveData`.
+        :returns: The :class:`CurveData` with the specified `x` if it exists.
+        :raises IndexError: When no `CurveData` was found with `x`.
+        """
+        return self.get_data(x)
+
+    def add_data(self, x: float, y1: float, y2: Optional[float], y3: Optional[float]) -> 'Curve':
+        """
+        Add a data point to this :class:`Curve`.
+
+        :param x: The data value of the X-axis variable, depending on the X-axis units.
+        :param y1: The data value of the first Y-axis variable, depending on the Y-axis units.
+        :param y2: The data value of the second Y-axis variable (if present), depending on the Y-axis units.
+        :param y3: The data value of the third Y-axis variable (if present), depending on the Y-axis units.
+        :raises ValueError: if a :class:`CurveData` for the provided `x` value already exists for this :class:`Curve`.
+        """
+        require(all([it.x_value != x for it in self.data]),
+                lambda: f"Unable to add datapoint to {self}. x_value {x} is invalid, as data with same x_value already exist in this Curve.")
+
+        if self._data is None:
+            self._data = []
+        self._data.append(CurveData(x, y1, y2, y3))
+        self._data.sort(key=lambda it: it.x_value)
+
+        return self
+
+    def add_curve_data(self, curve_data: CurveData) -> 'Curve':
+        """
+        Associate a :class:`CurveData` with this :class:`Curve`.
+
+        :param curve_data: The :class:`CurveData` to associate with this :class:`Curve`.
+        :returns: A reference to this :class:`Curve` to allow fluent use.
+        :raises ValueError: If another :class:`CurveData` with the same `x_value` already exists for this :class:`Curve`.
+        """
+        return self.add_data(curve_data.x_value, curve_data.y1_value, curve_data.y2_value, curve_data.y3_value)
+
+    def remove_data(self, curve_data: CurveData) -> 'Curve':
+        """
+        Disassociate a :class:`CurveData` from this :class:`Curve`.
+
+        :param curve_data: The :class:`CurveData` to disassociate from this :class:`Curve`.
+        :returns: A reference to this :class:`Curve` to allow fluent use.
+        :raises ValueError: If `curve_data` was not associated with this :class:`Curve`.
+        """
+        self._data = safe_remove(self._data, curve_data)
+        return self
+
+    def remove_data_at(self, x: float) -> CurveData:
+        """
+        Disassociate a :class:`CurveData` from this :class:`Curve` based on its `x_value`.
+
+        :param x: The :class:`CurveData` to disassociate from this :class:`Curve`.
+        :returns: A reference to the removed :class:`CurveData`.
+        :raises IndexError: If no :class:`CurveData` with a value of `x` was not associated with this :class:`Curve`.
+        """
+        data = self.get_data(x)
+        self._data = safe_remove(self._data, data)
+        return data
+
+    def clear_data(self) -> 'Curve':
+        """
+        Clear all :class:`CurveData` associated with this :class:`Curve`.
+        :returns: A reference to this :class:`Curve` to allow fluent use.
+        """
+        self._data = None
+        return self

zepben/ewb/model/cim/iec61970/base/core/curve_data.py

@@ -0,0 +1,29 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CurveData"]
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class CurveData:
+    """
+    Multipurpose data points for defining a curve. The use of this generic class is discouraged if a more specific class can be used to specify the X and
+    Y axis values along with their specific data types.
+    """
+
+    x_value: float
+    """The data value of the X-axis variable, depending on the X-axis units."""
+
+    y1_value: float
+    """The data value of the first Y-axis variable, depending on the Y-axis units."""
+
+    y2_value: Optional[float] = None
+    """The data value of the second Y-axis variable (if present), depending on the Y-axis units."""
+
+    y3_value: Optional[float] = None
+    """The data value of the third Y-axis variable (if present), depending on the Y-axis units."""

zepben/ewb/model/cim/iec61970/base/core/equipment.py

@@ -0,0 +1,366 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ['Equipment']
+
+import datetime
+from typing import Optional, Generator, List, TYPE_CHECKING, TypeVar, Type
+
+from zepben.ewb.model.cim.extensions.iec61970.base.core.site import Site
+from zepben.ewb.model.cim.extensions.iec61970.base.feeder.lv_feeder import LvFeeder
+from zepben.ewb.model.cim.iec61970.base.core.feeder import Feeder
+from zepben.ewb.model.cim.iec61970.base.core.power_system_resource import PowerSystemResource
+from zepben.ewb.model.cim.iec61970.base.core.substation import Substation
+from zepben.ewb.util import nlen, get_by_mrid, ngen, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61968.metering.usage_point import UsagePoint
+    from zepben.ewb.model.cim.iec61968.operations.operational_restriction import OperationalRestriction
+    from zepben.ewb.model.cim.iec61970.base.core.equipment_container import EquipmentContainer
+    from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+    TEquipmentContainer = TypeVar("TEquipmentContainer", bound=EquipmentContainer)
+
+
+class Equipment(PowerSystemResource):
+    """
+    Abstract class, should only be used through subclasses.
+    Any part of a power system that is a physical device, electronic or mechanical.
+    """
+
+    in_service: bool = True
+    """If True, the equipment is in service."""
+    normally_in_service: bool = True
+    """If True, the equipment is _normally_ in service."""
+    commissioned_date: Optional[datetime.datetime] = None
+    """The date this equipment was commissioned into service."""
+
+    _usage_points: Optional[List[UsagePoint]] = None
+    _equipment_containers: Optional[List[EquipmentContainer]] = None
+    _operational_restrictions: Optional[List[OperationalRestriction]] = None
+    _current_containers: Optional[List[EquipmentContainer]] = None
+
+    def __init__(self, usage_points: List[UsagePoint] = None, equipment_containers: List[EquipmentContainer] = None,
+                 operational_restrictions: List[OperationalRestriction] = None, current_containers: List[EquipmentContainer] = None, **kwargs):
+        super(Equipment, self).__init__(**kwargs)
+        if usage_points:
+            for up in usage_points:
+                self.add_usage_point(up)
+        if equipment_containers:
+            for container in equipment_containers:
+                self.add_container(container)
+        if operational_restrictions:
+            for restriction in operational_restrictions:
+                self.add_operational_restriction(restriction)
+        if current_containers:
+            for cf in current_containers:
+                self.add_current_container(cf)
+
+    @property
+    def sites(self) -> Generator[Site, None, None]:
+        """
+        The `Site`s this equipment belongs to.
+        """
+        return ngen(_of_type(self._equipment_containers, Site))
+
+    def feeders(self, network_state_operators: Type[NetworkStateOperators]) -> Generator[Feeder, None, None]:
+        """
+        The `Feeder` this equipment belongs too based on `NetworkStateOperators`
+        """
+        if network_state_operators.NORMAL:
+            return self.normal_feeders
+        else:
+            return self.current_feeders
+
+    @property
+    def normal_feeders(self) -> Generator[Feeder, None, None]:
+        """
+        The normal `Feeder`s this equipment belongs to.
+        """
+        return ngen(_of_type(self._equipment_containers, Feeder))
+
+    def lv_feeders(self, network_state_operators: Type[NetworkStateOperators]) -> Generator[LvFeeder, None, None]:
+        """
+        The `LvFeeder` this equipment belongs too based on `NetworkStateOperators`
+        """
+        if network_state_operators.NORMAL:
+            return self.normal_lv_feeders
+        else:
+            return self.current_lv_feeders
+
+    @property
+    def normal_lv_feeders(self) -> Generator[LvFeeder, None, None]:
+        """
+        The normal `LvFeeder`s this equipment belongs to.
+        """
+        return ngen(_of_type(self._equipment_containers, LvFeeder))
+
+    @property
+    def substations(self) -> Generator[Substation, None, None]:
+        """
+        The `Substation`s this equipment belongs to.
+        """
+        return ngen(_of_type(self._equipment_containers, Substation))
+
+    @property
+    def current_feeders(self) -> Generator[Feeder, None, None]:
+        """
+        The current `Feeder`s this equipment belongs to.
+        """
+        return ngen(_of_type(self._current_containers, Feeder))
+
+    @property
+    def current_lv_feeders(self) -> Generator[LvFeeder, None, None]:
+        """
+        The current `LvFeeder`s this equipment belongs to.
+        """
+        return ngen(_of_type(self._current_containers, LvFeeder))
+
+    @property
+    def containers(self) -> Generator[EquipmentContainer, None, None]:
+        """
+        The `EquipmentContainer`s this equipment belongs to.
+        """
+        return ngen(self._equipment_containers)
+
+    def num_containers(self) -> int:
+        """
+        Returns The number of `EquipmentContainer`s associated with this `Equipment`
+        """
+        return nlen(self._equipment_containers)
+
+    def num_substations(self) -> int:
+        """
+        Returns The number of `zepben.ewb.model.cim.iec61970.base.core.substation.Substation`s associated with this `Equipment`
+        """
+        return len(list(_of_type(self._equipment_containers, Substation)))
+
+    def num_sites(self) -> int:
+        """
+        Returns The number of `Site`s associated with this `Equipment`
+        """
+        return len(list(_of_type(self._equipment_containers, Site)))
+
+    def num_normal_feeders(self) -> int:
+        """
+        Returns The number of normal `Feeder`s associated with this `Equipment`
+        """
+        return len(list(_of_type(self._equipment_containers, Feeder)))
+
+    def num_usage_points(self) -> int:
+        """
+        Returns The number of `UsagePoint`s associated with this `Equipment`
+        """
+        return nlen(self._usage_points)
+
+    def num_current_containers(self) -> int:
+        """
+        Returns The number of `EquipmentContainer`s associated with this `Equipment`
+        """
+        return nlen(self._current_containers)
+
+    def num_operational_restrictions(self) -> int:
+        """
+        Returns The number of `OperationalRestriction`s associated with this `Equipment`
+        """
+        return nlen(self._operational_restrictions)
+
+    def get_container(self, mrid: str) -> EquipmentContainer:
+        """
+        Get the `EquipmentContainer` for this `Equipment` identified by `mrid`
+
+        `mrid` The mRID of the required `EquipmentContainer`
+        Returns The `EquipmentContainer` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._equipment_containers, mrid)
+
+    def add_container(self, ec: EquipmentContainer) -> Equipment:
+        """
+        Associate an `EquipmentContainer` with this `Equipment`
+
+        `ec` The `EquipmentContainer` to associate with this `Equipment`.
+        Returns A reference to this `Equipment` to allow fluent use.
+        Raises `ValueError` if another `EquipmentContainer` with the same `mrid` already exists for this `Equipment`.
+        """
+        if self._validate_reference(ec, self.get_container, "An EquipmentContainer"):
+            return self
+        self._equipment_containers = list() if self._equipment_containers is None else self._equipment_containers
+        self._equipment_containers.append(ec)
+        return self
+
+    def remove_container(self, ec: EquipmentContainer) -> Equipment:
+        """
+        Disassociate `ec` from this `Equipment`.
+
+        `ec` The `EquipmentContainer` to disassociate from this `Equipment`.
+        Returns A reference to this `Equipment` to allow fluent use.
+        Raises `ValueError` if `ec` was not associated with this `Equipment`.
+        """
+        self._equipment_containers = safe_remove(self._equipment_containers, ec)
+        return self
+
+    def clear_containers(self) -> Equipment:
+        """
+        Clear all equipment.
+        Returns A reference to this `Equipment` to allow fluent use.
+        """
+        self._equipment_containers = None
+        return self
+
+    @property
+    def current_containers(self) -> Generator[EquipmentContainer, None, None]:
+        """
+        The `EquipmentContainer`s this equipment belongs to in the current state of the network.
+        """
+        return ngen(self._current_containers)
+
+    def get_current_container(self, mrid: str) -> EquipmentContainer:
+        """
+        Get the `EquipmentContainer` for this `Equipment` in the current state of the network, identified by `mrid`
+
+        `mrid` The mRID of the required `EquipmentContainer`
+        Returns The `EquipmentContainer` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._current_containers, mrid)
+
+    def add_current_container(self, equipment_container: EquipmentContainer) -> Equipment:
+        """
+        Associate `equipment_container` with this `Equipment` in the current state of the network.
+
+        `equipment_container` The `EquipmentContainer` to associate with this `Equipment`.
+        Returns A reference to this `Equipment` to allow fluent use.
+        Raises `ValueError` if another `EquipmentContainer` with the same `mrid` already exists for this `Equipment`.
+        """
+        if self._validate_reference(equipment_container, self.get_current_container, "A current EquipmentContainer"):
+            return self
+        self._current_containers = list() if self._current_containers is None else self._current_containers
+        self._current_containers.append(equipment_container)
+        return self
+
+    def remove_current_container(self, equipment_container: EquipmentContainer) -> Equipment:
+        """
+        Disassociate `equipment_container` from this `Equipment` in the current state of the network.
+
+        `equipment_container` The `EquipmentContainer` to disassociate from this `Equipment`.
+        Returns A reference to this `Equipment` to allow fluent use.
+        Raises `ValueError` if `equipment_container` was not associated with this `Equipment`.
+        """
+        self._current_containers = safe_remove(self._current_containers, equipment_container)
+        return self
+
+    def clear_current_containers(self) -> Equipment:
+        """
+        Clear all current `EquipmentContainer`s in the current state of the network.
+        Returns A reference to this `Equipment` to allow fluent use.
+        """
+        self._current_containers = None
+        return self
+
+    @property
+    def usage_points(self) -> Generator[UsagePoint, None, None]:
+        """
+        The `UsagePoint`s for this equipment.
+        """
+        return ngen(self._usage_points)
+
+    def get_usage_point(self, mrid: str) -> UsagePoint:
+        """
+        Get the `UsagePoint` for this `Equipment` identified by `mrid`
+
+        `mrid` The mRID of the required `UsagePoint`
+        Returns The `UsagePoint` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._usage_points, mrid)
+
+    def add_usage_point(self, up: UsagePoint) -> Equipment:
+        """
+        Associate `up` with this `Equipment`.
+
+        `up` the `UsagePoint` to associate with this `Equipment`.
+        Returns A reference to this `Equipment` to allow fluent use.
+        Raises `ValueError` if another `UsagePoint` with the same `mrid` already exists for this `Equipment`.
+        """
+        if self._validate_reference(up, self.get_usage_point, "A UsagePoint"):
+            return self
+        self._usage_points = list() if self._usage_points is None else self._usage_points
+        self._usage_points.append(up)
+        return self
+
+    def remove_usage_point(self, up: UsagePoint) -> Equipment:
+        """
+        Disassociate `up` from this `Equipment`.
+
+        `up` The `UsagePoint` to disassociate from this `Equipment`.
+        Returns A reference to this `Equipment` to allow fluent use.
+        Raises `ValueError` if `up` was not associated with this `Equipment`.
+        """
+        self._usage_points = safe_remove(self._usage_points, up)
+        return self
+
+    def clear_usage_points(self) -> Equipment:
+        """
+        Clear all usage_points.
+        Returns A reference to this `Equipment` to allow fluent use.
+        """
+        self._usage_points = None
+        return self
+
+    @property
+    def operational_restrictions(self) -> Generator[OperationalRestriction, None, None]:
+        """
+        The `OperationalRestriction`s that this equipment is associated with.
+        """
+        return ngen(self._operational_restrictions)
+
+    def get_operational_restriction(self, mrid: str) -> OperationalRestriction:
+        """
+        Get the `OperationalRestriction` for this `Equipment` identified by `mrid`
+
+        `mrid` The mRID of the required `OperationalRestriction`
+        Returns The `OperationalRestriction` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._operational_restrictions, mrid)
+
+    def add_operational_restriction(self, op: OperationalRestriction) -> Equipment:
+        """
+        Associate `op` with this `Equipment`.
+
+        `op` The `OperationalRestriction` to associate with this `Equipment`.
+        Returns A reference to this `Equipment` to allow fluent use.
+        Raises `ValueError` if another `OperationalRestriction` with the same `mrid` already exists for this `Equipment`.
+        """
+        if self._validate_reference(op, self.get_operational_restriction, "An OperationalRestriction"):
+            return self
+        self._operational_restrictions = list() if self._operational_restrictions is None else self._operational_restrictions
+        self._operational_restrictions.append(op)
+        return self
+
+    def remove_operational_restriction(self, op: OperationalRestriction) -> Equipment:
+        """
+        Disassociate `up` from this `Equipment`.
+
+        `op` The `OperationalRestriction` to disassociate from this `Equipment`.
+        Returns A reference to this `Equipment` to allow fluent use.
+        Raises `ValueError` if `op` was not associated with this `Equipment`.
+        """
+        self._operational_restrictions = safe_remove(self._operational_restrictions, op)
+        return self
+
+    def clear_operational_restrictions(self) -> Equipment:
+        """
+        Clear all `OperationalRestrictions`.
+        Returns A reference to this `Equipment` to allow fluent use.
+        """
+        self._operational_restrictions = None
+        return self
+
+
+def _of_type(containers: Optional[List[EquipmentContainer]], ectype: Type[TEquipmentContainer]) -> Generator[TEquipmentContainer, None, None]:
+    yield from (ec for ec in containers if isinstance(ec, ectype)) if containers is not None else {}