zepben.ewb 1.0.0__py3-none-any.whl

zepben/ewb/model/cim/iec61968/operations/operational_restriction.py

@@ -0,0 +1,92 @@
+#  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__ = ["OperationalRestriction"]
+
+from typing import Optional, Generator, List, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61968.common.document import Document
+from zepben.ewb.util import get_by_mrid, nlen, ngen, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.core.equipment import Equipment
+
+
+class OperationalRestriction(Document):
+    """
+    A document that can be associated with equipment to describe any sort of restrictions compared with the
+    original manufacturer's specification or with the usual operational practice e.g.
+    temporary maximum loadings, maximum switching current, do not operate if bus couplers are open, etc.
+
+    In the UK, for example, if a breaker or switch ever mal-operates, this is reported centrally and utilities
+    use their asset systems to identify all the installed devices of the same manufacturer's type.
+    They then apply operational restrictions in the operational systems to warn operators of potential problems.
+    After appropriate inspection and maintenance, the operational restrictions may be removed.
+    """
+    _equipment: Optional[List[Equipment]] = None
+
+    def __init__(self, equipment: List[Equipment] = None, **kwargs):
+        super(OperationalRestriction, self).__init__(**kwargs)
+        if equipment:
+            for eq in equipment:
+                self.add_equipment(eq)
+
+    def num_equipment(self):
+        """
+        Returns the number of `Equipment` associated with this `OperationalRestriction`
+        """
+        return nlen(self._equipment)
+
+    @property
+    def equipment(self) -> Generator[Equipment, None, None]:
+        """
+        The `Equipment` to which this `OperationalRestriction` applies.
+        """
+        return ngen(self._equipment)
+
+    def get_equipment(self, mrid: str) -> Equipment:
+        """
+        Get the `Equipment` for this `OperationalRestriction` identified by `mrid`
+
+        `mrid` The mRID of the required `Equipment`
+        Returns The `Equipment` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._equipment, mrid)
+
+    def add_equipment(self, equipment: Equipment) -> OperationalRestriction:
+        """
+        Associate an `Equipment` with this `OperationalRestriction`
+
+        `equipment` The `Equipment` to associate with this `OperationalRestriction`.
+        Returns A reference to this `OperationalRestriction` to allow fluent use.
+        Raises `ValueError` if another `Equipment` with the same `mrid` already exists for this `OperationalRestriction`.
+        """
+        if self._validate_reference(equipment, self.get_equipment, "An Equipment"):
+            return self
+        self._equipment = list() if self._equipment is None else self._equipment
+        self._equipment.append(equipment)
+        return self
+
+    def remove_equipment(self, equipment: Equipment) -> OperationalRestriction:
+        """
+        Disassociate `equipment` from this `OperationalRestriction`.
+
+        `equipment` The `Equipment` to disassociate from this `OperationalRestriction`.
+        Returns A reference to this `OperationalRestriction` to allow fluent use.
+        Raises `ValueError` if `equipment` was not associated with this `OperationalRestriction`.
+        """
+        self._equipment = safe_remove(self._equipment, equipment)
+        return self
+
+    def clear_equipment(self) -> OperationalRestriction:
+        """
+        Clear all equipment.
+        Returns A reference to this `OperationalRestriction` to allow fluent use.
+        """
+        self._equipment = None
+        return self

zepben/ewb/model/cim/iec61970/__init__.py

@@ -0,0 +1,4 @@
+#  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/.

zepben/ewb/model/cim/iec61970/base/__init__.py

@@ -0,0 +1,4 @@
+#  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/.

zepben/ewb/model/cim/iec61970/base/auxiliaryequipment/__init__.py

@@ -0,0 +1,4 @@
+#  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/.

zepben/ewb/model/cim/iec61970/base/auxiliaryequipment/auxiliary_equipment.py

@@ -0,0 +1,24 @@
+#  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__ = ["AuxiliaryEquipment"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.core.equipment import Equipment
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.core.terminal import Terminal
+
+
+class AuxiliaryEquipment(Equipment):
+    """
+    `AuxiliaryEquipment` describe equipment that is not performing any primary functions but support for the
+    equipment performing the primary function.
+
+    `AuxiliaryEquipment` is attached to primary equipment via an association with `Terminal`.
+    """
+    terminal: Optional['Terminal'] = None
+    """The `zepben.ewb.model.cim.iec61970.base.core.terminal.Terminal`` at the `Equipment` where the `AuxiliaryEquipment` is attached."""

zepben/ewb/model/cim/iec61970/base/auxiliaryequipment/current_transformer.py

@@ -0,0 +1,37 @@
+#  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__ = ["CurrentTransformer"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.auxiliaryequipment.sensor import Sensor
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61968.infiec61968.infassetinfo.current_transformer_info import CurrentTransformerInfo
+
+
+class CurrentTransformer(Sensor):
+    """
+    Instrument transformer used to measure electrical qualities of the circuit that is being protected and/or monitored.
+    Typically used as current transducer for the purpose of metering or protection.
+    A typical secondary current rating would be 5A.
+    """
+
+    core_burden: Optional[int] = None
+    """Power burden of the CT core in watts."""
+
+    @property
+    def current_transformer_info(self) -> Optional['CurrentTransformerInfo']:
+        """The `CurrentTransformerInfo` for this `CurrentTransformer`"""
+        return self.asset_info
+
+    @current_transformer_info.setter
+    def current_transformer_info(self, cti: Optional['CurrentTransformerInfo']):
+        """
+        Set the `CurrentTransformerInfo` for this `CurrentTransformer`
+        `cti` The `CurrentTransformerInfo` for this `CurrentTransformer`
+        """
+        self.asset_info = cti

zepben/ewb/model/cim/iec61970/base/auxiliaryequipment/fault_indicator.py

@@ -0,0 +1,18 @@
+#  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/.
+
+__all__ = ["FaultIndicator"]
+
+from zepben.ewb.model.cim.iec61970.base.auxiliaryequipment.auxiliary_equipment import AuxiliaryEquipment
+
+
+class FaultIndicator(AuxiliaryEquipment):
+    """
+    A FaultIndicator is typically only an indicator (which may or may not be remotely monitored), and not a piece of
+    equipment that actually initiates a protection event. It is used for FLISR (Fault Location, Isolation and
+    Restoration) purposes, assisting with the dispatch of crews to "most likely" part of the network (i.e. assists
+    with determining circuit section where the fault most likely happened).
+    """
+    pass

zepben/ewb/model/cim/iec61970/base/auxiliaryequipment/potential_transformer.py

@@ -0,0 +1,38 @@
+#  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__ = ["PotentialTransformer"]
+
+from typing import Optional, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.auxiliaryequipment.potential_transformer_kind import PotentialTransformerKind
+from zepben.ewb.model.cim.iec61970.base.auxiliaryequipment.sensor import Sensor
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61968.infiec61968.infassetinfo.potential_transformer_info import PotentialTransformerInfo
+
+
+class PotentialTransformer(Sensor):
+    """
+    Instrument transformer (also known as Voltage Transformer) used to measure electrical qualities of the circuit that
+    is being protected and/or monitored. Typically used as voltage transducer for the purpose of metering, protection, or
+    sometimes auxiliary substation supply. A typical secondary voltage rating would be 120V.
+    """
+
+    type: PotentialTransformerKind = PotentialTransformerKind.UNKNOWN
+    """Potential transformer construction type."""
+
+    @property
+    def potential_transformer_info(self) -> Optional['PotentialTransformerInfo']:
+        """The `PotentialTransformerInfo` for this `PotentialTransformer`"""
+        return self.asset_info
+
+    @potential_transformer_info.setter
+    def potential_transformer_info(self, vti: Optional['PotentialTransformerInfo']):
+        """
+        Set the `PotentialTransformerInfo` for this `PotentialTransformer`
+        `vti` The `PotentialTransformerInfo` for this `PotentialTransformer`
+        """
+        self.asset_info = vti

zepben/ewb/model/cim/iec61970/base/auxiliaryequipment/potential_transformer_kind.py

@@ -0,0 +1,30 @@
+#  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__ = ["PotentialTransformerKind"]
+
+from enum import Enum
+
+from zepben.ewb import unique
+
+
+@unique
+class PotentialTransformerKind(Enum):
+    """
+    The construction kind of the potential transformer.
+    """
+
+    UNKNOWN = 0
+    """The construction type of the potential transformer is unknown."""
+
+    inductive = 1
+    """The potential transformer is using induction coils to create secondary voltage."""
+
+    capacitiveCoupling = 2
+    """The potential transformer is using capacitive coupling to create secondary voltage."""
+
+    @property
+    def short_name(self):
+        return str(self)[25:]

zepben/ewb/model/cim/iec61970/base/auxiliaryequipment/sensor.py

@@ -0,0 +1,92 @@
+#  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__ = ["Sensor"]
+
+from typing import Generator, Optional, List, TYPE_CHECKING, Iterable
+
+from zepben.ewb.model.cim.iec61970.base.auxiliaryequipment.auxiliary_equipment import AuxiliaryEquipment
+from zepben.ewb.util import ngen, nlen, get_by_mrid, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.extensions.iec61970.base.protection.protection_relay_function import ProtectionRelayFunction
+
+
+class Sensor(AuxiliaryEquipment):
+    """
+    This class describes devices that transform a measured quantity into signals that can be presented at displays,
+    used in control or be recorded.
+    """
+
+    _relay_functions: Optional[List[ProtectionRelayFunction]] = None
+    """The relay functions influenced by this [Sensor]."""
+
+    def __init__(self, relay_functions: Iterable[ProtectionRelayFunction] = None, **kwargs):
+        super(Sensor, self).__init__(**kwargs)
+        if relay_functions is not None:
+            for relay_function in relay_functions:
+                self.add_relay_function(relay_function)
+
+    @property
+    def relay_functions(self) -> Generator[ProtectionRelayFunction, None, None]:
+        """
+        Yields all the :class:`ProtectionRelayFunction` that are influenced by this :class:`Sensor`.
+
+        :return: A generator that iterates over all ProtectionRelayFunction influenced by this Sensor.
+        """
+        return ngen(self._relay_functions)
+
+    def num_relay_functions(self) -> int:
+        """
+        Get the number of :class:`ProtectionRelayFunction` that are influenced by this :class:`Sensor`.
+
+        :return: The number of ProtectionRelayFunction influenced by this Sensor.
+        """
+        return nlen(self._relay_functions)
+
+    def get_relay_function(self, mrid: str) -> ProtectionRelayFunction:
+        """
+        Get a :class:`ProtectionRelayFunction` that are influenced by this :class:`Sensor`.
+
+        :param mrid: The mRID of the desired ProtectionRelayFunction
+        :return: The ProtectionRelayFunction with the specified mRID if it exists, otherwise None.
+        :raises KeyError: If `mrid` wasn't present.
+        """
+        return get_by_mrid(self._relay_functions, mrid)
+
+    def add_relay_function(self, protection_relay_function: ProtectionRelayFunction) -> Sensor:
+        """
+        Associate this :class:`Sensor` with a :class:`ProtectionRelayFunction` it is influencing.
+
+        :param protection_relay_function: The ProtectionRelayFunction to associate with this Sensor.
+        :return: A reference to this Sensor for fluent use.
+        """
+        if self._validate_reference(protection_relay_function, self.get_relay_function, "A ProtectionRelayFunction"):
+            return self
+
+        self._relay_functions = list() if self._relay_functions is None else self._relay_functions
+        self._relay_functions.append(protection_relay_function)
+        return self
+
+    def remove_relay_function(self, protection_relay_function: ProtectionRelayFunction) -> Sensor:
+        """
+        Disassociate this :class:`Sensor` from a :class:`ProtectionRelayFunction` it is influencing.
+
+        :param protection_relay_function: The ProtectionRelayFunction to disassociate from this Sensor.
+        :return: A reference to this Sensor for fluent use.
+        """
+        self._relay_functions = safe_remove(self._relay_functions, protection_relay_function)
+        return self
+
+    def clear_relay_function(self) -> Sensor:
+        """
+        Disassociate all :class:`ProtectionRelayFunction` from this :class:`Sensor`.
+
+        :return: A reference to this Sensor for fluent use.
+        """
+        self._relay_functions = None
+        return self

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

@@ -0,0 +1,4 @@
+#  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/.

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

@@ -0,0 +1,16 @@
+#  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/.
+
+__all__ = ["AcDcTerminal"]
+
+from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+
+
+class AcDcTerminal(IdentifiedObject):
+    """
+    An electrical connection point (AC or DC) to a piece of conducting equipment. Terminals are connected at physical
+    connection points called connectivity nodes.
+    """
+    pass

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

@@ -0,0 +1,17 @@
+#  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__ = ["BaseVoltage"]
+
+from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+
+
+class BaseVoltage(IdentifiedObject):
+    """
+    Defines a system base voltage which is referenced.
+    """
+
+    nominal_voltage: int = 0
+    """The power system resource's base voltage."""

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

@@ -0,0 +1,198 @@
+#  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__ = ['ConductingEquipment']
+
+import sys
+from typing import List, Optional, Generator, TYPE_CHECKING, Union
+
+from zepben.ewb.model.cim.iec61970.base.core.equipment import Equipment
+from zepben.ewb.util import get_by_mrid, require, ngen
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.core.base_voltage import BaseVoltage
+    from zepben.ewb.model.cim.iec61970.base.core.terminal import Terminal
+
+
+class ConductingEquipment(Equipment):
+    """
+    Abstract class, should only be used through subclasses.
+    The parts of the AC power system that are designed to carry current or that are conductively connected through
+    terminals.
+
+    ConductingEquipment are connected by `Terminal`'s which are in turn associated with
+    `ConnectivityNode`'s. Each `Terminal` is associated with
+    _exactly one_ `ConnectivityNode`, and through that `ConnectivityNode` can be linked with many other `Terminals` and `ConductingEquipment`.
+    """
+
+    base_voltage: Optional[BaseVoltage] = None
+    """
+    `BaseVoltage` of this `ConductingEquipment`. Use only when there is no voltage level container used and only one base voltage applies. For example, not
+    used for transformers.
+    """
+
+    _terminals: List[Terminal] = []
+    max_terminals = int(sys.maxsize)
+
+    def __init__(self, terminals: List[Terminal] = None, **kwargs):
+        super(ConductingEquipment, self).__init__(**kwargs)
+        if terminals:
+            for term in terminals:
+                if term.conducting_equipment is None:
+                    term.conducting_equipment = self
+                self.add_terminal(term)
+
+    # pylint: disable=unused-argument
+    def get_base_voltage(self, terminal: Terminal = None):
+        """
+        Get the `BaseVoltage` of this `ConductingEquipment`.
+        Note `terminal` is not used here, but this method can be overridden in child classes (e.g PowerTransformer).
+
+        `terminal` The `Terminal` to get the voltage at.
+        Returns thee BaseVoltage of this `ConductingEquipment` at `terminal`
+        """
+        return self.base_voltage
+
+    # pylint: enable=unused-argument
+
+    @property
+    def base_voltage_value(self) -> int:
+        """
+        :return: The value of the nominal voltage for the base voltage if there is one, otherwise 0.
+        """
+        return self.base_voltage.nominal_voltage if self.base_voltage and self.base_voltage.nominal_voltage else 0
+
+    @property
+    def terminals(self) -> Generator[Terminal, None, None]:
+        """
+        `ConductingEquipment` have `Terminal`s that may be connected to other `ConductingEquipment`
+        `Terminal`s via `ConnectivityNode`s.
+        """
+        return ngen(self._terminals)
+
+    def num_terminals(self):
+        """
+        Get the number of `Terminal`s for this `ConductingEquipment`.
+        """
+        return len(self._terminals)
+
+    def get_terminal(self, identifier: Union[int, str]):
+        """
+        Get the `Terminal` for this `ConductingEquipment` identified by `mrid` or `sequence_number`
+
+        :param identifier: the mRID of the required `Terminal`, or the `sequence_number` of the terminal in relation
+            to this `ConductingEquipment`
+        :return: The `Terminal` with the specified `mrid` if it exists
+
+        Raises `KeyError` if `mrid` wasn't present.
+        Raises `TypeError` if the identifier wasn't a recognised type
+        """
+        if isinstance(identifier, int):
+            return self.get_terminal_by_sn(identifier)
+        elif isinstance(identifier, str):
+            return self.get_terminal_by_mrid(identifier)
+        raise TypeError(f'`identifier` parameter not a recognised type: {type(identifier)}')
+
+    def get_terminal_by_mrid(self, mrid: str) -> Terminal:
+        """
+        Get the `Terminal` for this `ConductingEquipment` identified by `mrid`
+
+        :param mrid: the mRID of the required `Terminal`
+
+        :return: The `Terminal` with the specified `mrid` if it exists
+
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._terminals, mrid)
+
+    def get_terminal_by_sn(self, sequence_number: int):
+        """
+        Get the `Terminal` on this `ConductingEquipment` by its `sequence_number`.
+
+        :param sequence_number: The `sequence_number` of the `Terminal` in relation to this `ConductingEquipment`.
+
+        :return: The `Terminal` on this `ConductingEquipment` with sequence number `sequence_number`
+
+        Raises IndexError if no `Terminal` was found with sequence_number `sequence_number`.
+        """
+        for term in self._terminals:
+            if term.sequence_number == sequence_number:
+                return term
+        raise IndexError(f"No Terminal with sequence_number {sequence_number} was found in ConductingEquipment {str(self)}")
+
+    def __getitem__(self, item: int):
+        return self.get_terminal_by_sn(item)
+
+    def add_terminal(self, terminal: Terminal) -> ConductingEquipment:
+        """
+        Associate `terminal` with this `ConductingEquipment`. If `terminal.sequence_number` == 0, the terminal will be assigned a sequence_number of
+        `self.num_terminals() + 1`.
+
+        `terminal` The `Terminal` to associate with this `ConductingEquipment`.
+        Returns A reference to this `ConductingEquipment` to allow fluent use.
+        Raises `ValueError` if another `Terminal` with the same `mrid` already exists for this `ConductingEquipment`.
+        Raises `ValueError` if `max_terminals` has already been reached.
+        """
+        if self._validate_terminal(terminal):
+            return self
+
+        require(self.num_terminals() < self.max_terminals,
+                lambda: f"Unable to add {terminal} to {str(self)}. This conducting equipment already has the maximum number of terminals ({self.max_terminals}).")
+
+        if terminal.sequence_number == 0:
+            terminal.sequence_number = self.num_terminals() + 1
+
+        self._terminals.append(terminal)
+        self._terminals.sort(key=lambda t: t.sequence_number)
+
+        return self
+
+    def remove_terminal(self, terminal: Terminal) -> ConductingEquipment:
+        """
+        Disassociate `terminal` from this `ConductingEquipment`
+
+        `terminal` the `Terminal` to disassociate from this `ConductingEquipment`.
+        Returns A reference to this `ConductingEquipment` to allow fluent use.
+        Raises `ValueError` if `terminal` was not associated with this `ConductingEquipment`.
+        """
+        self._terminals.remove(terminal)
+        return self
+
+    def clear_terminals(self) -> ConductingEquipment:
+        """
+        Clear all terminals.
+        Returns A reference to this `ConductingEquipment` to allow fluent use.
+        """
+        self._terminals.clear()
+        return self
+
+    def __repr__(self):
+        return (f"{super(ConductingEquipment, self).__repr__()}, in_service={self.in_service}, "
+                f"normally_in_service={self.normally_in_service}, location={self.location}"
+                )
+
+    def _validate_terminal(self, terminal: Terminal) -> bool:
+        """
+        Validate a terminal against this `ConductingEquipment`'s `Terminal`s.
+
+        `terminal` The `Terminal` to validate.
+        Returns True if `Terminal`` is already associated with this `ConductingEquipment`, otherwise False.
+        Raises `ValueError` if `Terminal`s `conducting_equipment` is not this `ConductingEquipment`,
+        or if this `ConductingEquipment` has a different `Terminal` with the same mRID.
+        """
+        if self._validate_reference(terminal, self.get_terminal_by_mrid, "A Terminal"):
+            return True
+
+        if self._validate_reference_by_field(terminal, terminal.sequence_number, self.get_terminal_by_sn, "sequence_number"):
+            return True
+
+        if not terminal.conducting_equipment:
+            terminal.conducting_equipment = self
+
+        require(terminal.conducting_equipment is self,
+                lambda: f"Terminal {terminal} references another piece of conducting equipment {terminal.conducting_equipment}, expected {str(self)}.")
+        return False