zepben.ewb 1.0.0__py3-none-any.whl

zepben/ewb/services/network/tracing/networktrace/operators/open_state_operators.py

@@ -0,0 +1,104 @@
+#  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__ = ['OpenStateOperators', 'NormalOpenStateOperators', 'CurrentOpenStateOperators']
+
+from abc import abstractmethod
+from typing import TypeVar, Optional, TYPE_CHECKING, Callable
+
+from zepben.ewb.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
+from zepben.ewb.services.network.tracing.networktrace.conditions.network_trace_queue_condition import NetworkTraceQueueCondition
+from zepben.ewb.services.network.tracing.networktrace.conditions.open_condition import OpenCondition
+from zepben.ewb.services.network.tracing.networktrace.operators import StateOperator
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.wires.switch import Switch
+    from zepben.ewb.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
+
+    T = TypeVar('T')
+
+
+class OpenStateOperators(StateOperator):
+    """
+    Interface for managing the open state of conducting equipment, typically switches.
+    """
+
+    @staticmethod
+    @abstractmethod
+    def is_open_switch(switch: Switch, phase: SinglePhaseKind = None) -> bool:
+        """
+        Checks if the specified switch is open. Optionally checking the state of a specific phase.
+
+        `switch` The switch to check open state.
+        `phase` The specific phase to check, or `null` to check if any phase is open.
+        Returns `True` if open; `False` otherwise.
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    def is_open(cls, conducting_equipment: ConductingEquipment, phase: SinglePhaseKind = None) -> bool:
+        """
+        Convenience method that checks if the `conducting_equipment` is a `Switch` before checking if its open
+
+        :param conducting_equipment: The conducting equipment to check open state
+        :param phase: The specified phase to check, or 'None' to check if any phase is open
+        Returns `True` if conducting equipment is a switch and its open; `False`  otherwise
+        """
+        from zepben.ewb.model.cim.iec61970.base.wires.switch import Switch  # FIXME: circular import
+
+        if isinstance(conducting_equipment, Switch):
+            return cls.is_open_switch(conducting_equipment, phase)
+        return False
+
+    @staticmethod
+    @abstractmethod
+    def set_open(switch: Switch, is_open: bool, phase: SinglePhaseKind = None) -> None:
+        """
+        Sets the open state of the specified switch. Optionally applies the state to a specific phase.
+
+        `switch` The switch for which to set the open state.
+        `isOpen` The desired open state (`True` for open, `False` for closed).
+        `phase` The specific phase to set, or `None` to apply to all phases.
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    def stop_at_open(cls, open_test: Optional[Callable[[Switch, Optional[SinglePhaseKind]], bool]] = None, phase: Optional[SinglePhaseKind] = None) -> \
+    NetworkTraceQueueCondition[T]:
+        return OpenCondition(open_test or cls.is_open, phase)
+
+
+class NormalOpenStateOperators(OpenStateOperators):
+    """
+    Operates on the normal state of the `Switch`
+    """
+
+    @staticmethod
+    def is_open_switch(switch: Switch, phase: SinglePhaseKind = None) -> Optional[bool]:
+        return switch.is_normally_open(phase)
+
+    @staticmethod
+    def set_open(switch: Switch, is_open: bool, phase: SinglePhaseKind = None) -> None:
+        switch.set_normally_open(is_open, phase)
+
+
+class CurrentOpenStateOperators(OpenStateOperators):
+    """
+    Operates on the current state of the `Switch`
+    """
+
+    @staticmethod
+    def is_open_switch(switch: Switch, phase: SinglePhaseKind = None) -> Optional[bool]:
+        return switch.is_open(phase)
+
+    @staticmethod
+    def set_open(switch: Switch, is_open: bool, phase: SinglePhaseKind = None) -> None:
+        switch.set_open(is_open, phase)
+
+
+OpenStateOperators.NORMAL = NormalOpenStateOperators
+OpenStateOperators.CURRENT = CurrentOpenStateOperators

zepben/ewb/services/network/tracing/networktrace/operators/phase_state_operators.py

@@ -0,0 +1,56 @@
+#  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__ = ['PhaseStateOperators', 'NormalPhaseStateOperators', 'CurrentPhaseStateOperators']
+
+from abc import abstractmethod
+from typing import TYPE_CHECKING
+
+from zepben.ewb.services.network.tracing.networktrace.operators import StateOperator
+from zepben.ewb.services.network.tracing.phases.phase_status import PhaseStatus
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.core.terminal import Terminal
+
+
+class PhaseStateOperators(StateOperator):
+    """
+    Interface for accessing the phase status of a terminal.
+    """
+
+    @staticmethod
+    @abstractmethod
+    def phase_status(terminal: 'Terminal') -> PhaseStatus:
+        """
+        Retrieves the phase status of the specified terminal.
+
+        `terminal` The terminal for which to retrieve the phase status.
+        Returns The phase status associated with the specified terminal.
+        """
+        pass
+
+
+class NormalPhaseStateOperators(PhaseStateOperators):
+    """
+    Operates on the normal state of the `Phase`
+    """
+
+    @staticmethod
+    def phase_status(terminal: 'Terminal') -> PhaseStatus:
+        return terminal.normal_phases
+
+
+class CurrentPhaseStateOperators(PhaseStateOperators):
+    """
+    Operates on the current state of the `Phase`
+    """
+
+    @staticmethod
+    def phase_status(terminal: 'Terminal') -> PhaseStatus:
+        return terminal.current_phases
+
+
+PhaseStateOperators.NORMAL = NormalPhaseStateOperators
+PhaseStateOperators.CURRENT = CurrentPhaseStateOperators

zepben/ewb/services/network/tracing/networktrace/tracing.py

@@ -0,0 +1,132 @@
+#  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 logging import Logger
+from typing import TypeVar, Union, Callable, Type
+
+from zepben.ewb.services.network.tracing.networktrace.compute_data import ComputeData, ComputeDataWithPaths
+from zepben.ewb.services.network.tracing.networktrace.network_trace import NetworkTrace
+from zepben.ewb.services.network.tracing.networktrace.network_trace_action_type import NetworkTraceActionType, CanActionItem
+from zepben.ewb.services.network.tracing.networktrace.network_trace_step import NetworkTraceStep
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+from zepben.ewb.services.network.tracing.traversal.queue import TraversalQueue
+
+T = TypeVar('T')
+
+
+class Tracing:
+    @staticmethod
+    def network_trace(
+        network_state_operators: Type[NetworkStateOperators] = NetworkStateOperators.NORMAL,
+        action_step_type: CanActionItem = NetworkTraceActionType.FIRST_STEP_ON_EQUIPMENT,
+        debug_logger: Logger = None,
+        name: str = 'NetworkTrace',
+        queue: TraversalQueue[NetworkTraceStep[T]] = TraversalQueue.depth_first(),
+        compute_data: Union[ComputeData[T], Callable] = None
+    ) -> NetworkTrace[T]:
+        """
+        Creates a `NetworkTrace` that computes contextual data for every step.
+
+        :param network_state_operators: The state operators to make the NetworkTrace state aware. Defaults to `NetworkStateOperators.NORMAL`.
+        :param action_step_type: The action step type to be applied when the trace steps. Defaults to `NetworkTraceActionType.FIRST_STEP_ON_EQUIPMENT`.
+        :param queue: The traversal queue the trace is backed by. Defaults to a depth first queue.
+        :param debug_logger: An optional logger to add information about how the trace is processing items.
+        :param name: An optional name for your trace that can be used for logging purposes.
+        :param compute_data: The computer that provides the `NetworkTraceStep.data` contextual step data for each step in the trace.
+
+        :returns: a new `NetworkTrace`
+        """
+
+        if not isinstance(compute_data, ComputeData):
+            compute_data = ComputeData(compute_data or (lambda *args: None))
+
+        return NetworkTrace.non_branching(
+            network_state_operators,
+            queue,
+            action_step_type,
+            name,
+            compute_data,
+            debug_logger=debug_logger
+        )
+
+    @staticmethod
+    def network_trace_branching(
+        network_state_operators: Type[NetworkStateOperators] = NetworkStateOperators.NORMAL,
+        action_step_type: CanActionItem = NetworkTraceActionType.FIRST_STEP_ON_EQUIPMENT,
+        debug_logger: Logger = None,
+        name: str = 'NetworkTrace',
+        queue_factory: Callable[[], TraversalQueue[NetworkTraceStep[T]]] = lambda: TraversalQueue.depth_first(),
+        branch_queue_factory: Callable[[], TraversalQueue[NetworkTrace[NetworkTraceStep[T]]]] = lambda: TraversalQueue.breadth_first(),
+        compute_data: Union[ComputeData[T], ComputeDataWithPaths[T]] = None
+    ) -> NetworkTrace[T]:
+        """
+        Creates a branching `NetworkTrace` that computes contextual data for every step. A new 'branch' will be created for each terminal
+        where the current terminal in the trace will step to two or more terminals.
+
+        :param network_state_operators: The state operators to make the NetworkTrace state aware. Defaults to `NetworkStateOperators.NORMAL`.
+        :param action_step_type: The action step type to be applied when the trace steps. Defaults to `NetworkTraceActionType.FIRST_STEP_ON_EQUIPMENT`.
+        :param queue_factory: A factory that will produce [TraversalQueue]s used by each branch in the trace to queue steps. Defaults to a factory
+          the creates depth first queues.
+        :param branch_queue_factory: A factory that will produce `TraversalQueue`s used by each branch in the trace to queue branches. Defaults
+          to a factory that creates breadth first queues.
+        :param debug_logger: An optional logger to add information about how the trace is processing items.
+        :param name: An optional name for your trace that can be used for logging purposes.
+        :param compute_data: The computer that provides the `NetworkTraceStep.data` contextual step data for each step in the trace.
+
+        :returns: a new `NetworkTrace`
+        """
+
+        if not isinstance(compute_data, ComputeData):
+            compute_data = ComputeData(compute_data or (lambda *args: None))
+
+        return NetworkTrace.branching(
+            network_state_operators,
+            queue_factory,
+            branch_queue_factory,
+            action_step_type,
+            name,
+            None,
+            compute_data,
+            debug_logger=debug_logger
+        )
+
+    @staticmethod
+    def set_direction(debug_logger: Logger = None):
+        from zepben.ewb.services.network.tracing.feeder.set_direction import SetDirection
+        return SetDirection(debug_logger=debug_logger)
+
+    @staticmethod
+    def clear_direction(debug_logger: Logger = None):
+        from zepben.ewb.services.network.tracing.feeder.clear_direction import ClearDirection
+        return ClearDirection(debug_logger=debug_logger)
+
+    @staticmethod
+    def assign_equipment_to_feeders(debug_logger: Logger = None):
+        from zepben.ewb.services.network.tracing.feeder.assign_to_feeders import AssignToFeeders
+        return AssignToFeeders(debug_logger=debug_logger)
+
+    @staticmethod
+    def assign_equipment_to_lv_feeders(debug_logger: Logger = None):
+        from zepben.ewb.services.network.tracing.feeder.assign_to_lv_feeders import AssignToLvFeeders
+        return AssignToLvFeeders(debug_logger=debug_logger)
+
+    @staticmethod
+    def set_phases(debug_logger: Logger = None):
+        from zepben.ewb.services.network.tracing.phases.set_phases import SetPhases
+        return SetPhases(debug_logger=debug_logger)
+
+    @staticmethod
+    def remove_phases(debug_logger: Logger = None):
+        from zepben.ewb.services.network.tracing.phases.remove_phases import RemovePhases
+        return RemovePhases(debug_logger=debug_logger)
+
+    @staticmethod
+    def phase_inferrer(debug_logger: Logger = None):
+        from zepben.ewb.services.network.tracing.phases.phase_inferrer import PhaseInferrer
+        return PhaseInferrer(debug_logger=debug_logger)
+
+    @staticmethod
+    def find_swer_equipment(debug_logger: Logger = None):
+        from zepben.ewb.services.network.tracing.find_swer_equipment import FindSwerEquipment
+        return FindSwerEquipment(debug_logger=debug_logger)

zepben/ewb/services/network/tracing/phases/__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/services/network/tracing/phases/phase_inferrer.py

@@ -0,0 +1,205 @@
+#  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__ = ["PhaseInferrer"]
+
+from dataclasses import dataclass
+from typing import Dict, Callable, List, Set, Awaitable, Type, TYPE_CHECKING
+
+from zepben.ewb import Terminal, SinglePhaseKind, ConductingEquipment, NetworkService, \
+    FeederDirection, X_PRIORITY, Y_PRIORITY, is_before, is_after
+from zepben.ewb.services.network.tracing.networktrace.operators.network_state_operators import NetworkStateOperators
+from zepben.ewb.services.network.tracing.networktrace.tracing import Tracing
+
+if TYPE_CHECKING:
+    from logging import Logger
+
+
+class PhaseInferrer:
+    """
+    A class that can infer missing phases on a network that has been processed by `SetPhases`.
+    """
+
+    def __init__(self, debug_logger: Logger = None):
+        self._debug_logger = debug_logger
+
+    @dataclass
+    class InferredPhase:
+        def __init__(self, conducting_equipment: ConductingEquipment, suspect: bool):
+            self.conducting_equipment = conducting_equipment
+            self.suspect = suspect
+
+        @property
+        def description(self) -> str:
+            if self.suspect:
+                _inner_desc = f"phases for '{str(self.conducting_equipment)}' which may not be correct. The phases were inferred"
+            else:
+                _inner_desc = f"phase for '{str(self.conducting_equipment)}' which should be correct. The phase was inferred"
+            return (f'Inferred missing {_inner_desc} due to a disconnected nominal phase because of an '
+                    f'upstream error in the source data. Phasing information for the upstream equipment should be fixed in the source system.')
+
+    async def run(self, network: NetworkService, network_state_operators: Type[NetworkStateOperators] = NetworkStateOperators.NORMAL) -> list[InferredPhase]:
+        """
+        Infer the missing phases on the specified `network`.
+
+        :param network: The `NetworkService` to infer phases on.
+        :param network_state_operators: The `NetworkStateOperators` to be used when inferring phases
+        """
+
+        tracking: Dict[ConductingEquipment, bool] = {}
+
+        await self.PhaseInferrerInternal(network_state_operators, self._debug_logger).infer_missing_phases(network, tracking)
+
+        return [self.InferredPhase(k, v) for k, v in tracking.items()]
+
+    class PhaseInferrerInternal:
+        def __init__(self, state_operators: Type[NetworkStateOperators], debug_logger: Logger = None):
+            self.state_operators = state_operators
+            self._debug_logger = debug_logger
+
+        async def infer_missing_phases(self, network: NetworkService, tracking: Dict[ConductingEquipment, bool]):
+            while True:
+                terms_missing_phases = [it for it in network.objects(Terminal) if self._is_connected_to_others(it) and self._has_none_phase(it)]
+                terms_missing_xy_phases = [it for it in terms_missing_phases if self._has_xy_phases(it)]
+
+                if not (await self._process(terms_missing_phases, lambda t: self._set_missing_to_nominal(t, tracking))
+                        or await self._process(terms_missing_xy_phases, lambda t: self._infer_xy_phases(t, 1, tracking))
+                        or await self._process(terms_missing_xy_phases, lambda t: self._infer_xy_phases(t, 4, tracking))
+                ):
+                    break
+
+        @staticmethod
+        def _is_connected_to_others(terminal: Terminal) -> bool:
+            return terminal.connectivity_node and (terminal.connectivity_node.num_terminals() > 1)
+
+        def _has_none_phase(self, terminal: Terminal) -> bool:
+            phases = self.state_operators.phase_status(terminal)
+            return any(phases[it] == SinglePhaseKind.NONE for it in terminal.phases.single_phases)
+
+        @staticmethod
+        def _has_xy_phases(terminal: Terminal) -> bool:
+            return SinglePhaseKind.Y in terminal.phases.single_phases or SinglePhaseKind.X in terminal.phases.single_phases
+
+        def _find_terminal_at_start_of_missing_phases(
+            self,
+            terminals: List[Terminal],
+        ) -> List[Terminal]:
+            return (
+                self._missing_from_down_to_up(terminals)
+                or self._missing_from_down_to_any(terminals)
+                or self._missing_from_any(terminals)
+            )
+
+        def _missing_from_down_to_up(self, terminals: List[Terminal]) -> List[Terminal]:
+            return [
+                terminal for terminal in terminals
+                if (FeederDirection.UPSTREAM in self.state_operators.get_direction(terminal))
+                   and self._missing_from_down_filter(terminal)
+            ]
+
+        def _missing_from_down_to_any(self, terminals: List[Terminal]) -> List[Terminal]:
+            return [
+                terminal for terminal in terminals
+                if self._missing_from_down_filter(terminal)
+            ]
+
+        def _missing_from_down_filter(self, terminal: Terminal) -> bool:
+            return (
+                self._has_none_phase(terminal) and terminal.connectivity_node and
+                any(not self._has_none_phase(t)
+                    for t in terminal.connectivity_node.terminals
+                    if (t != terminal) and (FeederDirection.DOWNSTREAM in self.state_operators.get_direction(t)))
+            )
+
+        def _missing_from_any(self, terminals: List[Terminal]) -> List[Terminal]:
+            return [
+                terminal for terminal in terminals
+                if (self._has_none_phase(terminal) and
+                    terminal.connectivity_node and
+                    any(not self._has_none_phase(t) for t in terminal.connectivity_node.terminals if t != terminal))
+            ]
+
+        async def _process(self, terminals: List[Terminal], processor: Callable[[Terminal], Awaitable[bool]]) -> bool:
+
+            has_processed = False
+            while True:
+                continue_processing = False
+
+                for terminal in self._find_terminal_at_start_of_missing_phases(terminals):
+                    continue_processing = await processor(terminal)
+
+                has_processed = has_processed or continue_processing
+                if not continue_processing:
+                    break
+
+            return has_processed
+
+        async def _set_missing_to_nominal(self, terminal: Terminal, tracking: Dict[ConductingEquipment, bool]) -> bool:
+            phases = self.state_operators.phase_status(terminal)
+
+            phases_to_process = [it for it in terminal.phases.single_phases if
+                                 it not in [SinglePhaseKind.X, SinglePhaseKind.Y] and (phases[it] == SinglePhaseKind.NONE)]
+
+            if not phases_to_process:
+                return False
+
+            for it in phases_to_process:
+                phases[it] = it
+            await self._continue_phases(terminal)
+
+            if terminal.conducting_equipment:
+                tracking[terminal.conducting_equipment] = False
+
+            return True
+
+        async def _infer_xy_phases(self, terminal: Terminal, max_missing_phases: int, tracking: Dict[ConductingEquipment, bool]) -> bool:
+            none: List[SinglePhaseKind] = []
+            used_phases: Set[SinglePhaseKind] = set()
+
+            if not terminal.conducting_equipment:
+                return False
+
+            phases = self.state_operators.phase_status(terminal)
+            for nominal_phase in terminal.phases:
+                phase = phases[nominal_phase]
+                if phase == SinglePhaseKind.NONE:
+                    none.append(nominal_phase)
+                else:
+                    used_phases.add(phase)
+
+            if not none or (len(none) > max_missing_phases):
+                return False
+
+            tracking[terminal.conducting_equipment] = True
+
+            had_changes = False
+            for nominal_phase in none:
+                if nominal_phase == SinglePhaseKind.X:
+                    new_phase = self._first_unused(X_PRIORITY, used_phases, lambda it: is_before(it, phases[SinglePhaseKind.Y]))
+                else:
+                    new_phase = self._first_unused(Y_PRIORITY, used_phases, lambda it: is_after(it, phases[SinglePhaseKind.X]))
+
+                if new_phase != SinglePhaseKind.NONE:
+                    phases[nominal_phase] = new_phase
+                    used_phases.add(phases[nominal_phase])
+                    had_changes = True
+
+            await self._continue_phases(terminal)
+            return had_changes
+
+        async def _continue_phases(self, terminal: Terminal):
+            set_phases_trace = Tracing.set_phases(debug_logger=self._debug_logger)
+            for other in terminal.other_terminals():
+                await set_phases_trace.run(other, terminal.phases.single_phases, network_state_operators=self.state_operators, seed_terminal=terminal)
+
+        @staticmethod
+        def _first_unused(phases: List[SinglePhaseKind], used_phases: Set[SinglePhaseKind], validate: Callable[[SinglePhaseKind], bool]) -> SinglePhaseKind:
+            for phase in phases:
+                if (phase not in used_phases) and validate(phase):
+                    return phase
+
+            return SinglePhaseKind.NONE

zepben/ewb/services/network/tracing/phases/phase_status.py

@@ -0,0 +1,101 @@
+#  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__ = ["normal_phases", "current_phases", "PhaseStatus", "NormalPhases", "CurrentPhases"]
+
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from zepben.ewb import Terminal
+from zepben.ewb.model.cim.iec61970.base.core.phase_code import phase_code_from_single_phases, PhaseCode
+
+from zepben.ewb.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
+from abc import ABC, abstractmethod
+
+
+def normal_phases(terminal: Terminal):
+    return NormalPhases(terminal)
+
+
+def current_phases(terminal: Terminal):
+    return CurrentPhases(terminal)
+
+
+class PhaseStatus(ABC):
+    terminal: Terminal
+
+    def __init__(self, terminal: Terminal):
+        self.terminal = terminal
+
+    @abstractmethod
+    def __getitem__(self, nominal_phase: SinglePhaseKind) -> SinglePhaseKind:
+        """
+        Get the traced phase for the specified `nominal_phase`.
+
+        `nominal_phase` The nominal phase you are interested in querying.
+
+        Returns the traced phase.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def __setitem__(self, nominal_phase: SinglePhaseKind, traced_phase: SinglePhaseKind) -> bool:
+        """
+        Set the traced phase for the specified `nominal_phase`.
+
+        `nominal_phase` The nominal phase you are interested in updating.
+
+        `traced_phase` The phase you wish to set for this `nominal_phase`. Specify `SinglePhaseKind.NONE` to clear the phase.
+
+        Returns True if the phase is updated, otherwise False.
+        """
+        raise NotImplementedError()
+
+    def as_phase_code(self) -> Optional[PhaseCode]:
+        """
+        Get the traced phase for each nominal phase as a `PhaseCode`.
+
+        Returns The `PhaseCode` if the combination of phases makes sense, otherwise `None`.
+        """
+        if self.terminal.phases == PhaseCode.NONE:
+            return PhaseCode.NONE
+
+        traced_phases = [self[it] for it in self.terminal.phases]
+        phases = set(traced_phases)
+
+        if phases == {SinglePhaseKind.NONE}:
+            return PhaseCode.NONE
+        elif SinglePhaseKind.NONE in phases:
+            return None
+        elif len(phases) == len(traced_phases):
+            return phase_code_from_single_phases(phases)
+        else:
+            return None
+
+
+class NormalPhases(PhaseStatus):
+    """
+    The traced phases in the normal state of the network.
+    """
+
+    def __getitem__(self, nominal_phase: SinglePhaseKind) -> SinglePhaseKind:
+        return self.terminal.traced_phases.normal(nominal_phase)
+
+    def __setitem__(self, nominal_phase: SinglePhaseKind, traced_phase: SinglePhaseKind) -> bool:
+        return self.terminal.traced_phases.set_normal(nominal_phase, traced_phase)
+
+
+class CurrentPhases(PhaseStatus):
+    """
+    The traced phases in the current state of the network.
+    """
+
+    def __getitem__(self, nominal_phase: SinglePhaseKind) -> SinglePhaseKind:
+        return self.terminal.traced_phases.current(nominal_phase)
+
+    def __setitem__(self, nominal_phase: SinglePhaseKind, traced_phase: SinglePhaseKind) -> bool:
+        return self.terminal.traced_phases.set_current(nominal_phase, traced_phase)