zepben.ewb 1.0.0__py3-none-any.whl

zepben/ewb/database/sqlite/tables/table_metadata_data_sources.py

@@ -0,0 +1,21 @@
+#  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__ = ["TableMetadataDataSources"]
+
+from zepben.ewb.database.sql.column import Column, Nullable
+from zepben.ewb.database.sqlite.tables.sqlite_table import SqliteTable
+
+
+class TableMetadataDataSources(SqliteTable):
+
+    def __init__(self):
+        self.source: Column = self._create_column("source", "TEXT", Nullable.NOT_NULL)
+        self.version: Column = self._create_column("version", "TEXT", Nullable.NOT_NULL)
+        self.timestamp: Column = self._create_column("timestamp", "TEXT", Nullable.NOT_NULL)
+
+    @property
+    def name(self) -> str:
+        return "metadata_data_sources"

zepben/ewb/database/sqlite/tables/table_version.py

@@ -0,0 +1,39 @@
+#  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__ = ["TableVersion"]
+
+import sqlite3
+from sqlite3 import Cursor
+from typing import Optional
+
+from zepben.ewb.database.sql.column import Column, Nullable
+from zepben.ewb.database.sqlite.tables.sqlite_table import SqliteTable
+
+
+class TableVersion(SqliteTable):
+    SUPPORTED_VERSION = 59
+
+    def __init__(self):
+        super().__init__()
+        self.version: Column = self._create_column("version", "TEXT", Nullable.NOT_NULL)
+
+    @property
+    def name(self) -> str:
+        return "version"
+
+    def get_version(self, cur: Cursor) -> Optional[int]:
+        """
+        Helper function to read the version from the database.
+        """
+        try:
+            cur.execute(self.select_sql)
+            rows = cur.fetchall()
+            if len(rows) == 1:
+                return int(rows[0][0])
+        except sqlite3.Error:
+            pass
+
+        return None

zepben/ewb/dataclassy/__init__.py

@@ -0,0 +1,15 @@
+# LICENCE EXCLUDED
+"""
+ Copyright (C) 2020 biqqles.
+ 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 http://mozilla.org/MPL/2.0/.
+
+ Forked from https://github.com/biqqles/dataclassy/tree/v0.6.2
+"""
+from .decorator import dataclass, make_dataclass
+from .dataclass import DataClass, Internal
+from .functions import fields, values, as_dict, as_tuple, replace
+
+# aliases intended for migration from dataclasses
+asdict, astuple = as_dict, as_tuple

zepben/ewb/dataclassy/dataclass.py

@@ -0,0 +1,192 @@
+# LICENCE EXCLUDED
+"""
+ Copyright (C) 2020 biqqles.
+ 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 http://mozilla.org/MPL/2.0/.
+
+ This file contains the internal mechanism that makes data classes
+ work, as well as functions which operate on them.
+
+ Forked from https://github.com/biqqles/dataclassy/tree/v0.6.2 with this additional bugfix:
+ https://github.com/biqqles/dataclassy/commit/ec9273ca02e5caefc08c923112fa9eeecf517246
+"""
+from types import FunctionType as Function
+from typing import Any, Dict, Generic, Hashable, TypeVar
+from reprlib import recursive_repr
+
+DataClass = Any  # type hint for variables that should be data class instances
+T = TypeVar('T')
+
+
+class Internal(Generic[T]):
+    """This type hint wrapper represents a field that is internal to the data class and is, for example, not to be
+    shown in a repr."""
+    @classmethod
+    def is_internal(cls, annotation):
+        return getattr(annotation, '__origin__', None) is cls or \
+               (type(annotation) is str and cls.__name__ in annotation)
+
+
+class DataClassMeta(type):
+    """The metaclass for a data class."""
+    DEFAULT_OPTIONS = dict(init=True, repr=True, eq=True, iter=False, frozen=False, kwargs=False, slots=False,
+                           order=False, unsafe_hash=True, hide_internals=True)
+
+    def __new__(mcs, name, bases, dict_, **kwargs):
+        # collect annotations, defaults, slots and options from this class' ancestors, in definition order
+        all_annotations = {}
+        all_defaults = {}
+        all_slots = set()
+        options = dict(mcs.DEFAULT_OPTIONS)
+
+        dataclass_bases = [vars(b) for b in bases if hasattr(b, '__dataclass__')]
+        for b in dataclass_bases + [dict_]:
+            all_annotations.update(b.get('__annotations__', {}))
+            all_defaults.update(b.get('__defaults__', dict_))
+            all_slots.update(b.get('__slots__', set()))
+            options.update(b.get('__dataclass__', {}))
+        options.update(kwargs)
+
+        # fill out this class' dict and store defaults, annotations and decorator options for future subclasses
+        dict_.update(all_defaults)
+        dict_['__defaults__'] = all_defaults
+        dict_['__annotations__'] = all_annotations
+        dict_['__dataclass__'] = options
+
+        # delete what will become stale references so that Python creates new ones
+        del dict_['__dict__'], dict_['__weakref__']
+
+        # create/apply generated methods and attributes
+        user_init = type(dict_.get('__init__')) is Function
+
+        if options['slots']:
+            # values with default values must only be present in slots, not dict, otherwise Python will interpret them
+            # as read only
+            for d in all_annotations.keys() & all_defaults.keys():
+                del dict_[d]
+            dict_['__slots__'] = all_annotations.keys() - all_slots
+        elif '__slots__' in dict_:
+            # if the slots option has been removed from an inheriting dataclass we must remove descriptors and __slots__
+            for d in all_annotations.keys() - all_defaults.keys() & dict_.keys():
+                del dict_[d]
+            del dict_['__slots__']
+        if options['init']:
+            dict_.setdefault('__new__', _generate_new(all_annotations, all_defaults, user_init,
+                                                      options['kwargs'], options['frozen']))
+        if options['repr']:
+            dict_.setdefault('__repr__', recursive_repr()(__repr__))
+        if options['eq']:
+            dict_.setdefault('__eq__', __eq__)
+        if options['iter']:
+            dict_.setdefault('__iter__', __iter__)
+        if options['frozen']:
+            dict_['__delattr__'] = dict_['__setattr__'] = __setattr__
+        if options['order']:
+            dict_.setdefault('__lt__', __lt__)
+        if (options['eq'] and options['frozen']) or options['unsafe_hash']:
+            dict_.setdefault('__hash__', __hash__)
+
+        return type.__new__((DataClassInit if options['init'] and user_init else mcs), name, bases, dict_)
+
+    def __init__(cls, *args, **kwargs):
+        # warn the user if they try to use __post_init__
+        if hasattr(cls, '__post_init__'):
+            raise TypeError('dataclassy does not use __post_init__. You should rename this method __init__')
+
+        if cls.__dataclass__['eq'] and cls.__dataclass__['order']:
+            from functools import total_ordering
+            total_ordering(cls)
+
+        # determine a static expression for an instance's fields as a tuple, then evaluate this to create a property
+        # allowing efficient representation for internal methods
+        tuple_expr = f'({", ".join((*(f"self.{f}" for f in fields(cls)), ""))})'  # "" ensures closing comma
+        cls.__tuple__ = property(eval(f'lambda self: {tuple_expr}'))
+
+
+class DataClassInit(DataClassMeta):
+    """In the case that a custom __init__ is defined, remove arguments used by __new__ before calling it."""
+    def __call__(cls, *args, **kwargs):
+        args = iter(args)
+        new_kwargs = dict(zip(cls.__annotations__, args))  # convert positional args to keyword for __new__
+        instance = cls.__new__(cls, **new_kwargs, **kwargs)
+
+        for parameter in kwargs.keys() & cls.__annotations__.keys():
+            del kwargs[parameter]
+
+        instance.__init__(*args, **kwargs)
+        return instance
+
+    @property
+    def __signature__(cls):
+        """Defining a __call__ breaks inspect.signature. Lazily generate a Signature object ourselves."""
+        import inspect
+        parameters = tuple(inspect.signature(cls.__new__).parameters.values())
+        return inspect.Signature(parameters[1:])  # remove 'cls' to transform parameters of __new__ into those of class
+
+
+def _generate_new(annotations: Dict, defaults: Dict, user_init: bool, gen_kwargs: bool, frozen: bool) -> Function:
+    """Generate and return a __new__ method for a data class which has as parameters all fields of the data class.
+    When the data class is initialised, arguments to this function are applied to the fields of the new instance. Using
+    __new__ frees up __init__, allowing it to be defined by the user to perform additional, custom initialisation.
+
+    If __init__ is defined, all arguments to __new__ become keyword-only, and the custom __call__ converts positional
+    arguments to keyword arguments. This prevents ambiguity during attempts to pass the same argument twice,
+    positionally and as a keyword."""
+    arguments = [a for a in annotations if a not in defaults]
+    default_arguments = [f'{a}={a}' for a in annotations if a in defaults]
+    kw_only = ['*'] if user_init and (arguments or default_arguments) else []
+    kwargs = ['**kwargs'] if gen_kwargs or user_init else []  # pass through unknown keyword arguments to __init__
+
+    parameters = ', '.join(kw_only + arguments + default_arguments + kwargs)
+
+    # determine what to do with arguments before assignment. If the argument matches a mutable default, make a copy
+    references = {n: f'{n}.copy() if {n} is self.__defaults__[{n!r}] else {n}'
+                  if n in defaults and hasattr(defaults[n], 'copy') else n for n in annotations}
+
+    # if the class is frozen, use the necessary but slightly slower object.__setattr__
+    assignments = [f'object.__setattr__(self, {n!r}, {r})' if frozen else f'self.{n} = {r}'
+                   for n, r in references.items()]
+
+    # generate the function
+    signature = f'def __new__(cls, {parameters}):'
+    body = [f'self = object.__new__(cls)', *assignments, 'return self']
+
+    exec('\n\t'.join([signature, *body]), {}, defaults)
+    function = defaults.pop('__new__')
+    function.__annotations__ = annotations
+    return function
+
+
+# generic method implementations common to all data classes
+# these are currently relatively inefficient - it would be better to cache an expression for a class' tuple
+from .functions import values, fields
+
+
+def __eq__(self: DataClass, other: DataClass):
+    return type(self) is type(other) and self.__tuple__ == other.__tuple__
+
+
+def __lt__(self: DataClass, other: DataClass):
+    if isinstance(other, type(self)):
+        return self.__tuple__ < other.__tuple__
+    return NotImplemented
+
+
+def __hash__(self):
+    # currently not ideal since gives no warning if a field expected to be hashable is not
+    return hash((type(self), *(v for v in self.__tuple__ if v is isinstance(v, Hashable))))
+
+
+def __iter__(self):
+    return iter(self.__tuple__)
+
+
+def __repr__(self):
+    show_internals = not self.__dataclass__['hide_internals']
+    field_values = ', '.join(f'{f}={v!r}' for f, v in values(self, show_internals).items())
+    return f'{type(self).__name__}({field_values})'
+
+
+def __setattr__(self, *args):
+    raise AttributeError('Frozen class')

zepben/ewb/dataclassy/decorator.py

@@ -0,0 +1,35 @@
+# LICENCE EXCLUDED
+"""
+ Copyright (C) 2020 biqqles.
+ 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 http://mozilla.org/MPL/2.0/.
+
+ This file contains code relating to dataclassy's decorator.
+
+ Forked from https://github.com/biqqles/dataclassy/tree/v0.6.2
+"""
+from typing import Any, Dict, Optional
+from .dataclass import DataClassMeta
+
+
+def dataclass(cls: Optional[type] = None, *, meta=DataClassMeta, **options):
+    """The decorator used to apply DataClassMeta, or optionally a subclass of that metaclass, to a class."""
+    assert issubclass(meta, DataClassMeta)
+
+    def apply_metaclass(to_class, metaclass=meta):
+        """Apply a metaclass to a class."""
+        dict_ = dict(vars(to_class), __metaclass__=metaclass)
+        return metaclass(to_class.__name__, to_class.__bases__, dict_, **options)
+
+    if cls:  # if decorator used with no arguments, apply metaclass to the class immediately
+        if not isinstance(cls, type):
+            raise TypeError('This decorator takes no explicit positional arguments')
+        return apply_metaclass(cls)
+    return apply_metaclass  # otherwise, return function for later evaluation
+
+
+def make_dataclass(name: str, fields: Dict[str, type], defaults: Dict[str, Any], bases=(), **options) -> type:
+    """Dynamically create a data class with name `name`, fields `fields`, default field values `defaults` and
+    inheriting from `bases`."""
+    return dataclass(type(name, bases, dict(defaults, __annotations__=fields)), **options)

zepben/ewb/dataclassy/functions.py

@@ -0,0 +1,80 @@
+# LICENCE EXCLUDED
+"""
+ Copyright (C) 2020 biqqles.
+ 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 http://mozilla.org/MPL/2.0/.
+
+ This file defines functions which operate on data classes.
+
+ Forked from https://github.com/biqqles/dataclassy/tree/v0.6.2
+"""
+from typing import Any, Callable, Dict, Tuple, Type
+
+from .dataclass import DataClassMeta, DataClass, Internal
+
+
+def is_dataclass(obj: Any) -> bool:
+    """Return True if the given object is a data class as implemented in this package, otherwise False."""
+    return isinstance(obj, DataClassMeta) or is_dataclass_instance(obj)
+
+
+def is_dataclass_instance(obj: Any) -> bool:
+    """Return True if the given object is an instance of a data class, otherwise False."""
+    return isinstance(type(obj), DataClassMeta)
+
+
+def fields(dataclass: Type[DataClass], internals=False) -> Dict[str, Type]:
+    """Return a dict of `dataclass`'s fields and their types. `internals` selects whether to include internal fields.
+    `dataclass` can be either a data class or an instance of a data class. A field is defined as a class-level variable
+    with a type annotation."""
+    assert is_dataclass(dataclass)
+    return _filter_annotations(dataclass.__annotations__, internals)
+
+
+def values(dataclass: DataClass, internals=False) -> Dict[str, Any]:
+    """Return a dict of `dataclass`'s fields and their values. `internals` selects whether to include internal fields.
+    `dataclass` must be an instance of a data class. A field is defined as a class-level variable with a type
+    annotation."""
+    assert is_dataclass_instance(dataclass)
+    return {f: getattr(dataclass, f) for f in fields(dataclass, internals)}
+
+
+def as_dict(dataclass: DataClass, dict_factory=dict) -> Dict[str, Any]:
+    """Recursively create a dict of a dataclass instance's fields and their values.
+    This function is recursively called on data classes, named tuples and iterables."""
+    assert is_dataclass_instance(dataclass)
+    return _recurse_structure(dataclass, dict_factory)
+
+
+def as_tuple(dataclass: DataClass) -> Tuple:
+    """Recursively create a tuple of the values of a dataclass instance's fields, in definition order.
+    This function is recursively called on data classes, named tuples and iterables."""
+    assert is_dataclass_instance(dataclass)
+    return _recurse_structure(dataclass, lambda k_v: tuple(v for k, v in k_v))
+
+
+def replace(dataclass: DataClass, **changes) -> DataClass:
+    """Return a new copy of `dataclass` with field values replaced as specified in `changes`."""
+    return type(dataclass)(**dict(values(dataclass, internals=True), **changes))
+
+
+def _filter_annotations(annotations: Dict[str, Type], internals: bool) -> Dict[str, Type]:
+    """Filter an annotations dict for to remove or keep internal fields."""
+    return annotations if internals else {f: a for f, a in annotations.items()
+                                          if not f.startswith('_') and not Internal.is_internal(a)}
+
+
+def _recurse_structure(var: Any, iter_proc: Callable) -> Any:
+    """Recursively convert an arbitrarily nested structure beginning at `var`, copying and processing any iterables
+    encountered with `iter_proc`."""
+    if is_dataclass(var):
+        var = values(var, internals=True)
+    if hasattr(var, '_asdict'):  # handle named tuples
+        # noinspection PyCallingNonCallable, PyProtectedMember
+        var = var._asdict()
+    if isinstance(var, dict):
+        return iter_proc((_recurse_structure(k, iter_proc), _recurse_structure(v, iter_proc)) for k, v in var.items())
+    if isinstance(var, (list, tuple)):
+        return type(var)(_recurse_structure(e, iter_proc) for e in var)
+    return var

zepben/ewb/examples/__init__.py

@@ -0,0 +1,6 @@
+#  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 zepben.ewb.examples.simple_test_network import *

zepben/ewb/examples/simple_test_network.py

@@ -0,0 +1,158 @@
+#  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__ = ["simple_test_network"]
+
+from typing import List
+
+from zepben.ewb import NetworkService, BaseVoltage, PowerTransformerInfo, PhaseCode, EnergySourcePhase, EnergySource, PowerTransformer, Terminal, \
+    ConductingEquipment, EnergyConsumer, AcLineSegment, Location
+from zepben.ewb.model.cim.iec61970.base.wires.per_length_sequence_impedance import PerLengthSequenceImpedance
+from zepben.ewb.model.cim.iec61968.common.position_point import PositionPoint
+from zepben.ewb.model.cim.iec61968.assetinfo.overhead_wire_info import OverheadWireInfo
+from zepben.ewb.model.cim.iec61970.base.wires.power_transformer_end import PowerTransformerEnd
+
+
+async def simple_test_network() -> NetworkService:
+    # Network
+    network = NetworkService()
+
+    # BaseVoltages
+    bv_hv: BaseVoltage = BaseVoltage(mrid="20kV", nominal_voltage=20000, name="20kV")
+    bv_lv: BaseVoltage = BaseVoltage(mrid="415V", nominal_voltage=400, name="415V")
+    network.add(bv_hv)
+    network.add(bv_lv)
+    point1 = PositionPoint(x_position=149.12791965570293, y_position=-35.277592101000934)
+    point2 = PositionPoint(x_position=149.12779472660375, y_position=-35.278183862759285)
+    point3 = PositionPoint(x_position=149.12840360920450, y_position=-35.277171304657690)
+
+    loc1 = Location().add_point(point1)
+    loc2 = Location().add_point(point2)
+    loc3 = Location().add_point(point3)
+
+    # PerLengthSequenceImpedance
+    plsi = PerLengthSequenceImpedance(
+        mrid="psli",
+        r=0.642 / 1000,
+        x=0.083 / 1000
+    )
+    network.add(plsi)
+
+    # WireInfo
+    wire_info = OverheadWireInfo(
+        mrid="wire_info",
+        rated_current=0.142 * 1000
+    )
+    network.add(wire_info)
+
+    # PowerTransformerInfo
+    pt_info = PowerTransformerInfo(
+        mrid="pt_info"
+    )
+    network.add(pt_info)
+
+    # EnergySource
+    energy_source_phases = []
+    for sp in PhaseCode.ABC.single_phases:
+        esp = EnergySourcePhase()
+        esp.phase = sp
+        energy_source_phases.append(esp)
+        network.add(esp)
+    es = EnergySource(
+        mrid="grid_connection",
+        name="Grid Connection",
+        voltage_magnitude=1.02 * bv_hv.nominal_voltage,
+        energy_source_phases=energy_source_phases,
+        location=loc1
+    )
+
+    es.base_voltage = bv_hv
+    network.add(es)
+    es_t = _create_terminal(es)
+    network.add(es_t)
+
+    # Transformer
+    tx = PowerTransformer(mrid="transformer", name="Transformer", location=loc1)
+    tx.asset_info = pt_info
+    tx_terminals = _create_terminals(tx, [PhaseCode.ABC, PhaseCode.ABN])
+    for t in tx_terminals:
+        network.add(t)
+    network.add(tx)
+
+    ends = _create_transformer_ends(tx, [20000, 400])
+    for end in ends:
+        network.add(end)
+
+    network.connect_terminals(tx_terminals[0], es_t)
+
+    # Line
+    line_location = Location().add_point(point2).add_point(point3)
+    network.add(line_location)
+    line = AcLineSegment(mrid="line", name="Line", length=100.0, per_length_impedance=plsi,
+                         location=line_location)
+    line.asset_info = wire_info
+    line.base_voltage = bv_lv
+    line_terminals = _create_terminals(line)
+    for t in line_terminals:
+        network.add(t)
+    network.add(line)
+
+    network.connect_terminals(tx_terminals[1], line_terminals[0])
+
+    # Load
+    ec = EnergyConsumer(mrid="load", name="Load", p=100000., q=50000., location=loc3)
+    ec.base_voltage = bv_lv
+    network.add(ec)
+    ec_t = _create_terminal(ec)
+    network.add(ec_t)
+
+    network.connect_terminals(line_terminals[1], ec_t)
+
+    await network.set_phases()
+    return network
+
+
+def _create_terminal(ce: ConductingEquipment, phases: PhaseCode = PhaseCode.ABC) -> Terminal:
+    return _create_terminals(ce, [phases])[0]
+
+
+def _create_terminals(ce: ConductingEquipment, phases_per_term: List[PhaseCode] = None) -> List[Terminal]:
+    if phases_per_term is None:
+        phases_per_term = [PhaseCode.ABC, PhaseCode.ABC]
+
+    terminals: List[Terminal] = []
+    for i in range(0, len(phases_per_term)):
+        terminal = Terminal(
+            mrid=f"{ce.mrid}_t{i + 1}",
+            conducting_equipment=ce,
+            phases=phases_per_term[i],
+            sequence_number=i + 1
+        )
+        ce.add_terminal(terminal)
+        terminals.append(terminal)
+    return terminals
+
+
+def _create_per_length_sequence_impedance(i: float) -> PerLengthSequenceImpedance:
+    return PerLengthSequenceImpedance(mrid=f"plsi{i}", r=i, x=i, bch=i, gch=i, r0=i, x0=i, b0ch=i, g0ch=i)
+
+
+def _create_transformer_ends(tx: PowerTransformer, voltages: List[int] = None) -> List[PowerTransformerEnd]:
+    if voltages is None:
+        voltages = [11000, 415]
+
+    ends = []
+    for i in range(0, len(voltages)):
+        end = PowerTransformerEnd(mrid=f"{tx.mrid}_e{i + 1}", power_transformer=tx, rated_u=voltages[i])
+        terminal = tx.get_terminal_by_sn(i + 1)
+
+        if terminal is None:
+            raise ValueError(f"No terminal found to attach transformer end {end.mrid} in power transformer {tx.mrid}")
+
+        tx.add_end(end)
+        end.terminal = terminal
+        ends.append(end)
+
+    return ends

zepben/ewb/exceptions.py

@@ -0,0 +1,52 @@
+#  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/.
+
+class MissingReferenceException(Exception):
+    TYPE = 'UNKNOWN'
+
+    def __init__(self, referenced_mrid: str, referrer=None, **kwargs):
+        self.referenced_mrid = referenced_mrid
+        self.referrer = referrer
+
+        super().__init__(kwargs)
+
+    @property
+    def info(self):
+        if self.referrer is not None:
+            if hasattr(self.referrer, 'DESCRIPTOR'):
+                self.referrer_type = self.referrer.DESCRIPTOR.name
+                self.referrer_mrid = self.referrer.mRID
+            else:
+                self.referrer_type = type(self.referrer).__name__
+                self.referrer_mrid = self.referrer.mrid
+        return f"{self.TYPE} {self.referenced_mrid} was not found in the network. It must be created before {self.referrer_type}[{self.referrer_mrid}] can reference it."
+
+
+class NetworkException(Exception):
+    pass
+
+
+class AlreadyExistsException(Exception):
+    pass
+
+
+class ReadingException(Exception):
+    pass
+
+
+class PhaseException(Exception):
+    pass
+
+
+class NominalPhaseException(Exception):
+    pass
+
+
+class WiringException(Exception):
+    pass
+
+
+class TracingException(Exception):
+    pass

zepben/ewb/model/__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/busbranch/__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/.