zepben.ewb 1.0.0__py3-none-any.whl

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

@@ -0,0 +1,239 @@
+#  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__ = ["IdentifiedObject", "TIdentifiedObject"]
+
+import logging
+from abc import ABCMeta
+from typing import Callable, Any, List, Generator, Optional, overload, TypeVar
+
+from zepben.ewb.dataclassy import dataclass
+from zepben.ewb.model.cim.iec61970.base.core.name import Name
+from zepben.ewb.model.cim.iec61970.base.core.name_type import NameType
+from zepben.ewb.util import require, CopyableUUID, nlen, ngen, safe_remove
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class IdentifiedObject(object, metaclass=ABCMeta):
+    """
+    Root class to provide common identification for all classes needing identification and naming attributes.
+    Everything should extend this class, however it's not mandated that every subclass must use all the fields
+    defined here.
+
+    All names of attributes of classes extending this class *must* directly reflect CIM properties if they have a direct
+    relation, however must be in snake case to keep the phases PEP compliant.
+    """
+
+    mrid: str = CopyableUUID()
+    """Master resource identifier issued by a model authority. The mRID is unique within an exchange context. 
+    Global uniqueness is easily achieved by using a UUID, as specified in RFC 4122, for the mRID. The use of UUID is strongly recommended."""
+
+    name: Optional[str] = None
+    """The name is any free human readable and possibly non unique text naming the object."""
+
+    description: Optional[str] = None
+    """a free human readable text describing or naming the object. It may be non unique and may not correlate to a naming hierarchy."""
+
+    _names: Optional[List[Name]] = None
+
+    # TODO: Missing num_diagram_objects: int = None  def has_diagram_objects(self): return (self.num_diagram_objects or 0) > 0
+
+    def __init__(self, names: Optional[List[Name]] = None, **kwargs):
+        super(IdentifiedObject, self).__init__(**kwargs)
+        if names:
+            for name in names:
+                self.add_name(name.type, name.name)
+
+    def __str__(self):
+        class_name = f'{self.__class__.__name__}'
+        if self.name:
+            return f'{class_name}{{{self.mrid}|{self.name}}}'
+        return f'{class_name}{{{self.mrid}}}'
+
+    @property
+    def names(self) -> Generator[Name, None, None]:
+        """All names of this identified object. The returned collection is read only."""
+        return ngen(self._names)
+
+    def num_names(self) -> int:
+        """Get the number of entries in the `Name` collection."""
+        return nlen(self._names)
+
+    @overload
+    def has_name(self, name_type: NameType, name: str) -> bool:
+        ...
+
+    @overload
+    def has_name(self, name_type: str, name: str) -> bool:
+        ...
+
+    def has_name(self, name_type, name) -> bool:
+        """
+        Check to see if this object has a `Name` with the matching `name_type` and `name`
+
+        :return: True if a matching `Name` was found, otherwise False.
+        """
+        if self._names:
+            for name_ in self._names:
+                if isinstance(name_type, str):
+                    if name_.type.name == name_type and name_.name == name:
+                        return True
+                elif isinstance(name_type, NameType):
+                    if name_.type == name_type and name_.name == name:
+                        return True
+        return False
+
+    @overload
+    def get_name(self, name_type: NameType, name: str) -> Name:
+        ...
+
+    @overload
+    def get_name(self, name_type: str, name: str) -> Name:
+        ...
+
+    def get_name(self, name_type, name):
+        """
+        Find the `Name` with the matching `name_type` and `name`
+
+        :return: The matched Name or None
+        :raises KeyError: If `name` in `name_type` wasn't present.
+        """
+        if self._names:
+            for name_ in self._names:
+                if isinstance(name_type, str):
+                    if name_.type.name == name_type and name_.name == name:
+                        return name_
+                elif isinstance(name_type, NameType):
+                    if name_.type == name_type and name_.name == name:
+                        return name_
+        raise KeyError(name_type, name)
+
+    @overload
+    def get_names(self, name_type: NameType) -> List[Name]:
+        ...
+
+    @overload
+    def get_names(self, name_type: str) -> List[Name]:
+        ...
+
+    def get_names(self, name_type):
+        """
+        Find all `Name` with the matching `name_type`
+
+        :return: A list of matching Name or None
+        :raises KeyError: If `name_type` wasn't present.
+        """
+        matches = None
+        if self._names:
+            if isinstance(name_type, str):
+                matches = [name for name in self._names if name.type.name == name_type]
+            elif isinstance(name_type, NameType):
+                matches = [name for name in self._names if name.type == name_type]
+
+        if matches:
+            return matches
+        else:
+            raise KeyError(f"{name_type}")
+
+    def add_name(self, name_type: NameType, name: str) -> IdentifiedObject:
+        """
+        Associate a `Name` with this `IdentifiedObject`
+
+        :param name_type: A `NameType` this `Name` belongs to.
+        :param name: A free string to associate with this `IdentifiedObject`.
+        :return: A reference to this `IdentifiedObject` to allow fluent use.
+        :raise ValueError: If `name` references another `IdentifiedObject`, or another `Name` already exists with the matching `type` and `name`.
+        """
+
+        name_obj = name_type.get_or_add_name(name, self)
+
+        if not name_obj.identified_object:
+            name_obj.identified_object = self
+        require(name_obj.identified_object is self, lambda: f"Attempting to add a Name to {str(self)} that does not reference this identified object")
+
+        if self.has_name(name_obj.type, name_obj.name):
+            existing = self.get_name(name_obj.type, name_obj.name)
+            if existing is name_obj:
+                return self
+            else:
+                raise ValueError(f"Failed to add duplicate name {str(name)} to {str(self)}.")
+
+        self._names = list() if not self._names else self._names
+        self._names.append(name_obj)
+        return self
+
+    def remove_name(self, name: Name) -> IdentifiedObject:
+        """
+        Disassociate a `Name` from this `IdentifiedObject` and remove the `name` from its `nameType`
+
+        :param name: The `Name` to disassociate from this `IdentifiedObject`.
+        :return: A reference to this `IdentifiedObject` to allow fluent use.
+        :raises ValueError: If `name` was not associated with this `IdentifiedObject`.
+        """
+        self._names = safe_remove(self._names, name)
+
+        # Remove the reverse reference from the NameType if it still exists.
+        if name.type.has_name(name):
+            name.type.remove_name(name)
+
+        return self
+
+    def clear_names(self) -> IdentifiedObject:
+        """
+        Clear all names.
+
+        :return: A reference to this `IdentifiedObject` to allow fluent use.
+        """
+        for name in list(self._names):
+            self.remove_name(name)
+        self._names = None
+
+        return self
+
+    def _validate_reference(self, other: IdentifiedObject, getter: Callable[[str], IdentifiedObject], type_descr: str) -> bool:
+        """
+        Validate whether a given reference exists to `other` using the provided getter function.
+
+        :param other: The object to look up with the getter using its mRID.
+        :param getter: A function that takes an mRID and returns an `IdentifiedObject`, and throws a `KeyError` if it couldn't be found.
+        :param type_descr: The type description to use for the lazily generated error message. Should be of the form "A[n] type(other)"
+        :return: True if `other` was retrieved with `getter` and was equivalent, False otherwise.
+        :raises ValueError: If the object retrieved from `getter` is not `other`.
+        """
+        try:
+            get_result = getter(other.mrid)
+            require(get_result is other, lambda: f"{type_descr} with mRID {other.mrid} already exists in {str(self)}")
+            return True
+        except (KeyError, AttributeError):
+            return False
+
+    def _validate_reference_by_field(self, other: IdentifiedObject, field: Any, getter: Callable[[Any], IdentifiedObject],
+                                     field_name: str) -> bool:
+        """
+        Validate whether a given reference exists to `other` using the provided getter function called with `field`.
+
+        :param other: The object to look up with the getter using its mRID.
+        :param field: The value of the field from `other` that needs to be validated.
+        :param getter: A function that takes `field` and returns an `IdentifiedObject`, and throws an `IndexError` if it couldn't be found.
+        :param field_name: The name of the field to use for the lazily generated error message.
+        :return: True if `other` was retrieved with `getter` and was equivalent, False otherwise.
+        :raises ValueError: If the object retrieved from `getter` is not `other`.
+        """
+        try:
+            get_result = getter(field)
+            require(get_result is other, lambda: f"Unable to add {other} to {self}. A {get_result} already exists with {field_name} {field}.")
+            return True
+        except IndexError:
+            return False
+
+
+TIdentifiedObject = TypeVar("TIdentifiedObject", bound=IdentifiedObject)
+"""
+Generic type of IdentifiedObject which can be used for type hinting generics.
+"""

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

@@ -0,0 +1,36 @@
+#  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__ = ["Name"]
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+    from zepben.ewb.model.cim.iec61970.base.core.name_type import NameType
+
+
+#
+# NOTE: unsafe_hash is used as we can't mark this class frozen due to needing to update/lazy initialise the identified_object, which shouldn't change once
+#       it has been initialised.
+#
+@dataclass(unsafe_hash=True)
+class Name:
+    """
+    The Name class provides the means to define any number of human-readable names for an object. A name is **not** to be used for defining inter-object
+    relationships. For inter-object relationships instead use the object identification 'mRID'.
+    """
+
+    name: str
+    """Any free text that name the object."""
+
+    type: NameType
+    """Type of this name."""
+
+    identified_object: Optional[IdentifiedObject] = None
+    """Identified object that this name designates."""

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

@@ -0,0 +1,203 @@
+#  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__ = ["NameType"]
+
+from typing import Dict, List, Generator, overload, TYPE_CHECKING, Callable, Optional
+
+from zepben.ewb.dataclassy import dataclass
+from zepben.ewb.model.cim.iec61970.base.core.name import Name
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+
+
+@dataclass(slots=True)
+class NameType:
+    """
+    Type of name. Possible values for attribute 'name' are implementation dependent but standard profiles may specify types. An enterprise may have multiple
+    IT systems each having its own local name for the same object, e.g. a planning system may have different names from an EMS. An object may also have
+    different names within the same IT system, e.g. localName as defined in CIM version 14. The definition from CIM14 is:
+    The localName is a human-readable name of the object. It is a free text name local to a node in a naming hierarchy similar to a file directory structure.
+    A power system related naming hierarchy may be: Substation, VoltageLevel, Equipment etc. Children of the same parent in such a hierarchy have names that
+    typically are unique among them.
+    """
+
+    name: str
+    """Name of the name type."""
+
+    description: Optional[str] = None
+    """Description of the name type."""
+
+    _names_index: Dict[str, Name] = dict()
+    _names_multi_index: Dict[str, List[Name]] = dict()
+
+    def __str__(self):
+        return f"NameType(name='{self.name}', description='{self.description}')"
+
+    @property
+    def names(self) -> Generator[Name, None, None]:
+        """All names of this type."""
+        for names_ in self._names_multi_index.values():
+            for name in names_:
+                yield name
+
+        for name_ in self._names_index.values():
+            yield name_
+
+    @overload
+    def has_name(self, name: str):
+        """Indicates if this :class:`NameType` contains `Name` with `name`."""
+
+    @overload
+    def has_name(self, name: Name):
+        """Indicates if this :class:`NameType` contains specific `name`."""
+
+    def has_name(self, name):
+        if isinstance(name, str):
+            return name in self._names_index or name in self._names_multi_index
+        if isinstance(name, Name):
+            return name in self._names_index.values() or name in self._names_multi_index.values()
+
+    @overload
+    def get_names(self, name: str) -> Generator[Name, None, None]:
+        ...
+
+    @overload
+    def get_names(self, io) -> Generator[Name, None, None]:
+        ...
+
+    def get_names(self, name_or_io) -> Generator[Name, None, None]:
+        """Get all the :class:`Name` instances for the provided `name` or `IdentifiedObject`.
+
+        :return: A `Generator` of `Name`
+        """
+        if isinstance(name_or_io, str):
+            try:
+                yield self._names_index[name_or_io]
+            except KeyError:
+                try:
+                    for name_ in self._names_multi_index[name_or_io]:
+                        yield name_
+                except KeyError:
+                    pass
+        else:
+            try:
+                for name_ in self._names_index.values():
+                    if name_.identified_object == name_or_io:
+                        yield name_
+                for names in self._names_multi_index.values():
+                    for name_ in names:
+                        if name_.identified_object == name_or_io:
+                            yield name_
+            except KeyError:
+                pass
+
+    def get_or_add_name(self, name: str, identified_object: IdentifiedObject) -> Name:
+        """
+        Gets a :class:`Name` for the given `name` and `identifiedObject` combination or adds a new :class:`Name`
+        to this :class:`NameType` with the combination and returns the new instance.
+        """
+        if name in self._names_index:
+            existing = self._names_index[name]
+            if existing.identified_object is identified_object:
+                return existing
+
+            def move_to_multi_index(name_obj: Name):
+                self._names_multi_index[name] = [existing, name_obj]
+                del self._names_index[name]
+
+            return self._get_or_create_name(name, identified_object, move_to_multi_index)
+        elif name in self._names_multi_index:
+            for n in self._names_multi_index[name]:
+                if n.identified_object is identified_object:
+                    return n
+
+            def expand_multi_index(name_obj: Name):
+                self._names_multi_index[name].append(name_obj)
+
+            return self._get_or_create_name(name, identified_object, expand_multi_index)
+        else:
+            def add_to_index(name_obj: Name):
+                self._names_index[name] = name_obj
+
+            return self._get_or_create_name(name, identified_object, add_to_index)
+
+    def remove_name(self, name: Name) -> NameType:
+        """
+        Removes the `name` from this name type.
+        Removes the `name` from associated `IdentifiedObject`
+
+        :return: True if the name instance was successfully removed
+        """
+        if name.type is not self:
+            raise ValueError(f"NameType.remove_name(name): {name} not in {self}")
+
+        try:
+            del self._names_index[name.name]
+            if name.identified_object.get_name(name.type, name.name):
+                name.identified_object.remove_name(name)
+            return self
+        except KeyError:
+            try:
+                names = self._names_multi_index[name.name]
+                names.remove(name)
+                if not names:
+                    del self._names_multi_index[name.name]
+                name.identified_object.remove_name(name)
+                return self
+            except KeyError:
+                return self
+
+    def remove_names(self, name: str) -> NameType:
+        """
+        Removes all :class:`Name` instances associated with name `name`.
+
+        :return: True if a matching name was removed.
+        """
+        try:
+            name_obj = self._names_index[name]
+            del self._names_index[name]
+            name_obj.identified_object.remove_name(name_obj)
+            return self
+        except KeyError:
+            try:
+                name_list = list(self._names_multi_index[name])
+                del self._names_multi_index[name]
+                for name_obj in name_list:
+                    name_obj.identified_object.remove_name(name_obj)
+                return self
+            except KeyError:
+                return self
+
+    def clear_names(self) -> NameType:
+        for name in list(self._names_index.values()):
+            name.identified_object.remove_name(name)
+        for names in list(self._names_multi_index.values()):
+            for name in names:
+                name.identified_object.remove_name(name)
+        self._names_index = dict()
+        self._names_multi_index = dict()
+        return self
+
+    def _get_or_create_name(self, name: str, identified_object: IdentifiedObject, update_index: Callable[[Name], None]) -> Name:
+        #
+        # NOTE: In Python, we can add names directly into the names collection of an object, so there is a chance that we just need to update the index rather
+        # than create a new Name class
+        #
+        had_name = identified_object.has_name(self, name)
+        if had_name:
+            name_obj = identified_object.get_name(self, name)
+        else:
+            name_obj = Name(name, self, identified_object)
+
+        update_index(name_obj)
+
+        if not had_name:
+            identified_object.add_name(self, name)
+
+        return name_obj

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

@@ -0,0 +1,202 @@
+#  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__ = ["PhaseCode", "phase_code_by_id", "phase_code_from_single_phases"]
+
+from enum import Enum
+from typing import List, Set, Union
+
+from zepben.ewb import unique
+from zepben.ewb.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
+
+
+def phase_code_by_id(value: int):
+    """
+    Get a PhaseCode by its value
+
+    `value` ID of the PhaseCode from 0 as per the order of definition
+    Returns The PhaseCode
+    """
+    return _PHASE_CODE_VALUES[value]
+
+
+@unique
+class PhaseCode(Enum):
+    """
+    An unordered enumeration of phase identifiers.  Allows designation of phases for both transmission and distribution equipment,
+    circuits and loads. The enumeration, by itself, does not describe how the phases are connected together or connected to ground.
+    Ground is not explicitly denoted as a phase.
+
+    Residential and small commercial loads are often served from single-phase, or split-phase, secondary circuits. For example of s12N,
+    phases 1 and 2 refer to hot wires that are 180 degrees out of phase, while N refers to the neutral wire. Through single-phase
+    transformer connections, these secondary circuits may be served from one or two of the primary phases A, B, and C. For three-phase
+    loads, use the A, B, C phase codes instead of s12N.
+    """
+
+    NONE = (0, [SinglePhaseKind.NONE])
+    """No phases specified"""
+
+    A = (1, [SinglePhaseKind.A])
+    """Phase A"""
+
+    B = (2, [SinglePhaseKind.B])
+    """Phase B"""
+
+    C = (3, [SinglePhaseKind.C])
+    """Phase C"""
+
+    N = (4, [SinglePhaseKind.N])
+    """Neutral Phase"""
+
+    AB = (5, [SinglePhaseKind.A, SinglePhaseKind.B])
+    """Phases A and B"""
+
+    AC = (6, [SinglePhaseKind.A, SinglePhaseKind.C])
+    """Phases A and C"""
+
+    AN = (7, [SinglePhaseKind.A, SinglePhaseKind.N])
+    """Phases A and N"""
+
+    BC = (8, [SinglePhaseKind.B, SinglePhaseKind.C])
+    """Phases B and C"""
+
+    BN = (9, [SinglePhaseKind.B, SinglePhaseKind.N])
+    """Phases B and N"""
+
+    CN = (10, [SinglePhaseKind.C, SinglePhaseKind.N])
+    """Phases C and N"""
+
+    ABC = (11, [SinglePhaseKind.A, SinglePhaseKind.B, SinglePhaseKind.C])
+    """Phases A, B and C"""
+
+    ABN = (12, [SinglePhaseKind.A, SinglePhaseKind.B, SinglePhaseKind.N])
+    """Phases A, B and neutral"""
+
+    ACN = (13, [SinglePhaseKind.A, SinglePhaseKind.C, SinglePhaseKind.N])
+    """Phases A, C and neutral"""
+
+    BCN = (14, [SinglePhaseKind.B, SinglePhaseKind.C, SinglePhaseKind.N])
+    """Phases B, C and neutral"""
+
+    ABCN = (15, [SinglePhaseKind.A, SinglePhaseKind.B, SinglePhaseKind.C, SinglePhaseKind.N])
+    """Phases A, B, C and neutral"""
+
+    X = (16, [SinglePhaseKind.X])
+    """Unknown non-neutral phase"""
+
+    XN = (17, [SinglePhaseKind.X, SinglePhaseKind.N])
+    """Unknown non-neutral phase plus neutral"""
+
+    XY = (18, [SinglePhaseKind.X, SinglePhaseKind.Y])
+    """Two Unknown non-neutral phases"""
+
+    XYN = (19, [SinglePhaseKind.X, SinglePhaseKind.Y, SinglePhaseKind.N])
+    """Two Unknown non-neutral phases plus neutral"""
+
+    Y = (20, [SinglePhaseKind.Y])
+    """Unknown non-neutral phase"""
+
+    YN = (21, [SinglePhaseKind.Y, SinglePhaseKind.N])
+    """Unknown non-neutral phase plus neutral"""
+
+    # pylint: disable=invalid-name
+    s1 = (22, [SinglePhaseKind.s1])
+    """Secondary phase 1"""
+
+    s1N = (23, [SinglePhaseKind.s1, SinglePhaseKind.N])
+    """Secondary phase 1 plus neutral"""
+
+    s12 = (24, [SinglePhaseKind.s1, SinglePhaseKind.s2])
+    """Secondary phase 1 and 2"""
+
+    s12N = (25, [SinglePhaseKind.s1, SinglePhaseKind.s2, SinglePhaseKind.N])
+    """Secondary phases 1, 2, and neutral"""
+
+    s2 = (26, [SinglePhaseKind.s2])
+    """Secondary phase 2"""
+
+    s2N = (27, [SinglePhaseKind.s2, SinglePhaseKind.N])
+    """Secondary phase 2 plus neutral"""
+
+    # pylint: enable=invalid-name
+
+    @property
+    def short_name(self) -> str:
+        """Get the name of this `PhaseCode` without the class qualifier"""
+        return str(self)[10:]
+
+    @property
+    def single_phases(self) -> List[SinglePhaseKind]:
+        """Get the list of `SinglePhaseKind` that make up this `PhaseCode`"""
+        return self.value[1]
+
+    @property
+    def num_phases(self) -> int:
+        """
+        Get the number of `SinglePhaseKind` that make up this `PhaseCode`. This is the same as the length of the `single_phases` in all cases except for NONE,
+        where the number of phases will be 0.
+        """
+        return len(self.value[1]) if self != PhaseCode.NONE else 0
+
+    @property
+    def without_neutral(self) -> 'PhaseCode':
+        """Get the equivalent `PhaseCode` without the `N` phase."""
+        if SinglePhaseKind.N not in self:
+            return self
+        else:
+            return phase_code_from_single_phases({it for it in self.single_phases if it != SinglePhaseKind.N})
+
+    def __iter__(self):
+        return PhaseCodeIter(self.single_phases)
+
+    def __contains__(self, item):
+        return item in self.single_phases
+
+    def __add__(self, other: Union[SinglePhaseKind, 'PhaseCode']) -> 'PhaseCode':
+        if isinstance(other, SinglePhaseKind):
+            return phase_code_from_single_phases(set(self.single_phases + [other]))
+        elif isinstance(other, PhaseCode):
+            return phase_code_from_single_phases(set(self.single_phases + other.single_phases))
+        else:
+            return PhaseCode.NONE
+
+    def __sub__(self, other: Union[SinglePhaseKind, 'PhaseCode']) -> 'PhaseCode':
+        if isinstance(other, SinglePhaseKind):
+            return phase_code_from_single_phases({it for it in self.single_phases if it != other})
+        elif isinstance(other, PhaseCode):
+            return phase_code_from_single_phases({it for it in self.single_phases if it not in other.single_phases})
+        else:
+            return PhaseCode.NONE
+
+
+class PhaseCodeIter:
+    """
+    An iterator that can be used to iterate over the `SinglePhaseKind` of a `PhaseCode`
+    """
+
+    def __init__(self, single_phases: List[SinglePhaseKind]):
+        self._index = -1
+        self._single_phases = single_phases
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        self._index += 1
+        if self._index < len(self._single_phases):
+            return self._single_phases[self._index]
+        raise StopIteration
+
+
+def phase_code_from_single_phases(single_phases: Set[SinglePhaseKind]) -> PhaseCode:
+    """Get the `PhaseCode` that is made up of the set of `SinglePhaseKind`, or `PhaseCode.NONE` if it is not valid."""
+    return _PHASE_CODE_BY_PHASES.get(frozenset(single_phases), PhaseCode.NONE)
+
+
+_PHASE_CODE_VALUES = list(PhaseCode.__members__.values())
+
+# The IDE is detecting `it` as a `SinglePhaseKind` rather than a `PhaseCode`
+# noinspection PyUnresolvedReferences
+_PHASE_CODE_BY_PHASES = {frozenset(it.single_phases): it for it in PhaseCode}