code
stringlengths 501
5.19M
| package
stringlengths 2
81
| path
stringlengths 9
304
| filename
stringlengths 4
145
|
|---|---|---|---|
from __future__ import annotations
from typing import Optional, Dict, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Equipment, Terminal, Substation, LvFeeder
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node_container import ConnectivityNodeContainer
from zepben.evolve.util import nlen, ngen, safe_remove_by_id
__all__ = ['EquipmentContainer', 'Feeder', 'Site']
class EquipmentContainer(ConnectivityNodeContainer):
"""
A modeling construct to provide a root class for containing equipment.
Unless overridden, all functions operating on currentEquipment simply operate on the equipment collection. i.e. currentEquipment = equipment
"""
_equipment: Optional[Dict[str, Equipment]] = None
"""Map of Equipment in this EquipmentContainer by their mRID"""
def __init__(self, equipment: List[Equipment] = None, **kwargs):
super(EquipmentContainer, 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 `EquipmentContainer`
"""
return nlen(self._equipment)
@property
def equipment(self) -> Generator[Equipment, None, None]:
"""
The `Equipment` contained in this `EquipmentContainer`
"""
return ngen(self._equipment.values() if self._equipment is not None else None)
def get_equipment(self, mrid: str) -> Equipment:
"""
Get the `Equipment` for this `EquipmentContainer` 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.
"""
if not self._equipment:
raise KeyError(mrid)
try:
return self._equipment[mrid]
except AttributeError:
raise KeyError(mrid)
def add_equipment(self, equipment: Equipment) -> EquipmentContainer:
"""
Associate `equipment` with this `EquipmentContainer`.
`equipment` The `Equipment` to associate with this `EquipmentContainer`.
Returns A reference to this `EquipmentContainer` to allow fluent use.
Raises `ValueError` if another `Equipment` with the same `mrid` already exists for this `EquipmentContainer`.
"""
if self._validate_reference(equipment, self.get_equipment, "An Equipment"):
return self
self._equipment = dict() if self._equipment is None else self._equipment
self._equipment[equipment.mrid] = equipment
return self
def remove_equipment(self, equipment: Equipment) -> EquipmentContainer:
"""
Disassociate `equipment` from this `EquipmentContainer`
`equipment` The `Equipment` to disassociate with this `EquipmentContainer`.
Returns A reference to this `EquipmentContainer` to allow fluent use.
Raises `KeyError` if `equipment` was not associated with this `EquipmentContainer`.
"""
self._equipment = safe_remove_by_id(self._equipment, equipment)
return self
def clear_equipment(self) -> EquipmentContainer:
"""
Clear all equipment.
Returns A reference to this `EquipmentContainer` to allow fluent use.
"""
self._equipment = None
return self
@property
def current_equipment(self) -> Generator[Equipment, None, None]:
"""
Contained `Equipment` using the current state of the network.
"""
return self.equipment
def num_current_equipment(self) -> int:
"""
Returns The number of `Equipment` contained in this `EquipmentContainer` in the current state of the network.
"""
return self.num_equipment()
def get_current_equipment(self, mrid: str) -> Equipment:
"""
Get the `Equipment` contained in this `EquipmentContainer` in the current state of the network, 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 self.get_equipment(mrid)
def add_current_equipment(self, equipment: Equipment) -> EquipmentContainer:
"""
Associate `equipment` with this `EquipmentContainer` in the current state of the network.
`equipment` the `Equipment` to associate with this `EquipmentContainer` in the current state of the network.
Returns A reference to this `EquipmentContainer` to allow fluent use.
Raises `ValueError` if another `Equipment` with the same `mrid` already exists for this `EquipmentContainer`.
"""
self.add_equipment(equipment)
return self
def remove_current_equipment(self, equipment: Equipment) -> EquipmentContainer:
"""
Disassociate `equipment` from this `EquipmentContainer` in the current state of the network.
`equipment` The `Equipment` to disassociate from this `EquipmentContainer` in the current state of the network.
Returns A reference to this `EquipmentContainer` to allow fluent use.
Raises `KeyError` if `equipment` was not associated with this `EquipmentContainer`.
"""
self.remove_equipment(equipment)
return self
def clear_current_equipment(self) -> EquipmentContainer:
"""
Clear all `Equipment` from this `EquipmentContainer` in the current state of the network.
Returns A reference to this `EquipmentContainer` to allow fluent use.
"""
self.clear_equipment()
return self
def current_feeders(self) -> Generator[Feeder, None, None]:
"""
Convenience function to find all of the current feeders of the equipment associated with this equipment container.
Returns the current feeders for all associated feeders
"""
seen = set()
for equip in self._equipment.values():
for f in equip.current_feeders:
if f not in seen:
seen.add(f.mrid)
yield f
def normal_feeders(self) -> Generator[Feeder, None, None]:
"""
Convenience function to find all of the normal feeders of the equipment associated with this equipment container.
Returns the normal feeders for all associated feeders
"""
seen = set()
for equip in self._equipment.values():
for f in equip.normal_feeders:
if f not in seen:
seen.add(f.mrid)
yield f
def current_lv_feeders(self) -> Generator[LvFeeder, None, None]:
"""
Convenience function to find all of the normal LV feeders of the equipment associated with this equipment container.
Returns the normal LV feeders for all associated LV feeders
"""
seen = set()
for equip in self._equipment.values():
for f in equip.current_lv_feeders:
if f not in seen:
seen.add(f.mrid)
yield f
def normal_lv_feeders(self) -> Generator[LvFeeder, None, None]:
"""
Convenience function to find all of the normal LV feeders of the equipment associated with this equipment container.
Returns the normal LV feeders for all associated LV feeders
"""
seen = set()
for equip in self._equipment.values():
for f in equip.normal_lv_feeders:
if f not in seen:
seen.add(f.mrid)
yield f
class Feeder(EquipmentContainer):
"""
A collection of equipment for organizational purposes, used for grouping distribution resources.
The organization of a feeder does not necessarily reflect connectivity or current operation state.
"""
_normal_head_terminal: Optional[Terminal] = None
"""The normal head terminal or terminals of the feeder."""
normal_energizing_substation: Optional[Substation] = None
"""The substation that nominally energizes the feeder. Also used for naming purposes."""
_current_equipment: Optional[Dict[str, Equipment]] = None
"""The equipment contained in this feeder in the current state of the network."""
_normal_energized_lv_feeders: Optional[Dict[str, LvFeeder]] = None
"""The LV feeders that are energized by this feeder in the normal state of the network."""
def __init__(
self,
normal_head_terminal: Terminal = None,
normal_energizing_substation: Substation = None,
current_equipment: List[Equipment] = None,
normal_energized_lv_feeders: List[LvFeeder] = None,
**kwargs
):
super(Feeder, self).__init__(**kwargs)
if normal_head_terminal:
self.normal_head_terminal = normal_head_terminal
if normal_energizing_substation:
self.normal_energizing_substation = normal_energizing_substation
if normal_energized_lv_feeders:
for lv_feeder in normal_energized_lv_feeders:
self.add_normal_energized_lv_feeder(lv_feeder)
if current_equipment:
for eq in current_equipment:
self.add_current_equipment(eq)
@property
def normal_head_terminal(self) -> Optional[Terminal]:
"""The normal head terminal or terminals of the feeder."""
return self._normal_head_terminal
@normal_head_terminal.setter
def normal_head_terminal(self, term: Optional[Terminal]):
if self._normal_head_terminal is None or self._normal_head_terminal is term:
self._normal_head_terminal = term
else:
raise ValueError(f"normal_head_terminal for {str(self)} has already been set to {self._normal_head_terminal}, cannot reset this field to {term}")
@property
def current_equipment(self) -> Generator[Equipment, None, None]:
"""
Contained `Equipment` using the current state of the network.
"""
return ngen(self._current_equipment.values() if self._current_equipment is not None else None)
def num_current_equipment(self):
"""
Returns The number of `Equipment` associated with this `Feeder`
"""
return nlen(self._current_equipment)
def get_current_equipment(self, mrid: str) -> Equipment:
"""
Get the `Equipment` for this `Feeder` 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.
"""
if not self._current_equipment:
raise KeyError(mrid)
try:
return self._current_equipment[mrid]
except AttributeError:
raise KeyError(mrid)
def add_current_equipment(self, equipment: Equipment) -> Feeder:
"""
Associate `equipment` with this `Feeder`.
`equipment` the `Equipment` to associate with this `Feeder`.
Returns A reference to this `Feeder` to allow fluent use.
Raises `ValueError` if another `Equipment` with the same `mrid` already exists for this `Feeder`.
"""
if self._validate_reference(equipment, self.get_current_equipment, "An Equipment"):
return self
self._current_equipment = dict() if self._current_equipment is None else self._current_equipment
self._current_equipment[equipment.mrid] = equipment
return self
def remove_current_equipment(self, equipment: Equipment) -> Feeder:
"""
Disassociate `equipment` from this `Feeder`
`equipment` The `Equipment` to disassociate from this `Feeder`.
Returns A reference to this `Feeder` to allow fluent use.
Raises `KeyError` if `equipment` was not associated with this `Feeder`.
"""
self._current_equipment = safe_remove_by_id(self._current_equipment, equipment)
return self
def clear_current_equipment(self) -> Feeder:
"""
Clear all equipment.
Returns A reference to this `Feeder` to allow fluent use.
"""
self._current_equipment = None
return self
@property
def normal_energized_lv_feeders(self) -> Generator[LvFeeder, None, None]:
"""
The LV feeders that are energized by this feeder.
"""
return ngen(self._normal_energized_lv_feeders.values() if self._normal_energized_lv_feeders is not None else self._normal_energized_lv_feeders)
def num_normal_energized_lv_feeders(self) -> int:
"""
Get the number of LV feeders that are energized by this feeder.
"""
return nlen(self._normal_energized_lv_feeders)
def get_normal_energized_lv_feeder(self, mrid: str) -> LvFeeder:
"""
Energized LvFeeder in the normal state of the network.
@param mrid: The mrid of the `LvFeeder`.
@return A matching `LvFeeder` that is energized by this `Feeder` in the normal state of the network.
@raise A `KeyError` if no matching `LvFeeder` was found.
"""
if not self._normal_energized_lv_feeders:
raise KeyError(mrid)
try:
return self._normal_energized_lv_feeders[mrid]
except AttributeError:
raise KeyError(mrid)
def add_normal_energized_lv_feeder(self, lv_feeder: LvFeeder) -> Feeder:
"""
Associate this `Feeder` with an `LvFeeder` in the normal state of the network.
@param lv_feeder: the LV feeder to associate with this feeder in the normal state of the network.
@return: This `Feeder` for fluent use.
"""
if self._validate_reference(lv_feeder, self.get_normal_energized_lv_feeder, "An LvFeeder"):
return self
self._normal_energized_lv_feeders = dict() if self._normal_energized_lv_feeders is None else self._normal_energized_lv_feeders
self._normal_energized_lv_feeders[lv_feeder.mrid] = lv_feeder
return self
def remove_normal_energized_lv_feeder(self, lv_feeder: LvFeeder) -> Feeder:
"""
Disassociate this `Feeder` from an `LvFeeder` in the normal state of the network.
@param lv_feeder: the LV feeder to disassociate from this feeder in the normal state of the network.
@return: This `Feeder` for fluent use.
@raise: A `ValueError` if `lv_feeder` is not found in the normal energized lv feeders collection.
"""
self._normal_energized_lv_feeders = safe_remove_by_id(self._normal_energized_lv_feeders, lv_feeder)
return self
def clear_normal_energized_lv_feeders(self) -> Feeder:
"""
Clear all `LvFeeder`s associated with `Feeder` in the normal state of the network.
@return: This `Feeder` for fluent use.
"""
self._normal_energized_lv_feeders = None
return self
class Site(EquipmentContainer):
"""
A collection of equipment for organizational purposes, used for grouping distribution resources located at a site.
Note this is not a CIM concept - however represents an `EquipmentContainer` in CIM. This is to avoid the use of `EquipmentContainer` as a concrete class.
"""
pass | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/equipment_container.py | equipment_container.py |
from __future__ import annotations
from typing import Optional, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import RemoteSource
from zepben.evolve.model.cim.iec61970.base.core.phase_code import PhaseCode
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.model.cim.iec61970.base.domain.unit_symbol import UnitSymbol
__all__ = ["Measurement", "Accumulator", "Analog", "Discrete"]
class Measurement(IdentifiedObject):
"""
A Measurement represents any measured, calculated or non-measured non-calculated quantity. Any piece of equipment
may contain Measurements, e.g. a substation may have temperature measurements and door open indications,
a transformer may have oil temperature and tank pressure measurements, a bay may contain a number of power flow
measurements and a Breaker may contain a switch status measurement.
The PSR - Measurement association is intended to capture this use of Measurement and is included in the naming
hierarchy based on EquipmentContainer. The naming hierarchy typically has Measurements as leafs,
e.g. Substation-VoltageLevel-Bay-Switch-Measurement.
Some Measurements represent quantities related to a particular sensor location in the network, e.g. a voltage
transformer (PT) at a busbar or a current transformer (CT) at the bar between a breaker and an isolator. The
sensing position is not captured in the PSR - Measurement association. Instead it is captured by the Measurement
- Terminal association that is used to define the sensing location in the network topology. The location is
defined by the connection of the Terminal to ConductingEquipment.
If both a Terminal and PSR are associated, and the PSR is of type ConductingEquipment, the associated Terminal
should belong to that ConductingEquipment instance.
When the sensor location is needed both Measurement-PSR and Measurement-Terminal are used. The Measurement-Terminal
association is never used alone.
"""
power_system_resource_mrid: Optional[str] = None
"""The MRID of the power system resource that contains the measurement."""
remote_source: Optional[RemoteSource] = None
"""The `zepben.evolve.cim.iec61970.base.scada.remote_source.RemoteSource` taking the `Measurement`"""
terminal_mrid: Optional[str] = None
"""A measurement may be associated with a terminal in the network."""
phases: PhaseCode = PhaseCode.ABC
"""Indicates to which phases the measurement applies and avoids the need to use 'measurementType' to also encode phase information
(which would explode the types). The phase information in Measurement, along with 'measurementType' and 'phases' uniquely defines a Measurement for a
device, based on normal network phase. Their meaning will not change when the computed energizing phasing is changed due to jumpers or other reasons.
If the attribute is missing three phases (ABC) shall be assumed."""
unit_symbol: UnitSymbol = UnitSymbol.NONE
"""Specifies the type of measurement. For example, this specifies if the measurement represents an indoor temperature, outdoor temperature, bus voltage,
line flow, etc. When the measurementType is set to "Specialization", the type of Measurement is defined in more detail by the specialized class which
inherits from Measurement."""
class Accumulator(Measurement):
"""Accumulator represents an accumulated (counted) Measurement, e.g. an energy value."""
pass
class Analog(Measurement):
"""Analog represents an analog Measurement."""
positive_flow_in: bool = False
"""If true then this measurement is an active power, reactive power or current with the convention that a positive value measured at the
Terminal means power is flowing into the related PowerSystemResource."""
class Discrete(Measurement):
"""Discrete represents a discrete Measurement, i.e. a Measurement representing discrete values, e.g. a Breaker position."""
pass | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/meas/measurement.py | measurement.py |
from __future__ import annotations
from typing import Optional
from zepben.evolve.model.cim.iec61970.base.equivalents.equivalent_equipment import EquivalentEquipment
__all__ = ["EquivalentBranch"]
class EquivalentBranch(EquivalentEquipment):
"""
The class represents equivalent branches. In cases where a transformer phase shift is modelled and the EquivalentBranch
is spanning the same nodes, the impedance quantities for the EquivalentBranch shall consider the needed phase shift.
"""
negative_r12: Optional[float] = None
""""
Negative sequence series resistance from terminal sequence 1 to terminal sequence 2. Used for short circuit data exchange according
to IEC 60909. EquivalentBranch is a result of network reduction prior to the data exchange.
"""
negative_r21: Optional[float] = None
""""
Negative sequence series resistance from terminal sequence 2 to terminal sequence 1. Used for short circuit data exchange according
to IEC 60909. EquivalentBranch is a result of network reduction prior to the data exchange.
"""
negative_x12: Optional[float] = None
""""
Negative sequence series reactance from terminal sequence 1 to terminal sequence 2. Used for short circuit data exchange according
to IEC 60909. Usage : EquivalentBranch is a result of network reduction prior to the data exchange.
"""
negative_x21: Optional[float] = None
""""
Negative sequence series reactance from terminal sequence 2 to terminal sequence 1. Used for short circuit data exchange according
to IEC 60909. Usage: EquivalentBranch is a result of network reduction prior to the data exchange.
"""
positive_r12: Optional[float] = None
""""
Positive sequence series resistance from terminal sequence 1 to terminal sequence 2 . Used for short circuit data exchange according
to IEC 60909. EquivalentBranch is a result of network reduction prior to the data exchange.
"""
positive_r21: Optional[float] = None
""""
Positive sequence series resistance from terminal sequence 2 to terminal sequence 1. Used for short circuit data exchange according
to IEC 60909. EquivalentBranch is a result of network reduction prior to the data exchange.
"""
positive_x12: Optional[float] = None
""""
Positive sequence series reactance from terminal sequence 1 to terminal sequence 2. Used for short circuit data exchange according
to IEC 60909. Usage : EquivalentBranch is a result of network reduction prior to the data exchange.
"""
positive_x21: Optional[float] = None
""""
Positive sequence series reactance from terminal sequence 2 to terminal sequence 1. Used for short circuit data exchange according
to IEC 60909. Usage : EquivalentBranch is a result of network reduction prior to the data exchange.
"""
r: Optional[float] = None
""""
Positive sequence series resistance of the reduced branch.
"""
r21: Optional[float] = None
""""
Resistance from terminal sequence 2 to terminal sequence 1 .Used for steady state power flow. This attribute is optional and represent
unbalanced network such as off-nominal phase shifter. If only EquivalentBranch.r is given, then EquivalentBranch.r21 is assumed equal
to EquivalentBranch.r. Usage rule : EquivalentBranch is a result of network reduction prior to the data exchange.
"""
x: Optional[float] = None
""""
Positive sequence series reactance of the reduced branch.
"""
x21: Optional[float] = None
""""
Reactance from terminal sequence 2 to terminal sequence 1. Used for steady state power flow. This attribute is optional and represents
an unbalanced network such as off-nominal phase shifter. If only EquivalentBranch.x is given, then EquivalentBranch.x21 is assumed
equal to EquivalentBranch.x. Usage rule: EquivalentBranch is a result of network reduction prior to the data exchange.
"""
zero_r12: Optional[float] = None
""""
Zero sequence series resistance from terminal sequence 1 to terminal sequence 2. Used for short circuit data exchange according to
IEC 60909. EquivalentBranch is a result of network reduction prior to the data exchange.
"""
zero_r21: Optional[float] = None
"""
Zero sequence series resistance from terminal sequence 2 to terminal sequence 1. Used for short circuit data exchange according to
IEC 60909. Usage : EquivalentBranch is a result of network reduction prior to the data exchange.
"""
zero_x12: Optional[float] = None
"""
Zero sequence series reactance from terminal sequence 1 to terminal sequence 2. Used for short circuit data exchange according to
IEC 60909. Usage : EquivalentBranch is a result of network reduction prior to the data exchange.
"""
zero_x21: Optional[float] = None
"""
Zero sequence series reactance from terminal sequence 2 to terminal sequence 1. Used for short circuit data exchange according to
IEC 60909. Usage : EquivalentBranch is a result of network reduction prior to the data exchange.
""" | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/equivalents/equivalent_branch.py | equivalent_branch.py |
from __future__ import annotations
import typing
from typing import Generator, Optional, Dict, List
if typing.TYPE_CHECKING:
from zepben.evolve import Equipment, Terminal, Feeder
from zepben.evolve.model.cim.iec61970.base.core.equipment_container import EquipmentContainer
from zepben.evolve.util import safe_remove_by_id, nlen, ngen
__all__ = ["LvFeeder"]
class LvFeeder(EquipmentContainer):
"""
A branch of LV network starting at a distribution substation and continuing until the end of the LV network.
"""
_normal_head_terminal: Optional[Terminal] = None
"""The normal head terminal or terminals of this LvFeeder"""
_normal_energizing_feeders: Optional[Dict[str, Feeder]] = None
_current_equipment: Optional[Dict[str, Equipment]] = None
"""The equipment contained in this LvFeeder in the current state of the network."""
def __init__(
self,
normal_head_terminal: Terminal = None,
normal_energizing_feeders: List[Feeder] = None,
current_equipment: List[Equipment] = None,
**kwargs
):
super(LvFeeder, self).__init__(**kwargs)
if normal_head_terminal:
self.normal_head_terminal = normal_head_terminal
if normal_energizing_feeders:
for feeder in normal_energizing_feeders:
self.add_normal_energizing_feeder(feeder)
if current_equipment:
for eq in current_equipment:
self.add_current_equipment(eq)
@property
def normal_head_terminal(self) -> Optional[Terminal]:
"""
The normal head terminal or terminals of the feeder.
"""
return self._normal_head_terminal
@normal_head_terminal.setter
def normal_head_terminal(self, term: Optional[Terminal]):
if self._normal_head_terminal is None or self._normal_head_terminal is term:
self._normal_head_terminal = term
else:
raise ValueError(f"normal_head_terminal for {str(self)} has already been set to {self._normal_head_terminal}, cannot reset this field to {term}")
@property
def normal_energizing_feeders(self) -> Generator[Feeder, None, None]:
"""
The HV/MV feeders that energize this LV feeder.
"""
return ngen(self._normal_energizing_feeders.values() if self._normal_energizing_feeders is not None else None)
def num_normal_energizing_feeders(self) -> int:
"""
Get the number of HV/MV feeders that energize this LV feeder.
"""
return nlen(self._normal_energizing_feeders)
def get_normal_energizing_feeder(self, mrid: str) -> Feeder:
"""
Energizing feeder using the normal state of the network.
@param mrid: The mrid of the `Feeder`.
@return A matching `Feeder` that energizes this `LvFeeder` in the normal state of the network.
@raise A `KeyError` if no matching `Feeder` was found.
"""
if not self._normal_energizing_feeders:
raise KeyError(mrid)
try:
return self._normal_energizing_feeders[mrid]
except AttributeError:
raise KeyError(mrid)
def add_normal_energizing_feeder(self, feeder: Feeder) -> LvFeeder:
"""
Associate this `LvFeeder` with a `Feeder` in the normal state of the network.
@param feeder: the HV/MV feeder to associate with this LV feeder in the normal state of the network.
@return: This `LvFeeder` for fluent use.
"""
if self._validate_reference(feeder, self.get_normal_energizing_feeder, "A Feeder"):
return self
self._normal_energizing_feeders = dict() if self._normal_energizing_feeders is None else self._normal_energizing_feeders
self._normal_energizing_feeders[feeder.mrid] = feeder
return self
def remove_normal_energizing_feeder(self, feeder: Feeder) -> LvFeeder:
"""
Disassociate this `LvFeeder` from a `Feeder` in the normal state of the network.
@param feeder: the HV/MV feeder to disassociate from this LV feeder in the normal state of the network.
@return: This `LvFeeder` for fluent use.
@raise: A `ValueError` if `feeder` is not found in the normal energizing feeders collection.
"""
self._normal_energizing_feeders = safe_remove_by_id(self._normal_energizing_feeders, feeder)
return self
def clear_normal_energizing_feeders(self) -> LvFeeder:
"""
Clear all `Feeder`s associated with `LvFeeder` in the normal state of the network.
@return: This `LvFeeder` for fluent use.
"""
self._normal_energizing_feeders = None
return self
@property
def current_equipment(self) -> Generator[Equipment, None, None]:
"""
Contained `Equipment` using the current state of the network.
"""
return ngen(self._current_equipment.values() if self._current_equipment is not None else None)
def num_current_equipment(self):
"""
Returns The number of `Equipment` associated with this `LvFeeder` in the current state of the network.
"""
return nlen(self._current_equipment)
def get_current_equipment(self, mrid: str) -> Equipment:
"""
Get the `Equipment` contained in this `LvFeeder` in the current state of the network, 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.
"""
if not self._current_equipment:
raise KeyError(mrid)
try:
return self._current_equipment[mrid]
except AttributeError:
raise KeyError(mrid)
def add_current_equipment(self, equipment: Equipment) -> LvFeeder:
"""
Associate `equipment` with this `LvFeeder` in the current state of the network.
`equipment` the `Equipment` to associate with this `LvFeeder` in the current state of the network.
Returns A reference to this `LvFeeder` to allow fluent use.
Raises `ValueError` if another `Equipment` with the same `mrid` already exists for this `LvFeeder`.
"""
if self._validate_reference(equipment, self.get_current_equipment, "An Equipment"):
return self
self._current_equipment = dict() if self._current_equipment is None else self._current_equipment
self._current_equipment[equipment.mrid] = equipment
return self
def remove_current_equipment(self, equipment: Equipment) -> LvFeeder:
"""
Disassociate `equipment` from this `LvFeeder` in the current state of the network.
`equipment` The `Equipment` to disassociate from this `LvFeeder` in the current state of the network.
Returns A reference to this `LvFeeder` to allow fluent use.
Raises `KeyError` if `equipment` was not associated with this `LvFeeder`.
"""
self._current_equipment = safe_remove_by_id(self._current_equipment, equipment)
return self
def clear_current_equipment(self) -> LvFeeder:
"""
Clear all `Equipment` from this `LvFeeder` in the current state of the network.
Returns A reference to this `LvFeeder` to allow fluent use.
"""
self._current_equipment = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/infiec61970/feeder/lv_feeder.py | lv_feeder.py |
from __future__ import annotations
from typing import Optional, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Substation, Terminal, Loop
from zepben.evolve.model.cim.iec61970.base.wires.line import Line
from zepben.evolve.util import ngen, get_by_mrid, safe_remove, nlen
__all__ = ["Circuit"]
class Circuit(Line):
"""Missing description"""
loop: Optional[Loop] = None
_end_terminals: Optional[List[Terminal]] = None
_end_substations: Optional[List[Substation]] = None
def __init__(self, end_terminals: List[Terminal] = None, end_substations: List[Substation] = None, **kwargs):
super(Circuit, self).__init__(**kwargs)
if end_terminals:
for term in end_terminals:
self.add_end_terminal(term)
if end_substations:
for sub in end_substations:
self.add_end_substation(sub)
@property
def end_terminals(self) -> Generator[Terminal, None, None]:
"""
The `Terminal`s representing the ends for this `Circuit`.
"""
return ngen(self._end_terminals)
@property
def end_substations(self) -> Generator[Substation, None, None]:
"""
The `Substations`s representing the ends for this `Circuit`.
"""
return ngen(self._end_substations)
def num_end_terminals(self):
"""Return the number of end `Terminal`s associated with this `Circuit`"""
return nlen(self._end_terminals)
def get_end_terminal(self, mrid: str) -> Terminal:
"""
Get the `Terminal` for this `Circuit` identified by `mrid`
`mrid` the mRID of the required `Terminal`
Returns The `Terminal` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._end_terminals, mrid)
def add_end_terminal(self, terminal: Terminal) -> Circuit:
"""
Associate an `Terminal` with this `Circuit`
`terminal` the `Terminal` to associate with this `Circuit`.
Returns A reference to this `Circuit` to allow fluent use.
Raises `ValueError` if another `Terminal` with the same `mrid` already exists for this `Circuit`.
"""
if self._validate_reference(terminal, self.get_end_terminal, "An Terminal"):
return self
self._end_terminals = list() if self._end_terminals is None else self._end_terminals
self._end_terminals.append(terminal)
return self
def remove_end_terminal(self, terminal: Terminal) -> Circuit:
"""
Disassociate `terminal` from this `Circuit`
`terminal` the `Terminal` to disassociate from this `Circuit`.
Returns A reference to this `Circuit` to allow fluent use.
Raises `ValueError` if `terminal` was not associated with this `Circuit`.
"""
self._end_terminals = safe_remove(self._end_terminals, terminal)
return self
def clear_end_terminals(self) -> Circuit:
"""
Clear all end terminals.
Returns A reference to this `Circuit` to allow fluent use.
"""
self._end_terminals = None
return self
def num_end_substations(self):
"""Return the number of end `Substation`s associated with this `Circuit`"""
return nlen(self._end_substations)
def get_end_substation(self, mrid: str) -> Substation:
"""
Get the `Substation` for this `Circuit` identified by `mrid`
`mrid` the mRID of the required `Substation`
Returns The `Substation` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._end_substations, mrid)
def add_end_substation(self, substation: Substation) -> Circuit:
"""
Associate an `Substation` with this `Circuit`
`substation` the `Substation` to associate with this `Circuit`.
Returns A reference to this `Circuit` to allow fluent use.
Raises `ValueError` if another `Substation` with the same `mrid` already exists for this `Circuit`.
"""
if self._validate_reference(substation, self.get_end_substation, "An Substation"):
return self
self._end_substations = list() if self._end_substations is None else self._end_substations
self._end_substations.append(substation)
return self
def remove_end_substation(self, substation: Substation) -> Circuit:
"""
Disassociate `substation` from this `Circuit`
`substation` the `Substation` to disassociate from this `Circuit`.
Returns A reference to this `Circuit` to allow fluent use.
Raises `ValueError` if `substation` was not associated with this `Circuit`.
"""
self._end_substations = safe_remove(self._end_substations, substation)
return self
def clear_end_substations(self) -> Circuit:
"""
Clear all end substations.
Returns A reference to this `Circuit` to allow fluent use.
"""
self._end_substations = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/infiec61970/feeder/circuit.py | circuit.py |
from __future__ import annotations
from typing import Optional, List, Generator, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Circuit, Substation
__all__ = ["Loop"]
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.util import safe_remove, ngen, nlen, get_by_mrid
class Loop(IdentifiedObject):
"""Missing description"""
_circuits: Optional[List[Circuit]] = None
_substations: Optional[List[Substation]] = None
_energizing_substations: Optional[List[Substation]] = None
def __init__(self, circuits: List[Circuit] = None, substations: List[Substation] = None, energizing_substations: List[Substation] = None, **kwargs):
super(Loop, self).__init__(**kwargs)
if circuits:
for term in circuits:
self.add_circuit(term)
if substations:
for sub in substations:
self.add_substation(sub)
if energizing_substations:
for sub in energizing_substations:
self.add_energizing_substation(sub)
@property
def circuits(self) -> Generator[Circuit, None, None]:
"""
Sub-transmission `Circuit`s that form part of this loop.
"""
return ngen(self._circuits)
@property
def substations(self) -> Generator[Substation, None, None]:
"""
The `Substation`s that are powered by this `Loop`.
"""
return ngen(self._substations)
@property
def energizing_substations(self) -> Generator[Substation, None, None]:
"""
The `Substation`s that normally energize this `Loop`.
"""
return ngen(self._energizing_substations)
def num_circuits(self):
"""Return the number of end `Circuit`s associated with this `Loop`"""
return nlen(self._circuits)
def get_circuit(self, mrid: str) -> Circuit:
"""
Get the `Circuit` for this `Loop` identified by `mrid`
`mrid` the mRID of the required `Circuit`
Returns The `Circuit` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._circuits, mrid)
def add_circuit(self, circuit: Circuit) -> Loop:
"""
Associate an `Circuit` with this `Loop`
`circuit` the `Circuit` to associate with this `Loop`.
Returns A reference to this `Loop` to allow fluent use.
Raises `ValueError` if another `Circuit` with the same `mrid` already exists for this `Loop`.
"""
if self._validate_reference(circuit, self.get_circuit, "An Circuit"):
return self
self._circuits = list() if self._circuits is None else self._circuits
self._circuits.append(circuit)
return self
def remove_circuit(self, circuit: Circuit) -> Loop:
"""
Disassociate `circuit` from this `Loop`
`circuit` the `Circuit` to disassociate from this `Loop`.
Returns A reference to this `Loop` to allow fluent use.
Raises `ValueError` if `circuit` was not associated with this `Loop`.
"""
self._circuits = safe_remove(self._circuits, circuit)
return self
def clear_circuits(self) -> Loop:
"""
Clear all end circuits.
Returns A reference to this `Loop` to allow fluent use.
"""
self._circuits = None
return self
def num_substations(self):
"""Return the number of end `Substation`s associated with this `Loop`"""
return nlen(self._substations)
def get_substation(self, mrid: str) -> Substation:
"""
Get the `Substation` for this `Loop` identified by `mrid`
`mrid` the mRID of the required `Substation`
Returns The `Substation` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._substations, mrid)
def add_substation(self, substation: Substation) -> Loop:
"""
Associate an `Substation` with this `Loop`
`substation` the `Substation` to associate with this `Loop`.
Returns A reference to this `Loop` to allow fluent use.
Raises `ValueError` if another `Substation` with the same `mrid` already exists for this `Loop`.
"""
if self._validate_reference(substation, self.get_substation, "An Substation"):
return self
self._substations = list() if self._substations is None else self._substations
self._substations.append(substation)
return self
def remove_substation(self, substation: Substation) -> Loop:
"""
Disassociate `substation` from this `Loop`
`substation` the `Substation` to disassociate from this `Loop`.
Returns A reference to this `Loop` to allow fluent use.
Raises `ValueError` if `substation` was not associated with this `Loop`.
"""
self._substations = safe_remove(self._substations, substation)
return self
def clear_substations(self) -> Loop:
"""
Clear all end substations.
Returns A reference to this `Loop` to allow fluent use.
"""
self._substations = None
return self
def num_energizing_substations(self):
"""Return the number of end `Substation`s associated with this `Loop`"""
return nlen(self._energizing_substations)
def get_energizing_substation(self, mrid: str) -> Substation:
"""
Get the `Substation` for this `Loop` identified by `mrid`
`mrid` the mRID of the required `Substation`
Returns The `Substation` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._energizing_substations, mrid)
def add_energizing_substation(self, substation: Substation) -> Loop:
"""
Associate an `Substation` with this `Loop`
`substation` the `Substation` to associate with this `Loop`.
Returns A reference to this `Loop` to allow fluent use.
Raises `ValueError` if another `Substation` with the same `mrid` already exists for this `Loop`.
"""
if self._validate_reference(substation, self.get_energizing_substation, "An Substation"):
return self
self._energizing_substations = list() if self._energizing_substations is None else self._energizing_substations
self._energizing_substations.append(substation)
return self
def remove_energizing_substation(self, substation: Substation) -> Loop:
"""
Disassociate `substation` from this `Loop`
`substation` the `Substation` to disassociate from this `Loop`.
Returns A reference to this `Loop` to allow fluent use.
Raises `ValueError` if `substation` was not associated with this `Loop`.
"""
self._energizing_substations = safe_remove(self._energizing_substations, substation)
return self
def clear_energizing_substations(self) -> Loop:
"""
Clear all end energizing_substations.
Returns A reference to this `Loop` to allow fluent use.
"""
self._energizing_substations = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/infiec61970/feeder/loop.py | loop.py |
from __future__ import annotations
from typing import Optional, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import CustomerAgreement
from zepben.evolve.model.cim.iec61968.common.organisation_role import OrganisationRole
from zepben.evolve.model.cim.iec61968.customers.customer_kind import CustomerKind
from zepben.evolve.util import nlen, get_by_mrid, ngen, safe_remove
__all__ = ["Customer"]
class Customer(OrganisationRole):
"""
Organisation receiving services from service supplier.
"""
kind: CustomerKind = CustomerKind.UNKNOWN
"""Kind of customer"""
_customer_agreements: Optional[List[CustomerAgreement]] = None
def __init__(self, customer_agreements: List[CustomerAgreement] = None, **kwargs):
super(Customer, self).__init__(**kwargs)
if customer_agreements:
for agreement in customer_agreements:
self.add_agreement(agreement)
def num_agreements(self) -> int:
"""
Get the number of `CustomerAgreement`s associated with this `Customer`.
"""
return nlen(self._customer_agreements)
@property
def agreements(self) -> Generator[CustomerAgreement, None, None]:
"""
The `CustomerAgreement`s for this `Customer`.
"""
return ngen(self._customer_agreements)
def get_agreement(self, mrid: str) -> CustomerAgreement:
"""
Get the `CustomerAgreement` for this `Customer` identified by `mrid`.
`mrid` the mRID of the required `customer_agreement.CustomerAgreement`
Returns the `CustomerAgreement` with the specified `mrid`.
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._customer_agreements, mrid)
def add_agreement(self, customer_agreement: CustomerAgreement) -> Customer:
"""
Associate a `CustomerAgreement` with this `Customer`.
`customer_agreement` The `customer_agreement.CustomerAgreement` to associate with this `Customer`.
Returns A reference to this `Customer` to allow fluent use.
Raises `ValueError` if another `CustomerAgreement` with the same `mrid` already exists for this `Customer`
"""
if self._validate_reference(customer_agreement, self.get_agreement, "A CustomerAgreement"):
return self
self._customer_agreements = list() if self._customer_agreements is None else self._customer_agreements
self._customer_agreements.append(customer_agreement)
return self
def remove_agreement(self, customer_agreement: CustomerAgreement) -> Customer:
"""
Disassociate `customer_agreement` from this `Customer`.
`customer_agreement` the `customer_agreement.CustomerAgreement` to disassociate with this `Customer`.
Returns A reference to this `Customer` to allow fluent use.
Raises `ValueError` if `customer_agreement` was not associated with this `Customer`.
"""
self._customer_agreements = safe_remove(self._customer_agreements, customer_agreement)
return self
def clear_agreements(self) -> Customer:
"""
Clear all customer agreements.
Returns self
"""
self._customer_agreements = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/customers/customer.py | customer.py |
from __future__ import annotations
from typing import Optional, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import PricingStructure, Customer
from zepben.evolve.model.cim.iec61968.common.document import Agreement
from zepben.evolve.util import nlen, get_by_mrid, ngen, safe_remove
__all__ = ["CustomerAgreement"]
class CustomerAgreement(Agreement):
"""
Agreement between the customer and the service supplier to pay for service at a specific service location. It
records certain billing information about the type of service provided at the service location and is used
during charge creation to determine the type of service.
"""
_customer: Optional[Customer] = None
"""The `zepben.evolve.cim.iec61968.customers.customer.Customer` that has this `CustomerAgreement`."""
_pricing_structures: Optional[List[PricingStructure]] = None
def __init__(self, customer: Customer = None, pricing_structures: List[PricingStructure] = None, **kwargs):
super(CustomerAgreement, self).__init__(**kwargs)
if customer:
self.customer = customer
if pricing_structures:
for ps in pricing_structures:
self.add_pricing_structure(ps)
@property
def customer(self):
"""The `Customer` that has this `CustomerAgreement`."""
return self._customer
@customer.setter
def customer(self, cust):
if self._customer is None or self._customer is cust:
self._customer = cust
else:
raise ValueError(f"customer for {str(self)} has already been set to {self._customer}, cannot reset this field to {cust}")
def num_pricing_structures(self):
"""
The number of `PricingStructure`s associated with this `CustomerAgreement`
"""
return nlen(self._pricing_structures)
@property
def pricing_structures(self) -> Generator[PricingStructure, None, None]:
"""
The `PricingStructure`s of this `CustomerAgreement`.
"""
return ngen(self._pricing_structures)
def get_pricing_structure(self, mrid: str) -> PricingStructure:
"""
Get the `PricingStructure` for this `CustomerAgreement` identified by `mrid`
`mrid` the mRID of the required `PricingStructure`
Returns the `PricingStructure` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._pricing_structures, mrid)
def add_pricing_structure(self, ps: PricingStructure) -> CustomerAgreement:
"""
Associate `ps` with this `CustomerAgreement`
`ps` the `PricingStructure` to associate with this `CustomerAgreement`.
Returns A reference to this `CustomerAgreement` to allow fluent use.
Raises `ValueError` if another `PricingStructure` with the same `mrid` already exists for this `CustomerAgreement`
"""
if self._validate_reference(ps, self.get_pricing_structure, "A PricingStructure"):
return self
self._pricing_structures = list() if self._pricing_structures is None else self._pricing_structures
self._pricing_structures.append(ps)
return self
def remove_pricing_structure(self, ps: PricingStructure) -> CustomerAgreement:
"""
Disassociate `ps` from this `CustomerAgreement`
`ps` the `PricingStructure` to disassociate from this `CustomerAgreement`.
Returns A reference to this `CustomerAgreement` to allow fluent use.
Raises `ValueError` if `ps` was not associated with this `CustomerAgreement`.
"""
self._pricing_structures = safe_remove(self._pricing_structures, ps)
return self
def clear_pricing_structures(self) -> CustomerAgreement:
"""
Clear all pricing structures.
Returns a reference to this `CustomerAgreement` to allow fluent use.
"""
self._pricing_structures = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/customers/customer_agreement.py | customer_agreement.py |
from __future__ import annotations
from typing import Optional, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Tariff
from zepben.evolve.model.cim.iec61968.common.document import Document
from zepben.evolve.util import get_by_mrid, nlen, ngen, safe_remove
__all__ = ["PricingStructure"]
class PricingStructure(Document):
"""
Grouping of pricing components and prices used in the creation of customer charges and the eligibility
criteria under which these terms may be offered to a customer. The reasons for grouping include state,
customer classification, site characteristics, classification (i.e. fee price structure, deposit price
structure, electric service price structure, etc.) and accounting requirements.
"""
_tariffs: Optional[List[Tariff]] = None
def __init__(self, tariffs: List[Tariff] = None, **kwargs):
super(PricingStructure, self).__init__(**kwargs)
if tariffs:
for tariff in tariffs:
self.add_tariff(tariff)
def num_tariffs(self):
"""
Returns The number of `Tariff`s associated with this `PricingStructure`
"""
return nlen(self._tariffs)
@property
def tariffs(self) -> Generator[Tariff, None, None]:
"""
The `Tariff`s of this `PricingStructure`.
"""
return ngen(self._tariffs)
def get_tariff(self, mrid: str) -> Tariff:
"""
Get the `Tariff` for this `PricingStructure` identified by `mrid`
`mrid` the mRID of the required `Tariff`
Returns The `Tariff` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._tariffs, mrid)
def add_tariff(self, tariff: Tariff) -> PricingStructure:
"""
Associate a `Tariff` with this `PricingStructure`.
`tariff` the `Tariff` to associate with this `PricingStructure`.
Returns A reference to this `PricingStructure` to allow fluent use.
Raises `ValueError` if another `Tariff` with the same `mrid` already exists for this `PricingStructure`.
"""
if self._validate_reference(tariff, self.get_tariff, "A Tariff"):
return self
self._tariffs = list() if self._tariffs is None else self._tariffs
self._tariffs.append(tariff)
return self
def remove_tariff(self, tariff: Tariff) -> PricingStructure:
"""
Disassociate `tariff` from this `PricingStructure`.
`tariff` the `Tariff` to disassociate from this `PricingStructure`.
Returns A reference to this `PricingStructure` to allow fluent use.
Raises `ValueError` if `tariff` was not associated with this `PricingStructure`.
"""
self._tariffs = safe_remove(self._tariffs, tariff)
return self
def clear_tariffs(self) -> PricingStructure:
"""
Clear all tariffs.
Returns A reference to this `PricingStructure` to allow fluent use.
"""
self._tariffs = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/customers/pricing_structure.py | pricing_structure.py |
from __future__ import annotations
from typing import Optional, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import AssetOrganisationRole
from zepben.evolve.model.cim.iec61968.common.location import Location
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.util import get_by_mrid, nlen, ngen, safe_remove
__all__ = ["Asset", "AssetContainer"]
class Asset(IdentifiedObject):
"""
Tangible resource of the utility, including power system equipment, various end devices, cabinets, buildings,
etc. For electrical network equipment, the role of the asset is defined through PowerSystemResource and its
subclasses, defined mainly in the Wires model (refer to IEC61970-301 and model package IEC61970::Wires). Asset
description places emphasis on the physical characteristics of the equipment fulfilling that role.
"""
location: Optional[Location] = None
"""`zepben.evolve.cim.iec61968.common.location.Location` of this asset"""
_organisation_roles: Optional[List[AssetOrganisationRole]] = None
def __init__(self, organisation_roles: List[AssetOrganisationRole] = None, **kwargs):
super(Asset, self).__init__(**kwargs)
if organisation_roles:
for role in organisation_roles:
self.add_organisation_role(role)
def num_organisation_roles(self) -> int:
"""
Get the number of `AssetOrganisationRole`s associated with this `Asset`.
"""
return nlen(self._organisation_roles)
@property
def organisation_roles(self) -> Generator[AssetOrganisationRole, None, None]:
"""
The `AssetOrganisationRole`s of this `Asset`.
"""
return ngen(self._organisation_roles)
def get_organisation_role(self, mrid: str) -> AssetOrganisationRole:
"""
Get the `AssetOrganisationRole` for this asset identified by `mrid`.
`mrid` the mRID of the required `AssetOrganisationRole`
Returns The `AssetOrganisationRole` with the specified `mrid`.
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._organisation_roles, mrid)
def add_organisation_role(self, role: AssetOrganisationRole) -> Asset:
"""
`role` The `AssetOrganisationRole` to
associate with this `Asset`.
Returns A reference to this `Asset` to allow fluent use.
Raises `ValueError` if another `AssetOrganisationRole` with the same `mrid` already exists in this `Asset`
"""
if self._validate_reference(role, self.get_organisation_role, "An AssetOrganisationRole"):
return self
self._organisation_roles = list() if self._organisation_roles is None else self._organisation_roles
self._organisation_roles.append(role)
return self
def remove_organisation_role(self, role: AssetOrganisationRole) -> Asset:
"""
Disassociate an `AssetOrganisationRole` from this `Asset`.
`role` the `AssetOrganisationRole` to
disassociate with this `Asset`.
Raises `ValueError` if `role` was not associated with this `Asset`.
Returns A reference to this `Asset` to allow fluent use.
"""
self._organisation_roles = safe_remove(self._organisation_roles, role)
return self
def clear_organisation_roles(self) -> Asset:
"""
Clear all organisation roles.
Returns self
"""
self._organisation_roles = None
return self
class AssetContainer(Asset):
"""
Asset that is aggregation of other assets such as conductors, transformers, switchgear, land, fences, buildings,
equipment, vehicles, etc.
"""
pass | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/assets/asset.py | asset.py |
from __future__ import annotations
from typing import List, Optional, Generator, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Streetlight
from zepben.evolve.model.cim.iec61968.assets.structure import Structure
from zepben.evolve.util import get_by_mrid, ngen, nlen, safe_remove
__all__ = ["Pole"]
class Pole(Structure):
"""A Pole Asset"""
classification: str = ""
"""Pole class: 1, 2, 3, 4, 5, 6, 7, H1, H2, Other, Unknown."""
_streetlights: Optional[List[Streetlight]] = None
def __init__(self, streetlights: List[Streetlight] = None, **kwargs):
super(Pole, self).__init__(**kwargs)
if streetlights:
for light in streetlights:
self.add_streetlight(light)
def num_streetlights(self) -> int:
"""
Get the number of `Streetlight`s associated with this `Pole`.
"""
return nlen(self._streetlights)
@property
def streetlights(self) -> Generator[Streetlight, None, None]:
"""
The `Streetlight`s of this `Pole`.
"""
return ngen(self._streetlights)
def get_streetlight(self, mrid: str) -> Streetlight:
"""
Get the `Streetlight` for this asset identified by `mrid`.
`mrid` the mRID of the required `Streetlight`
Returns The `Streetlight` with the specified `mrid`.
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._streetlights, mrid)
def add_streetlight(self, streetlight: Streetlight) -> Pole:
"""
Associate a `Streetlight` with this `Pole`
`streetlight` the `Streetlight` to associate with this `Pole`.
Returns A reference to this `Pole` to allow fluent use.
Raises `ValueError` if another `Streetlight` with the same `mrid` already exists in this `Pole`
"""
if self._validate_reference(streetlight, self.get_streetlight, "A Streetlight"):
return self
self._streetlights = list() if self._streetlights is None else self._streetlights
self._streetlights.append(streetlight)
return self
def remove_streetlight(self, streetlight: Streetlight) -> Pole:
"""
Disassociate `streetlight` from this `Pole`
`streetlight` the `Streetlight` to disassociate from this `Pole`.
Raises `ValueError` if `streetlight` was not associated with this `Pole`.
Returns A reference to this `Pole` to allow fluent use.
"""
self._streetlights = safe_remove(self._streetlights, streetlight)
return self
def clear_streetlights(self) -> Pole:
"""
Clear all Streetlights.
Returns self
"""
self._streetlights = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/assets/pole.py | pole.py |
from __future__ import annotations
from typing import Optional, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Equipment
from zepben.evolve.model.cim.iec61968.common.document import Document
from zepben.evolve.util import get_by_mrid, nlen, ngen, safe_remove
__all__ = ["OperationalRestriction"]
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.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/operations/operational_restriction.py | operational_restriction.py |
from __future__ import annotations
import logging
from typing import Optional, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Equipment
from zepben.evolve.model.cim.iec61968.assets.asset import AssetContainer
from zepben.evolve.model.cim.iec61968.common.location import Location
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.util import nlen, get_by_mrid, ngen, safe_remove
__all__ = ["Meter", "EndDevice", "UsagePoint"]
logger = logging.getLogger(__name__)
class EndDevice(AssetContainer):
"""
Asset container that performs one or more end device functions. One type of end device is a meter which can perform
metering, load management, connect/disconnect, accounting functions, etc. Some end devices, such as ones monitoring
and controlling air conditioners, refrigerators, pool pumps may be connected to a meter. All end devices may have
communication capability defined by the associated communication function(s).
An end device may be owned by a consumer, a service provider, utility or otherwise.
There may be a related end device function that identifies a sensor or control point within a metering application
or communications systems (e.g., water, gas, electricity).
Some devices may use an optical port that conforms to the ANSI C12.18 standard for communications.
"""
customer_mrid: Optional[str] = None
"""The `zepben.evolve.cim.iec61968.customers.customer.Customer` owning this `EndDevice`."""
service_location: Optional[Location] = None
"""Service `zepben.evolve.cim.iec61968.common.location.Location` whose service delivery is measured by this `EndDevice`."""
_usage_points: Optional[List[UsagePoint]] = None
def __init__(self, usage_points: List[UsagePoint] = None, **kwargs):
super(EndDevice, self).__init__(**kwargs)
if usage_points:
for up in usage_points:
self.add_usage_point(up)
def num_usage_points(self):
"""
Returns The number of `UsagePoint`s associated with this `EndDevice`
"""
return nlen(self._usage_points)
@property
def usage_points(self) -> Generator[UsagePoint, None, None]:
"""
The `UsagePoint`s associated with this `EndDevice`
"""
return ngen(self._usage_points)
def get_usage_point(self, mrid: str) -> UsagePoint:
"""
Get the `UsagePoint` for this `EndDevice` identified by `mrid`
`mrid` the mRID of the required `UsagePoint`
Returns The `UsagePoint` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._usage_points, mrid)
def add_usage_point(self, up: UsagePoint) -> EndDevice:
"""
Associate `up` to this `EndDevice`.
`up` the `UsagePoint` to associate with this `EndDevice`.
Returns A reference to this `EndDevice` to allow fluent use.
Raises `ValueError` if another `UsagePoint` with the same `mrid` already exists for this `EndDevice`.
"""
if self._validate_reference(up, self.get_usage_point, "A UsagePoint"):
return self
self._usage_points = list() if self._usage_points is None else self._usage_points
self._usage_points.append(up)
return self
def remove_usage_point(self, up: UsagePoint) -> EndDevice:
"""
Disassociate `up` from this `EndDevice`
`up` the `UsagePoint` to disassociate from this `EndDevice`.
Returns A reference to this `EndDevice` to allow fluent use.
Raises `ValueError` if `up` was not associated with this `EndDevice`.
"""
self._usage_points = safe_remove(self._usage_points, up)
return self
def clear_usage_points(self) -> EndDevice:
"""
Clear all usage_points.
Returns A reference to this `EndDevice` to allow fluent use.
"""
self._usage_points = None
return self
class UsagePoint(IdentifiedObject):
"""
Logical or physical point in the network to which readings or events may be attributed.
Used at the place where a physical or virtual meter may be located; however, it is not required that a meter be present.
"""
usage_point_location: Optional[Location] = None
"""Service `zepben.evolve.cim.iec61968.common.location.Location` where the service delivered by this `UsagePoint` is consumed."""
is_virtual: bool = False
"""
If true, this usage point is virtual, i.e., no physical location exists in the network where a meter could be located to
collect the meter readings. For example, one may define a virtual usage point to serve as an aggregation of usage for all
of a company's premises distributed widely across the distribution territory. Otherwise, the usage point is physical,
i.e., there is a logical point in the network where a meter could be located to collect meter readings.
"""
connection_category: Optional[str] = None
"""
A code used to specify the connection category, e.g., low voltage or low pressure, where the usage point is defined.
"""
_equipment: Optional[List[Equipment]] = None
_end_devices: Optional[List[EndDevice]] = None
def __init__(self, equipment: List[Equipment] = None, end_devices: List[EndDevice] = None, **kwargs):
super(UsagePoint, self).__init__(**kwargs)
if equipment:
for eq in equipment:
self.add_equipment(eq)
if end_devices:
for ed in end_devices:
self.add_end_device(ed)
def num_equipment(self):
"""
Returns The number of `Equipment`s associated with this `UsagePoint`
"""
return nlen(self._equipment)
def num_end_devices(self):
"""
Returns The number of `EndDevice`s associated with this `UsagePoint`
"""
return nlen(self._end_devices)
@property
def end_devices(self) -> Generator[EndDevice, None, None]:
"""
The `EndDevice`'s (Meter's) associated with this `UsagePoint`.
"""
return ngen(self._end_devices)
@property
def equipment(self) -> Generator[Equipment, None, None]:
"""
The `zepben.model.Equipment` associated with this `UsagePoint`.
"""
return ngen(self._equipment)
def get_equipment(self, mrid: str) -> Equipment:
"""
Get the `Equipment` for this `UsagePoint` 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) -> UsagePoint:
"""
Associate an `Equipment` with this `UsagePoint`
`equipment` The `Equipment` to associate with this `UsagePoint`.
Returns A reference to this `UsagePoint` to allow fluent use.
Raises `ValueError` if another `Equipment` with the same `mrid` already exists for this `UsagePoint`.
"""
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) -> UsagePoint:
"""
Disassociate an `Equipment` from this `UsagePoint`
`equipment` The `Equipment` to disassociate with this `UsagePoint`.
Returns A reference to this `UsagePoint` to allow fluent use.
Raises `ValueError` if `equipment` was not associated with this `UsagePoint`.
"""
self._equipment = safe_remove(self._equipment, equipment)
return self
def clear_equipment(self) -> UsagePoint:
"""
Clear all equipment.
Returns A reference to this `UsagePoint` to allow fluent use.
"""
self._equipment = None
return self
def get_end_device(self, mrid: str) -> EndDevice:
"""
Get the `EndDevice` for this `UsagePoint` identified by `mrid`
`mrid` The mRID of the required `EndDevice`
Returns The `EndDevice` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._end_devices, mrid)
def add_end_device(self, end_device: EndDevice) -> UsagePoint:
"""
Associate an `EndDevice` with this `UsagePoint`
`end_device` The `EndDevice` to associate with this `UsagePoint`.
Returns A reference to this `UsagePoint` to allow fluent use.
Raises `ValueError` if another `EndDevice` with the same `mrid` already exists for this `UsagePoint`.
"""
if self._validate_reference(end_device, self.get_end_device, "An EndDevice"):
return self
self._end_devices = list() if self._end_devices is None else self._end_devices
self._end_devices.append(end_device)
return self
def remove_end_device(self, end_device: EndDevice) -> UsagePoint:
"""
Disassociate `end_device` from this `UsagePoint`.
`end_device` The `EndDevice` to disassociate from this `UsagePoint`.
Returns A reference to this `UsagePoint` to allow fluent use.
Raises `ValueError` if `end_device` was not associated with this `UsagePoint`.
"""
self._end_devices = safe_remove(self._end_devices, end_device)
return self
def clear_end_devices(self) -> UsagePoint:
"""
Clear all end_devices.
Returns A reference to this `UsagePoint` to allow fluent use.
"""
self._end_devices = None
return self
def is_metered(self):
"""
Check whether this `UsagePoint` is metered. A `UsagePoint` is metered if it's associated with at least one `EndDevice`.
Returns True if this `UsagePoint` has an `EndDevice`, False otherwise.
"""
return nlen(self._end_devices) > 0
class Meter(EndDevice):
"""
Physical asset that performs the metering role of the usage point. Used for measuring consumption and detection of events.
"""
@property
def company_meter_id(self):
""" Returns this `Meter`s ID. Currently stored in `IdentifiedObject.name` """
return self.name
@company_meter_id.setter
def company_meter_id(self, meter_id):
"""
`meter_id` The ID to set for this Meter. Will use `IdentifiedObject.name` as a backing field.
"""
self.name = meter_id | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/metering/metering.py | metering.py |
from __future__ import annotations
from typing import Optional, List, Generator, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import PowerTransformerInfo
from zepben.evolve.model.cim.iec61968.assetinfo.transformer_end_info import TransformerEndInfo
from zepben.evolve.model.cim.iec61968.assets.asset_info import AssetInfo
from zepben.evolve.util import nlen, ngen, safe_remove, get_by_mrid
__all__ = ["TransformerTankInfo"]
class TransformerTankInfo(AssetInfo):
"""Set of transformer tank data, from an equipment library."""
power_transformer_info: Optional[PowerTransformerInfo] = None
"""Power transformer data that this tank description is part of."""
_transformer_end_infos: Optional[List[TransformerEndInfo]] = None
"""Data for all the ends described by this transformer tank data."""
def __init__(self, transformer_end_infos: List[TransformerEndInfo] = None, **kwargs):
super(TransformerTankInfo, self).__init__(**kwargs)
if transformer_end_infos:
for tei in transformer_end_infos:
self.add_transformer_end_info(tei)
def num_transformer_end_infos(self):
"""
Get the number of `TransformerEndInfo`s associated with this `TransformerTankInfo`.
"""
return nlen(self._transformer_end_infos)
@property
def transformer_end_infos(self) -> Generator[TransformerEndInfo, None, None]:
"""
The `TransformerEndInfo`s of this `TransformerTankInfo`.
"""
return ngen(self._transformer_end_infos)
def get_transformer_end_info(self, mrid: str) -> TransformerEndInfo:
"""
Get the `TransformerEndInfo` for this `TransformerTankInfo` identified by `mrid`.
`mrid` the mRID of the required `TransformerEndInfo`
Returns The `TransformerEndInfo` with the specified `mrid`.
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._transformer_end_infos, mrid)
def add_transformer_end_info(self, tei: TransformerEndInfo) -> TransformerTankInfo:
"""
`tei` The `TransformerEndInfo` to
associate with this `TransformerTankInfo`.
Returns A reference to this `TransformerTankInfo` to allow fluent use.
Raises `ValueError` if another `TransformerEndInfo` with the same `mrid` already
exists in this `TransformerTankInfo`
"""
if self._validate_reference(tei, self.get_transformer_end_info, "A TransformerEndInfo"):
return self
self._transformer_end_infos = list() if self._transformer_end_infos is None else self._transformer_end_infos
self._transformer_end_infos.append(tei)
return self
def remove_transformer_end_info(self, tei: TransformerEndInfo) -> TransformerTankInfo:
"""
Disassociate an `TransformerEndInfo` from this `TransformerTankInfo`.
`tei` the `TransformerEndInfo` to
disassociate with this `TransformerTankInfo`.
Raises `ValueError` if `tei` was not associated with this `TransformerTankInfo`.
Returns A reference to this `TransformerTankInfo` to allow fluent use.
"""
self._transformer_end_infos = safe_remove(self._transformer_end_infos, tei)
return self
def clear_transformer_end_infos(self) -> TransformerTankInfo:
"""
Clears all `TransformerEndInfo`.
Returns self
"""
self._transformer_end_infos = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/assetinfo/transformer_tank_info.py | transformer_tank_info.py |
from __future__ import annotations
import math
from typing import Optional, TYPE_CHECKING, Tuple
if TYPE_CHECKING:
from zepben.evolve import TransformerTankInfo, NoLoadTest, OpenCircuitTest, ShortCircuitTest
from zepben.evolve.model.cim.iec61968.assets.asset_info import AssetInfo
from zepben.evolve.model.cim.iec61970.base.wires.transformer_star_impedance import TransformerStarImpedance
from zepben.evolve.model.resistance_reactance import ResistanceReactance
from zepben.evolve.model.cim.iec61970.base.wires.winding_connection import WindingConnection
__all__ = ["TransformerEndInfo"]
class TransformerEndInfo(AssetInfo):
"""Transformer end data."""
connection_kind: WindingConnection = WindingConnection.UNKNOWN_WINDING
"""Kind of connection."""
emergency_s: Optional[int] = None
"""Apparent power that the winding can carry under emergency conditions (also called long-term emergency power). Unit: VA"""
end_number: int = 0
"""Number for this transformer end, corresponding to the end's order in the PowerTransformer.vectorGroup attribute. Highest voltage winding
should be 1."""
insulation_u: Optional[int] = None
"""Basic insulation level voltage rating. Unit: Volts"""
phase_angle_clock: Optional[int] = None
"""Winding phase angle where 360 degrees are represented with clock hours, so the valid values are {0, ..., 11}. For example,
to express the second winding in code 'Dyn11', set attributes as follows: 'endNumber'=2, 'connectionKind' = Yn and 'phaseAngleClock' = 11."""
r: Optional[float] = None
"""DC resistance. Unit: Ohms"""
rated_s: Optional[int] = None
"""Normal apparent power rating. Unit: VA"""
rated_u: Optional[int] = None
"""Rated voltage: phase-phase for three-phase windings, and either phase-phase or phase-neutral for single-phase windings. Unit: Volts"""
short_term_s: Optional[int] = None
"""Apparent power that this winding can carry for a short period of time (in emergency). Unit: VA"""
transformer_tank_info: Optional[TransformerTankInfo] = None
"""Transformer tank data that this end description is part of."""
transformer_star_impedance: Optional[TransformerStarImpedance] = None
"""Transformer star impedance calculated from this transformer end datasheet."""
energised_end_no_load_tests: Optional[NoLoadTest] = None
"""
All no-load test measurements in which this transformer end was energised.
"""
energised_end_short_circuit_tests: Optional[ShortCircuitTest] = None
"""
All short-circuit test measurements in which this transformer end was short-circuited.
"""
grounded_end_short_circuit_tests: Optional[ShortCircuitTest] = None
"""
All short-circuit test measurements in which this transformer end was energised.
"""
open_end_open_circuit_tests: Optional[OpenCircuitTest] = None
"""
All open-circuit test measurements in which this transformer end was not excited.
"""
energised_end_open_circuit_tests: Optional[OpenCircuitTest] = None
"""
All open-circuit test measurements in which this transformer end was excited.
"""
def resistance_reactance(self) -> Optional[ResistanceReactance]:
"""
Get the `ResistanceReactance` for this `TransformerEndInfo` from either the pre-calculated `transformer_star_impedance` or
calculated from the associated test data.
Returns the `ResistanceReactance` for this `TransformerEndInfo` or None if it could not be calculated
"""
if self.transformer_star_impedance is not None:
return self.transformer_star_impedance.resistance_reactance().merge_if_incomplete(lambda: self.calculate_resistance_reactance_from_tests())
else:
return self.calculate_resistance_reactance_from_tests()
def calculate_resistance_reactance_from_tests(self) -> Optional[ResistanceReactance]:
"""
Get the `ResistanceReactance` for this `TransformerEndInfo` calculated from the associated test data.
Returns the `ResistanceReactance` for this `TransformerEndInfo` or None if it could not be calculated
Calculation of r0 and x0 from Test data is not supported. r0 nad x0 must be populated directly in the
associated TransformerStarImpedance
"""
if not self.rated_u or not self.rated_s:
return None
def calculate_x(voltage: float, r: float) -> Optional[float]:
if voltage is None or r is None:
return None
return round(math.sqrt((((voltage / 100) * (self.rated_u ** 2) / self.rated_s) ** 2) - (r ** 2)), 2)
def calculate_r_x_from_test(short_circuit_test: ShortCircuitTest) -> Optional[Tuple[float, float]]:
if short_circuit_test is None:
return None
elif short_circuit_test.voltage_ohmic_part is not None:
r = round((short_circuit_test.voltage_ohmic_part * (self.rated_u ** 2)) / (self.rated_s * 100), 2)
elif short_circuit_test.loss is not None:
r = round(short_circuit_test.loss * ((self.rated_u / self.rated_s) ** 2), 2)
else:
return None
return r, calculate_x(short_circuit_test.voltage, r)
rr = ResistanceReactance()
rx = calculate_r_x_from_test(self.energised_end_short_circuit_tests)
if rx is not None:
rr.r, rr.x = rx
r0x0 = calculate_r_x_from_test(self.grounded_end_short_circuit_tests)
if r0x0 is not None:
rr.r0, rr.x0 = r0x0
return rr if not rr.is_empty() else None | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/assetinfo/transformer_end_info.py | transformer_end_info.py |
from __future__ import annotations
from typing import List, Optional, Generator
from zepben.evolve.model.cim.iec61968.assetinfo.transformer_tank_info import TransformerTankInfo
from zepben.evolve.model.cim.iec61968.assets.asset_info import AssetInfo
from zepben.evolve.util import nlen, ngen, get_by_mrid, safe_remove
__all__ = ["PowerTransformerInfo"]
class PowerTransformerInfo(AssetInfo):
"""Set of power transformer data, from an equipment library."""
_transformer_tank_infos: Optional[List[TransformerTankInfo]] = None
"""Data for all the tanks described by this power transformer data."""
def __init__(self, transformer_tank_infos: List[TransformerTankInfo] = None, **kwargs):
super(PowerTransformerInfo, self).__init__(**kwargs)
if transformer_tank_infos:
for ti in transformer_tank_infos:
self.add_transformer_tank_info(ti)
def num_transformer_tank_infos(self):
"""
Get the number of `TransformerTankInfo`s associated with this `PowerTransformerInfo`.
"""
return nlen(self._transformer_tank_infos)
@property
def transformer_tank_infos(self) -> Generator[TransformerTankInfo, None, None]:
"""
The `TransformerTankInfo`s of this `PowerTransformerInfo`.
"""
return ngen(self._transformer_tank_infos)
def get_transformer_tank_info(self, mrid: str) -> TransformerTankInfo:
"""
Get the `TransformerTankInfo` for this `PowerTransformerInfo` identified by `mrid`.
`mrid` the mRID of the required `TransformerTankInfo`
Returns The `TransformerTankInfo` with the specified `mrid`.
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._transformer_tank_infos, mrid)
def add_transformer_tank_info(self, tti: TransformerTankInfo) -> PowerTransformerInfo:
"""
`tti` The `TransformerTankInfo` to
associate with this `PowerTransformerInfo`.
Returns A reference to this `PowerTransformerInfo` to allow fluent use.
Raises `ValueError` if another `TransformerTankInfo` with the same `mrid` already
exists in this `PowerTransformerInfo`
"""
if self._validate_reference(tti, self.get_transformer_tank_info, "A TransformerTankInfo"):
return self
self._transformer_tank_infos = list() if self._transformer_tank_infos is None else self._transformer_tank_infos
self._transformer_tank_infos.append(tti)
return self
def remove_transformer_tank_info(self, tti: TransformerTankInfo) -> PowerTransformerInfo:
"""
Disassociate an `TransformerTankInfo` from this `PowerTransformerInfo`.
`tti` the `TransformerTankInfo` to
disassociate with this `PowerTransformerInfo`.
Raises `ValueError` if `tti` was not associated with this `PowerTransformerInfo`.
Returns A reference to this `Asset` to allow fluent use.
"""
self._transformer_tank_infos = safe_remove(self._transformer_tank_infos, tti)
return self
def clear_transformer_tank_infos(self) -> PowerTransformerInfo:
"""
Clears all `TransformerTankInfo`.
Returns self
"""
self._transformer_tank_infos = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/assetinfo/power_transformer_info.py | power_transformer_info.py |
from __future__ import annotations
from typing import List, Optional, Generator
from dataclassy import dataclass
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.util import require, nlen, ngen, safe_remove
__all__ = ["PositionPoint", "Location", "StreetAddress", "TownDetail", "StreetDetail"]
@dataclass(slots=True, frozen=True)
class PositionPoint(object):
"""
Set of spatial coordinates that determine a point, defined in WGS84 (latitudes and longitudes).
Use a single position point instance to desribe a point-oriented location.
Use a sequence of position points to describe a line-oriented object (physical location of non-point oriented
objects like cables or lines), or area of an object (like a substation or a geographical zone - in this case,
have first and last position point with the same values).
"""
x_position: float
"""X axis position - longitude"""
y_position: float
"""Y axis position - latitude"""
def __init__(self):
require(-90.0 <= self.y_position <= 90.0,
lambda: f"Latitude is out of range. Expected -90 to 90, got {self.y_position}.")
require(-180.0 <= self.x_position <= 180.0,
lambda: f"Longitude is out of range. Expected -180 to 180, got {self.x_position}.")
def __str__(self):
return f"{self.x_position}:{self.y_position}"
@property
def longitude(self):
return self.x_position
@property
def latitude(self):
return self.y_position
@dataclass(slots=True)
class TownDetail(object):
"""
Town details, in the context of address.
"""
name: Optional[str] = None
"""Town name."""
state_or_province: Optional[str] = None
"""Name of the state or province."""
def all_fields_null_or_empty(self):
"""Check to see if all fields of this `TownDetail` are null or empty."""
return not (self.name or self.state_or_province)
@dataclass(slots=True)
class StreetDetail(object):
"""
Street details, in the context of address.
"""
building_name: str = ""
"""
(if applicable) In certain cases the physical location of the place of interest does not have a direct point of entry from the street,
but may be located inside a larger structure such as a building, complex, office block, apartment, etc.
"""
floor_identification: str = ""
"""The identification by name or number, expressed as text, of the floor in the building as part of this address."""
name: str = ""
"""Name of the street."""
number: str = ""
"""Designator of the specific location on the street."""
suite_number: str = ""
"""Number of the apartment or suite."""
type: str = ""
"""Type of street. Examples include: street, circle, boulevard, avenue, road, drive, etc."""
display_address: str = ""
"""The address as it should be displayed to a user."""
def all_fields_empty(self):
"""Check to see if all fields of this `StreetDetail` are empty."""
return not (
self.building_name or
self.floor_identification or
self.name or
self.number or
self.suite_number or
self.type or
self.display_address
)
@dataclass(slots=True)
class StreetAddress(object):
"""
General purpose street and postal address information.
"""
postal_code: str = ""
"""Postal code for the address."""
town_detail: Optional[TownDetail] = None
"""Optional `TownDetail` for this address."""
po_box: str = ""
"""Post office box for the address."""
street_detail: Optional[StreetDetail] = None
"""Optional `StreetDetail` for this address."""
class Location(IdentifiedObject):
"""
The place, scene, or point of something where someone or something has been, is, and/or will be at a given moment in time.
It can be defined with one or more `PositionPoint`'s.
"""
main_address: Optional[StreetAddress] = None
"""Main address of the location."""
_position_points: Optional[List[PositionPoint]] = None
def __init__(self, position_points: List[PositionPoint] = None, **kwargs):
"""
`position_points` A list of `PositionPoint`s to associate with this `Location`.
"""
super(Location, self).__init__(**kwargs)
if position_points:
for point in position_points:
self.add_point(point)
def num_points(self):
"""
Returns The number of `PositionPoint`s in this `Location`
"""
return nlen(self._position_points)
@property
def points(self) -> Generator[PositionPoint, None, None]:
"""
Returns Generator over the `PositionPoint`s of this `Location`.
"""
for point in ngen(self._position_points):
yield point
def get_point(self, sequence_number: int) -> Optional[PositionPoint]:
"""
Get the `sequence_number` `PositionPoint` for this `Location`.
`sequence_number` The sequence number of the `PositionPoint` to get.
Returns The `PositionPoint` identified by `sequence_number`
Raises IndexError if this `Location` didn't contain `sequence_number` points.
"""
return self._position_points[sequence_number] if 0 <= sequence_number < nlen(self._position_points) else None
def __getitem__(self, item):
return self.get_point(item)
def add_point(self, point: PositionPoint) -> Location:
"""
Associate a `PositionPoint` with this `Location`, assigning it a sequence_number of `num_points`.
`point` The `PositionPoint` to associate with this `Location`.
Returns A reference to this `Location` to allow fluent use.
"""
return self.insert_point(point)
def insert_point(self, point: PositionPoint, sequence_number: int = None) -> Location:
"""
Associate a `PositionPoint` with this `Location`
`point` The `PositionPoint` to associate with this `Location`.
`sequence_number` The sequence number of the `PositionPoint`.
Returns A reference to this `Location` to allow fluent use.
Raises `ValueError` if `sequence_number` < 0 or > `num_points()`.
"""
if sequence_number is None:
sequence_number = self.num_points()
require(0 <= sequence_number <= self.num_points(),
lambda: f"Unable to add PositionPoint to {str(self)}. Sequence number {sequence_number} "
f"is invalid. Expected a value between 0 and {self.num_points()}. Make sure you are "
f"adding the points in the correct order and there are no gaps in the numbering.")
self._position_points = list() if self._position_points is None else self._position_points
self._position_points.insert(sequence_number, point)
return self
def __setitem__(self, key, value):
return self.insert_point(value, key)
def remove_point(self, point: PositionPoint) -> Location:
"""
Remove a `PositionPoint` from this `Location`
`point` The `PositionPoint` to remove.
Raises `ValueError` if `point` was not part of this `Location`
Returns A reference to this `Location` to allow fluent use.
"""
self._position_points = safe_remove(self._position_points, point)
return self
def clear_points(self) -> Location:
self._position_points = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61968/common/location.py | location.py |
import abc
from collections import Counter
from dataclasses import dataclass, field
from functools import reduce
from typing import Set, Tuple, FrozenSet, Dict, Callable, Union, TypeVar, Any, List, Generic, Optional, Iterable
from zepben.evolve import BasicTraversal, LifoQueue, Junction, BusbarSection, EquivalentBranch
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.model.cim.iec61970.base.wires.aclinesegment import AcLineSegment
from zepben.evolve.model.cim.iec61970.base.wires.energy_consumer import EnergyConsumer
from zepben.evolve.model.cim.iec61970.base.wires.energy_source import EnergySource
from zepben.evolve.model.cim.iec61970.base.wires.power_electronics_connection import PowerElectronicsConnection
from zepben.evolve.model.cim.iec61970.base.wires.power_transformer import PowerTransformer, PowerTransformerEnd
from zepben.evolve.model.cim.iec61970.base.wires.switch import Switch
from zepben.evolve.services.network.network_service import NetworkService
__all__ = [
"BusBranchNetworkCreationValidator",
"BusBranchNetworkCreator",
"BusBranchNetworkCreationMappings",
"BusBranchNetworkCreationResult",
"TerminalGrouping"
]
BBN = TypeVar('BBN') # Bus-Branch Network
TN = TypeVar('TN') # Topological Node
TB = TypeVar('TB') # Topological Branch
EB = TypeVar('EB') # Equivalent Branch
PT = TypeVar('PT') # Power Transformer
ES = TypeVar('ES') # Energy Source
EC = TypeVar('EC') # Energy Consumer
PEC = TypeVar('PEC') # Power Electronics Connection
class BusBranchNetworkCreationValidator(Generic[BBN, TN, TB, EB, PT, ES, EC, PEC], metaclass=abc.ABCMeta):
"""
Validator used to determine if node-breaker network data is fit for the creation of a bus-branch network.
"""
@classmethod
def __subclasshook__(cls, subclass):
return (hasattr(subclass, "is_valid_network_data") and callable(subclass.is_valid_network_data)
and hasattr(subclass, "is_valid_topological_node_data") and callable(subclass.is_valid_topological_node_data)
and hasattr(subclass, "is_valid_topological_branch_data") and callable(subclass.is_valid_topological_branch_data)
and hasattr(subclass, "is_valid_equivalent_branch_data") and callable(subclass.is_valid_topological_branch_data)
and hasattr(subclass, "is_valid_power_transformer_data") and callable(subclass.is_valid_power_transformer_data)
and hasattr(subclass, "is_valid_energy_source_data") and callable(subclass.is_valid_energy_source_data)
and hasattr(subclass, "is_valid_energy_consumer_data") and callable(subclass.is_valid_energy_consumer_data)
and hasattr(subclass, "is_valid_power_electronics_connection_data") and callable(subclass.is_valid_power_electronics_connection_data)
or NotImplemented)
@abc.abstractmethod
def is_valid_network_data(self, node_breaker_network: NetworkService) -> bool:
"""
Validates if provided data is fit for the creation of a bus-branch network.
NOTE: Refer to class `BusBranchNetworkCreator` for parameter information.
:return: Whether data is valid or not.
"""
raise NotImplementedError
@abc.abstractmethod
def is_valid_topological_node_data(
self,
bus_branch_network: BBN,
base_voltage: Optional[int],
collapsed_conducting_equipment: FrozenSet[ConductingEquipment],
border_terminals: FrozenSet[Terminal],
inner_terminals: FrozenSet[Terminal],
node_breaker_network: NetworkService
) -> bool:
"""
Validates if provided data is fit for the creation of a topological node.
NOTE: Refer to class `BusBranchNetworkCreator` for parameter information.
:return: Whether data is valid or not.
"""
raise NotImplementedError
@abc.abstractmethod
def is_valid_topological_branch_data(
self,
bus_branch_network: BBN,
connected_topological_nodes: Tuple[TN, TN],
length: Optional[float],
collapsed_ac_line_segments: FrozenSet[AcLineSegment],
border_terminals: FrozenSet[Terminal],
inner_terminals: FrozenSet[Terminal],
node_breaker_network: NetworkService
) -> bool:
"""
Validates if provided data is fit for the creation of a topological branch.
NOTE: Refer to class `BusBranchNetworkCreator` for parameter information.
:return: Whether data is valid or not.
"""
raise NotImplementedError
@abc.abstractmethod
def is_valid_equivalent_branch_data(
self,
bus_branch_network: BBN,
connected_topological_nodes: List[TN],
equivalent_branch: EquivalentBranch,
node_breaker_network: NetworkService
) -> bool:
"""
Validates if provided data is fit for the creation of an equivalent branch.
NOTE: Refer to class `BusBranchNetworkCreator` for parameter information.
:return: Whether data is valid or not.
"""
raise NotImplementedError
@abc.abstractmethod
def is_valid_power_transformer_data(
self,
bus_branch_network: BBN,
power_transformer: PowerTransformer,
ends_to_topological_nodes: List[Tuple[PowerTransformerEnd, Optional[TN]]],
node_breaker_network: NetworkService
) -> bool:
"""
Validates if provided data is fit for the creation of a power transformer.
NOTE: Refer to class `BusBranchNetworkCreator` for parameter information.
:return: Whether data is valid or not.
"""
raise NotImplementedError
@abc.abstractmethod
def is_valid_energy_source_data(
self,
bus_branch_network: BBN,
energy_source: EnergySource,
connected_topological_node: TN,
node_breaker_network: NetworkService
) -> bool:
"""
Validates if provided data is fit for the creation of an energy source.
NOTE: Refer to class `BusBranchNetworkCreator` for parameter information.
:return: Whether data is valid or not.
"""
raise NotImplementedError
@abc.abstractmethod
def is_valid_energy_consumer_data(
self,
bus_branch_network: BBN,
energy_consumer: EnergyConsumer,
connected_topological_node: TN,
node_breaker_network: NetworkService,
) -> bool:
"""
Validates if provided data is fit for the creation of an energy consumer.
NOTE: Refer to class `BusBranchNetworkCreator` for parameter information.
:return: Whether data is valid or not.
"""
raise NotImplementedError
@abc.abstractmethod
def is_valid_power_electronics_connection_data(
self,
bus_branch_network: BBN,
power_electronics_connection: PowerElectronicsConnection,
connected_topological_node: TN,
node_breaker_network: NetworkService
) -> bool:
"""
Validates if provided data is fit for the creation of a power electronics connection.
NOTE: Refer to class `BusBranchNetworkCreator` for parameter information.
:return: Whether data is valid or not.
"""
raise NotImplementedError
BNV = TypeVar('BNV', bound=BusBranchNetworkCreationValidator) # Subtype of BusBranchNetworkCreationValidator
class BusBranchNetworkCreator(Generic[BBN, TN, TB, EB, PT, ES, EC, PEC, BNV], metaclass=abc.ABCMeta):
"""Contains the logic needed to generate a target bus-branch network from a source `NetworkService`.
NOTE: All bus-branch network elements returned from the creators must have a uuid (universally unique identifier). This is needed to prevent collisions
when generating the mappings object between the source `NetworkService` and the target bus-branch network.
Generic Types:
- BBN := Type for the object used to represent the bus-branch network.
- TN := Type for the object used to represent a topological node in the bus-branch network.
- TB := Type for the object used to represent a topological branch in the bus-branch network.
- EB := Type for the object used to represent an equivalent branch in the bus-branch network.
- PT := Type for the object used to represent a power transformer in the bus-branch network.
- ES := Type for the object used to represent an energy source in the bus-branch network.
- EC := Type for the object used to represent an energy consumer in the bus-branch network.
- PEC := Type for the object used to represent a power electronics connection in the bus-branch network.
- BNV := Type for the validator instance used in the creation of the bus-branch network.
"""
@classmethod
def __subclasshook__(cls, subclass):
return (hasattr(subclass, "bus_branch_network_creator") and callable(subclass.bus_branch_network_creator)
and hasattr(subclass, "topological_node_creator") and callable(subclass.topological_node_creator)
and hasattr(subclass, "topological_branch_creator") and callable(subclass.topological_branch_creator)
and hasattr(subclass, "equivalent_branch_creator") and callable(subclass.topological_branch_creator)
and hasattr(subclass, "power_transformer_creator") and callable(subclass.power_transformer_creator)
and hasattr(subclass, "energy_source_creator") and callable(subclass.energy_source_creator)
and hasattr(subclass, "energy_consumer_creator") and callable(subclass.energy_consumer_creator)
and hasattr(subclass, "power_electronics_connection_creator") and callable(subclass.power_electronics_connection_creator)
and hasattr(subclass, "validator_creator") and callable(subclass.validator_creator)
or NotImplemented)
@abc.abstractmethod
def bus_branch_network_creator(self, node_breaker_network: NetworkService) -> BBN:
"""
Creates an empty target bus-branch network instance of type BBN.
:param node_breaker_network: Instance of type `NetworkService` being used as a source node-breaker network.
:return: Target bus-branch network of type BBN.
"""
raise NotImplementedError
@abc.abstractmethod
def topological_node_creator(
self,
bus_branch_network: BBN,
base_voltage: Optional[int],
collapsed_conducting_equipment: FrozenSet[ConductingEquipment],
border_terminals: FrozenSet[Terminal],
inner_terminals: FrozenSet[Terminal],
node_breaker_network: NetworkService
) -> Tuple[Any, TN]:
"""
Callback used to create a topological node instance of type TN.
:param bus_branch_network: Instance of type BBN being used as a target bus-branch network.
:param base_voltage: Base voltage value to be used for the topological node in Volts.
:param collapsed_conducting_equipment: Set that contains all instances of `ConductingEquipment` being collapsed in this topological node.
:param border_terminals: Set that contains all instances of `Terminal` that connect this topological node to other equipment.
:param inner_terminals: Set that contains all instances of `Terminal` collapsed in this topological node.
:param node_breaker_network: Instance of type `NetworkService` being used as a source node-breaker network.
:return: A 2-tuple with the first element being an id for the topological node and the second element being an instance of type TN that represents a
topological node in the target bus-branch network. This instance will be passed into the appropriate bus-branch model element creators for
the elements that are connected to this topological node.
"""
raise NotImplementedError
@abc.abstractmethod
def topological_branch_creator(
self,
bus_branch_network: BBN,
connected_topological_nodes: Tuple[TN, TN],
length: Optional[float],
collapsed_ac_line_segments: FrozenSet[AcLineSegment],
border_terminals: FrozenSet[Terminal],
inner_terminals: FrozenSet[Terminal],
node_breaker_network: NetworkService
) -> Tuple[Any, TB]:
"""
Callback used to create a topological branch instance in target bus-branch network.
:param bus_branch_network: Instance of type BBN being used as a target bus-branch network.
:param connected_topological_nodes: Instances of type TN connected to this topological branch sorted by `FeederDirection`.
:param length: Length of the topological branch in meters.
:param collapsed_ac_line_segments: Set that contains all instances of `AcLineSegment` being collapsed in this topological branch. e.g. connected lines
with the same impedance values.
:param border_terminals: Set that contains all instances of `Terminal` that connect this topological branch to other equipment.
:param inner_terminals: Set that contains all instances of `Terminal` collapsed in this topological branch.
:param node_breaker_network: Instance of type `NetworkService` being used as a source node-breaker network.
:return: A 2-tuple with the first element being an id for the topological branch and the second element being an instance of type TB that represents a
topological branch in the target bus-branch network.
"""
raise NotImplementedError
@abc.abstractmethod
def equivalent_branch_creator(
self,
bus_branch_network: BBN,
connected_topological_nodes: List[TN],
equivalent_branch: EquivalentBranch,
node_breaker_network: NetworkService
) -> Tuple[Any, EB]:
"""
Callback used to create an equivalent branch instance in target bus-branch network.
:param bus_branch_network: Instance of type BBN being used as a target bus-branch network.
:param connected_topological_nodes: Instances of type TN connected to this topological branch sorted by `FeederDirection`.
:param equivalent_branch: Instance of `EquivalentBranch` used to generate the equivalent branch in target bus-branch network.
:param node_breaker_network: Instance of type `NetworkService` being used as a source node-breaker network.
:return: A 2-tuple with the first element being an id for the topological branch and the second element being an instance of type TB that represents a
topological branch in the target bus-branch network.
"""
raise NotImplementedError
@abc.abstractmethod
def power_transformer_creator(
self,
bus_branch_network: BBN,
power_transformer: PowerTransformer,
ends_to_topological_nodes: List[Tuple[PowerTransformerEnd, Optional[TN]]],
node_breaker_network: NetworkService
) -> Dict[Any, PT]:
"""
Callback used to create a power transformer instance in target bus-branch network.
:param bus_branch_network: Instance of type BBN being used as a target bus-branch network.
:param power_transformer: Instance of `PowerTransformer` used to generate power transformer in target bus-branch network.
:param ends_to_topological_nodes: List holding power transformer ends with the topological nodes they are connected to sorted by `FeederDirection`.
:param node_breaker_network: Instance of type `NetworkService` being used as a source node-breaker network.
:return: A dictionary with keys being uuids for the instance/s of type PT that represents a power transformer in the target bus-branch network.
"""
raise NotImplementedError
@abc.abstractmethod
def energy_source_creator(
self,
bus_branch_network: BBN,
energy_source: EnergySource,
connected_topological_node: TN,
node_breaker_network: NetworkService
) -> Dict[Any, ES]:
"""
Callback used to create an energy source instance in target bus-branch network.
:param bus_branch_network: Instance of type BBN being used as a target bus-branch network.
:param energy_source: Instance of `EnergySource` used to generate energy source in target bus-branch network.
:param connected_topological_node: Topological node of type TN that is connected to this energy source.
:param node_breaker_network: Instance of type `NetworkService` being used as a source node-breaker network.
:return: A dictionary with keys being uuids for the instance/s of type ES that represents an energy source in the target bus-branch network.
"""
raise NotImplementedError
@abc.abstractmethod
def energy_consumer_creator(
self,
bus_branch_network: BBN,
energy_consumer: EnergyConsumer,
connected_topological_node: TN,
node_breaker_network: NetworkService,
) -> Dict[Any, EC]:
"""
Callback used to pass all the required values to generate an energy consumer object.
:param bus_branch_network: Instance of type BBN being used as a target bus-branch network.
:param energy_consumer: Instance of `EnergyConsumer` used to generate energy consumer in target bus-branch network.
:param connected_topological_node: Topological node of type TN that is connected to this energy consumer.
:param node_breaker_network: Instance of type `NetworkService` being used as a source node-breaker network.
:return: A dictionary with keys being uuids for the instance/s of type EC that represents an energy consumer in the target bus-branch network.
"""
raise NotImplementedError
@abc.abstractmethod
def power_electronics_connection_creator(
self,
bus_branch_network: BBN,
power_electronics_connection: PEC,
connected_topological_node: TN,
node_breaker_network: NetworkService
) -> Dict[Any, PEC]:
"""
Callback used to pass all the required values to generate a power electronics connection object.
:param bus_branch_network: Instance of type BBN being used as a target bus-branch network.
:param power_electronics_connection: Instance of `PowerElectronicsConnection` used to generate power electronics connection in target bus-branch
network.
:param connected_topological_node: Topological node of type TN that is connected to this power electronics connection.
:param node_breaker_network: Instance of type `NetworkService` being used as a source node-breaker network.
:return: A dictionary with keys being uuids for the instance/s of type PEC that represents a power electronics connection in the target bus-branch
network.
"""
raise NotImplementedError
@abc.abstractmethod
def validator_creator(self) -> BNV:
"""
Callback used to create 'BusBranchNetworkCreationValidator' instance used for validation while creating a bus-branch
network.
:return: Instance of type 'BusBranchNetworkCreationValidator'.
"""
raise NotImplementedError
# noinspection PyMethodMayBeStatic
def has_negligible_impedance(self, ce: ConductingEquipment) -> bool:
"""
Callback used to evaluate if an instance of `ConductingEquipment` has negligible impedance.
:param ce: `ConductingEquipment` instance whose impedance is being evaluated.
:return: True if 'ce' has negligible impedance, False otherwise.
"""
if isinstance(ce, AcLineSegment):
return ce.length == 0
if isinstance(ce, Switch):
return not ce.is_open()
if isinstance(ce, Junction) or isinstance(ce, BusbarSection):
return True
if isinstance(ce, EquivalentBranch):
return _is_no_impedance_branch(ce)
return False
async def create(self, node_breaker_network: NetworkService) -> 'BusBranchNetworkCreationResult[BBN, BNV]':
return await _create_bus_branch_network(self, node_breaker_network)
CE = TypeVar("CE", bound=ConductingEquipment)
@dataclass()
class TerminalGrouping(Generic[CE]):
border_terminals: Set[Terminal] = field(default_factory=set)
inner_terminals: Set[Terminal] = field(default_factory=set)
conducting_equipment_group: Set[CE] = field(default_factory=set)
def terminals(self) -> Set[Terminal]:
return {*self.border_terminals, *self.inner_terminals}
class BusBranchToNodeBreakerMappings:
def __init__(self):
self.topological_nodes: Dict[Any, TerminalGrouping[ConductingEquipment]] = {}
self.topological_branches: Dict[Any, TerminalGrouping[AcLineSegment]] = {}
self.equivalent_branches: Dict[Any, Set[EquivalentBranch]] = {}
self.power_transformers: Dict[Any, Set[PowerTransformer]] = {}
self.energy_sources: Dict[Any, Set[EnergySource]] = {}
self.energy_consumers: Dict[Any, Set[EnergyConsumer]] = {}
self.power_electronics_connections: Dict[Any, Set[PowerElectronicsConnection]] = {}
class NodeBreakerToBusBranchMappings:
def __init__(self):
self.objects: Dict[str, Set[Any]] = {}
class BusBranchNetworkCreationMappings:
"""
Holds mappings between a bus-branch network (bbn) and a node-breaker network (nbn) of type `NetworkService`.
"""
def __init__(self):
self.to_nbn = BusBranchToNodeBreakerMappings()
self.to_bbn = NodeBreakerToBusBranchMappings()
def _add_to_mapping(mapping: Dict[Any, Set[Any]], uuid: Any, obj_to_add: Any) -> None:
if uuid not in mapping:
mapping[uuid] = set()
mapping[uuid].add(obj_to_add)
class BusBranchNetworkCreationResult(Generic[BBN, BNV]):
"""
Represents the results of creating a bus-branch network from a node-breaker network.
"""
def __init__(self, validator: BNV):
self.validator: BNV = validator
self.mappings: BusBranchNetworkCreationMappings = BusBranchNetworkCreationMappings()
self.network: BBN = None
self.was_successful: bool = False
async def _create_bus_branch_network(
bus_branch_network_creator: BusBranchNetworkCreator[BBN, TN, TB, EB, PT, ES, EC, PEC, BNV],
node_breaker_network: NetworkService
) -> BusBranchNetworkCreationResult[BBN, BNV]:
"""
Creates bus-branch network.
:param bus_branch_network_creator: Instance of type `BusBranchNetworkCreator` used to generate the target bus-branch network.
:param node_breaker_network: Instance of type `NetworkService` being used as a source node-breaker network.
:return: `CreationResult`
"""
_validate_number_of_terminals(node_breaker_network)
validator = bus_branch_network_creator.validator_creator()
result: BusBranchNetworkCreationResult[BBN, BNV] = BusBranchNetworkCreationResult(validator)
if not validator.is_valid_network_data(node_breaker_network):
return result
bus_branch_network = bus_branch_network_creator.bus_branch_network_creator(node_breaker_network)
terminals_to_tns = {}
# create topological branches
tbs_creation_success = await _create_topological_branches(node_breaker_network, bus_branch_network,
bus_branch_network_creator, result,
terminals_to_tns, validator)
if not tbs_creation_success:
return result
# create equivalent branches
ebs_creation_success = await _create_equivalent_branches(node_breaker_network, bus_branch_network,
bus_branch_network_creator, result,
terminals_to_tns, validator)
if not ebs_creation_success:
return result
# create power transformers
pt_creation_success = await _create_power_transformers(node_breaker_network, bus_branch_network,
bus_branch_network_creator, result,
terminals_to_tns, validator)
if not pt_creation_success:
return result
# create energy sources
es_creation_success = await _create_energy_sources(node_breaker_network, bus_branch_network,
bus_branch_network_creator,
result, terminals_to_tns, validator)
if not es_creation_success:
return result
# create energy consumers
ec_creation_success = await _create_energy_consumers(node_breaker_network, bus_branch_network,
bus_branch_network_creator,
result, terminals_to_tns, validator)
if not ec_creation_success:
return result
# create power electronics connections
pec_creation_success = await _create_power_electronics_connections(node_breaker_network, bus_branch_network,
bus_branch_network_creator,
result, terminals_to_tns, validator)
if not pec_creation_success:
return result
result.network = bus_branch_network
result.was_successful = True
return result
async def _get_or_create_topological_node(
terminal: Terminal,
terminals_to_tns: Dict[str, TN],
node_breaker_network: NetworkService,
bus_branch_network: BBN,
bus_branch_network_creator: BusBranchNetworkCreator[BBN, TN, TB, EB, PT, ES, EC, PEC, BNV],
result: BusBranchNetworkCreationResult[BBN, BNV],
validator: BNV
) -> (bool, TN):
cached_tn = terminals_to_tns.get(terminal.mrid)
if cached_tn is not None:
return True, cached_tn
# group terminals connected by negligible impedance equipment
terminals_grouping = await _group_negligible_impedance_terminals(terminal,
bus_branch_network_creator.has_negligible_impedance)
negligible_impedance_equipment = frozenset(terminals_grouping.conducting_equipment_group)
inner_terms = frozenset(terminals_grouping.inner_terminals)
border_terms = frozenset(terminals_grouping.border_terminals)
rated_u = _get_base_voltage(border_terms)
# create topological node
if not validator.is_valid_topological_node_data(bus_branch_network,
rated_u,
negligible_impedance_equipment,
border_terms,
inner_terms,
node_breaker_network):
return False, None
tn_id, tn = bus_branch_network_creator.topological_node_creator(
bus_branch_network,
rated_u,
negligible_impedance_equipment,
border_terms,
inner_terms,
node_breaker_network
)
# populate result mappings
result.mappings.to_nbn.topological_nodes[tn_id] = terminals_grouping
for t in terminals_grouping.terminals():
_add_to_mapping(result.mappings.to_bbn.objects, t.mrid, tn)
if t.connectivity_node is not None:
_add_to_mapping(result.mappings.to_bbn.objects, t.connectivity_node.mrid, tn)
for ce in terminals_grouping.conducting_equipment_group:
_add_to_mapping(result.mappings.to_bbn.objects, ce.mrid, tn)
# map terminals to associated topological nodes for easy lookup when creating connected equipment
for t in border_terms:
terminals_to_tns[t.mrid] = tn
for t in inner_terms:
terminals_to_tns[t.mrid] = tn
return True, tn
async def _create_topological_branches(
node_breaker_network: NetworkService,
bus_branch_network: BBN,
bus_branch_network_creator: BusBranchNetworkCreator[BBN, TN, TB, EB, PT, ES, EC, PEC, BNV],
result: BusBranchNetworkCreationResult[BBN, BNV],
terminals_to_tns: Dict[str, TN],
validator: BNV
) -> bool:
processed_acls_ids = set()
for acls in node_breaker_network.objects(AcLineSegment):
if not (acls.mrid in processed_acls_ids or bus_branch_network_creator.has_negligible_impedance(acls)):
lines_grouping = await _group_common_ac_line_segment_terminals(acls)
border_terms = frozenset(lines_grouping.border_terminals)
common_acls = frozenset(lines_grouping.conducting_equipment_group)
inner_terms = frozenset(lines_grouping.inner_terminals)
# get/create connected topological nodes
acls_tns = []
for t in _sort_terminals_by_feeder_direction(border_terms):
tn_creation_success, tn = await _get_or_create_topological_node(t, terminals_to_tns,
node_breaker_network,
bus_branch_network,
bus_branch_network_creator,
result, validator)
if not tn_creation_success:
return False
acls_tns.append(tn)
total_length = reduce(lambda s, l: l.length + s, (common_acl for common_acl in common_acls), 0.0)
# create topological branch
if not validator.is_valid_topological_branch_data(bus_branch_network,
(acls_tns[0], acls_tns[1]),
total_length,
common_acls,
border_terms,
inner_terms,
node_breaker_network):
return False
tb_id, tb = bus_branch_network_creator.topological_branch_creator(
bus_branch_network,
(acls_tns[0], acls_tns[1]),
total_length,
common_acls,
border_terms,
inner_terms,
node_breaker_network
)
# populate result mappings
result.mappings.to_nbn.topological_branches[tb_id] = lines_grouping
for line in lines_grouping.conducting_equipment_group:
_add_to_mapping(result.mappings.to_bbn.objects, line.mrid, tb)
for t in lines_grouping.inner_terminals:
_add_to_mapping(result.mappings.to_bbn.objects, t.mrid, tb)
if t.connectivity_node is not None:
_add_to_mapping(result.mappings.to_bbn.objects, t.connectivity_node.mrid, tb)
# flag processed ac-line-segments
processed_acls_ids.update({acls.mrid for acls in common_acls})
return True
async def _create_equivalent_branches(
node_breaker_network: NetworkService,
bus_branch_network: BBN,
bus_branch_network_creator: BusBranchNetworkCreator[BBN, TN, TB, EB, PT, ES, EC, PEC, BNV],
result: BusBranchNetworkCreationResult[BBN, BNV],
terminals_to_tns: Dict[str, TN],
validator: BNV
) -> bool:
for eb in node_breaker_network.objects(EquivalentBranch):
if eb.mrid in result.mappings.to_bbn.objects:
# skip if already processed
continue
# get/create connected topological nodes
eb_tns = []
for t in _sort_terminals_by_feeder_direction(eb.terminals):
tn_creation_success, tn = await _get_or_create_topological_node(t, terminals_to_tns,
node_breaker_network,
bus_branch_network,
bus_branch_network_creator,
result, validator)
if not tn_creation_success:
return False
eb_tns.append(tn)
if bus_branch_network_creator.has_negligible_impedance(eb):
continue
# create equivalent branch
if not validator.is_valid_equivalent_branch_data(bus_branch_network, eb_tns, eb, node_breaker_network):
return False
teb_id, teb = bus_branch_network_creator.equivalent_branch_creator(bus_branch_network, eb_tns, eb, node_breaker_network)
# populate result mappings
_add_to_mapping(result.mappings.to_nbn.equivalent_branches, teb_id, eb)
_add_to_mapping(result.mappings.to_bbn.objects, eb.mrid, teb)
return True
async def _create_power_transformers(
node_breaker_network: NetworkService,
bus_branch_network: BBN,
bus_branch_network_creator: BusBranchNetworkCreator[BBN, TN, TB, EB, PT, ES, EC, PEC, BNV],
result: BusBranchNetworkCreationResult[BBN, BNV],
terminals_to_tns: Dict[str, TN],
validator: BNV
) -> bool:
for pt in node_breaker_network.objects(PowerTransformer):
# create list of ends with their connected topological nodes
ends_to_topological_nodes = []
for end in _sort_ends_by_feeder_direction(pt.ends):
if end.terminal is not None:
tn_creation_success, tn = await _get_or_create_topological_node(end.terminal, terminals_to_tns,
node_breaker_network,
bus_branch_network,
bus_branch_network_creator, result,
validator)
if not tn_creation_success:
return False
ends_to_topological_nodes.append((end, tn))
else:
ends_to_topological_nodes.append((end, None))
# create power transformer
if not validator.is_valid_power_transformer_data(bus_branch_network, pt, ends_to_topological_nodes,
node_breaker_network):
return False
txs = bus_branch_network_creator.power_transformer_creator(bus_branch_network, pt, ends_to_topological_nodes,
node_breaker_network)
# populate result mappings
for tx_id, tx in txs.items():
_add_to_mapping(result.mappings.to_nbn.power_transformers, tx_id, pt)
_add_to_mapping(result.mappings.to_bbn.objects, pt.mrid, tx)
return True
async def _create_energy_sources(
node_breaker_network: NetworkService,
bus_branch_network: BBN,
bus_branch_network_creator: BusBranchNetworkCreator[BBN, TN, TB, EB, PT, ES, EC, PEC, BNV],
result: BusBranchNetworkCreationResult[BBN, BNV],
terminals_to_tns: Dict[str, TN],
validator: BNV
) -> bool:
for es in node_breaker_network.objects(EnergySource):
es_terminal = next((t for t in es.terminals))
tn_creation_success, tn = await _get_or_create_topological_node(es_terminal, terminals_to_tns,
node_breaker_network,
bus_branch_network, bus_branch_network_creator,
result, validator)
if not tn_creation_success:
return False
if not validator.is_valid_energy_source_data(bus_branch_network, es, tn, node_breaker_network):
return False
bb_ess = bus_branch_network_creator.energy_source_creator(bus_branch_network, es, tn, node_breaker_network)
# populate result mappings
for bb_es_id, bb_es in bb_ess.items():
_add_to_mapping(result.mappings.to_nbn.energy_sources, bb_es_id, es)
_add_to_mapping(result.mappings.to_bbn.objects, es.mrid, bb_es)
return True
async def _create_energy_consumers(
node_breaker_network: NetworkService,
bus_branch_network: BBN,
bus_branch_network_creator: BusBranchNetworkCreator[BBN, TN, TB, EB, PT, ES, EC, PEC, BNV],
result: BusBranchNetworkCreationResult[BBN, BNV],
terminals_to_tns: Dict[str, TN],
validator: BNV
):
for ec in node_breaker_network.objects(EnergyConsumer):
ec_terminal = next((t for t in ec.terminals))
tn_creation_success, tn = await _get_or_create_topological_node(ec_terminal, terminals_to_tns,
node_breaker_network,
bus_branch_network, bus_branch_network_creator,
result, validator)
if not tn_creation_success:
return False
if not validator.is_valid_energy_consumer_data(bus_branch_network, ec, tn, node_breaker_network):
return False
bb_ecs = bus_branch_network_creator.energy_consumer_creator(bus_branch_network, ec, tn,
node_breaker_network)
# populate result mappings
for bb_ec_id, bb_ec in bb_ecs.items():
_add_to_mapping(result.mappings.to_nbn.energy_consumers, bb_ec_id, ec)
_add_to_mapping(result.mappings.to_bbn.objects, ec.mrid, bb_ec)
return True
async def _create_power_electronics_connections(
node_breaker_network: NetworkService,
bus_branch_network: BBN,
bus_branch_network_creator: BusBranchNetworkCreator[BBN, TN, TB, EB, PT, ES, EC, PEC, BNV],
result: BusBranchNetworkCreationResult[BBN, BNV],
terminals_to_tns: Dict[str, TN],
validator: BNV
):
for pec in node_breaker_network.objects(PowerElectronicsConnection):
pec_terminal = next((t for t in pec.terminals))
tn_creation_success, tn = await _get_or_create_topological_node(pec_terminal, terminals_to_tns,
node_breaker_network,
bus_branch_network, bus_branch_network_creator,
result, validator)
if not tn_creation_success:
return False
if not validator.is_valid_power_electronics_connection_data(bus_branch_network, pec, tn, node_breaker_network):
return False
bb_pecs = bus_branch_network_creator.power_electronics_connection_creator(bus_branch_network, pec, tn,
node_breaker_network)
# populate result mappings
for bb_pec_id, bb_pec in bb_pecs.items():
_add_to_mapping(result.mappings.to_nbn.power_electronics_connections, bb_pec_id, pec)
_add_to_mapping(result.mappings.to_bbn.objects, pec.mrid, bb_pec)
return True
def _get_base_voltage(border_terminals: FrozenSet[Terminal]) -> Union[int, None]:
voltages = set()
for t in border_terminals:
ce = t.conducting_equipment
# Open switches may have a different voltage rating from the negligible-impedance equipment group due to the equipment on the other side of it.
if isinstance(ce, Switch):
continue
if isinstance(ce, PowerTransformer):
end_voltage = next((e.rated_u for e in ce.ends if e.terminal is t), None)
if end_voltage is not None:
voltages.add(end_voltage)
else:
if ce.base_voltage is not None:
voltages.add(ce.base_voltage.nominal_voltage)
return next(iter(voltages), None)
def _validate_number_of_terminals(network: NetworkService):
illegal_acls = []
for acl in network.objects(AcLineSegment):
if acl.num_terminals() != 2:
illegal_acls.append(acl.mrid)
if len(illegal_acls) != 0:
raise ValueError(
f"NetworkService contains the following AcLineSegments with an invalid number of terminals: {illegal_acls}")
illegal_es = []
for es in network.objects(EnergySource):
if es.num_terminals() != 1:
illegal_es.append(es.mrid)
if len(illegal_es) != 0:
raise ValueError(
f"NetworkService contains the following EnergySources with an invalid number of terminals: {illegal_es}")
illegal_ec = []
for ec in network.objects(EnergyConsumer):
if ec.num_terminals() != 1:
illegal_ec.append(ec.mrid)
if len(illegal_ec) != 0:
raise ValueError(
f"NetworkService contains the following EnergyConsumers with an invalid number of terminals: {illegal_ec}")
illegal_pec = []
for pec in network.objects(PowerElectronicsConnection):
if pec.num_terminals() != 1:
illegal_pec.append(pec.mrid)
if len(illegal_pec) != 0:
raise ValueError(
f"NetworkService contains the following PowerElectronicsConnections with an invalid number of terminals: {illegal_pec}")
async def _group_negligible_impedance_terminals(
terminal: Terminal,
has_negligible_impedance: Callable[[ConductingEquipment], bool]
) -> TerminalGrouping[ConductingEquipment]:
tg = TerminalGrouping[ConductingEquipment]()
# noinspection PyArgumentList
trace = BasicTraversal(
start_item=terminal,
queue_next=_queue_terminals_across_negligible_impedance(has_negligible_impedance),
process_queue=LifoQueue(),
step_actions=[_process_terminal(tg, has_negligible_impedance)]
)
await trace.run()
return tg
def _process_terminal(
tg: TerminalGrouping[ConductingEquipment],
has_negligible_impedance: Callable[[ConductingEquipment], bool]
):
async def add_to_group(t: Terminal, _):
if has_negligible_impedance(t.conducting_equipment):
tg.conducting_equipment_group.add(t.conducting_equipment)
tg.inner_terminals.add(t)
else:
tg.border_terminals.add(t)
return add_to_group
def _queue_terminals_across_negligible_impedance(
has_negligible_impedance: Callable[[ConductingEquipment], bool]
):
def queue_next(terminal: Terminal, traversal: BasicTraversal[Terminal]):
if terminal.connectivity_node is not None:
traversal.process_queue.extend(ot for ot in terminal.connectivity_node.terminals if ot != terminal)
if has_negligible_impedance(terminal.conducting_equipment):
traversal.process_queue.extend(ot for ot in terminal.conducting_equipment.terminals if ot != terminal)
return queue_next
async def _group_common_ac_line_segment_terminals(acls: AcLineSegment) -> TerminalGrouping[AcLineSegment]:
def has_common_impedance(line: AcLineSegment):
return line.per_length_sequence_impedance.mrid == acls.per_length_sequence_impedance.mrid
common_acls: TerminalGrouping[AcLineSegment] = TerminalGrouping()
connectivity_node_counter = Counter()
# noinspection PyArgumentList
trace = BasicTraversal(
start_item=acls,
queue_next=_queue_common_impedance_lines(common_acls, has_common_impedance),
process_queue=LifoQueue(),
step_actions=[_process_acls(common_acls, connectivity_node_counter)]
)
await trace.run()
for t in (t for line in common_acls.conducting_equipment_group for t in line.terminals):
if t.connectivity_node is None:
common_acls.border_terminals.add(t)
continue
count = connectivity_node_counter.get(t.connectivity_node, 0)
if count == 1:
common_acls.border_terminals.add(t)
else:
common_acls.inner_terminals.add(t)
return common_acls
def _process_acls(
common_acls: TerminalGrouping[AcLineSegment],
connectivity_node_counter: Counter
):
async def add_to_group(acls: AcLineSegment, _):
if acls in common_acls.conducting_equipment_group:
return
common_acls.conducting_equipment_group.add(acls)
connectivity_node_counter.update(
(t.connectivity_node for t in acls.terminals if t.connectivity_node is not None))
return add_to_group
def _queue_common_impedance_lines(
common_acls: TerminalGrouping[AcLineSegment],
has_common_impedance: Callable[[AcLineSegment], bool]
):
def queue_next(acls: AcLineSegment, traversal: BasicTraversal[AcLineSegment]):
traversal.process_queue.extend(_next_common_acls(acls, has_common_impedance, common_acls))
return queue_next
def _next_common_acls(
acls: AcLineSegment,
has_common_impedance: Callable[[AcLineSegment], bool],
common_acls: TerminalGrouping[AcLineSegment]
) -> Set[AcLineSegment]:
acls_terminals = {*acls.terminals}
def can_process_ac_line(o: Terminal) -> bool:
return o not in acls_terminals \
and isinstance(o.conducting_equipment, AcLineSegment) \
and has_common_impedance(o.conducting_equipment) \
and o.conducting_equipment not in common_acls.conducting_equipment_group
def is_non_forking_ac_line(t: Terminal) -> bool:
return t.connectivity_node is not None and len(list(t.connectivity_node.terminals)) == 2
return {
o.conducting_equipment
for t in acls.terminals if is_non_forking_ac_line(t)
for o in t.connectivity_node.terminals if can_process_ac_line(o)
}
def _is_no_impedance_branch(eb: EquivalentBranch):
return eb.r is None or eb.x is None or eb.r == 0.0 or eb.x == 0.0
def _sort_ends_by_feeder_direction(ends: Iterable[PowerTransformerEnd]) -> List[PowerTransformerEnd]:
return sorted(iter(ends), key=lambda pte: 999 if pte.terminal is None else pte.terminal.normal_feeder_direction.value)
def _sort_terminals_by_feeder_direction(terminals: Iterable[Terminal]) -> List[Terminal]:
return sorted(iter(terminals), key=lambda ter: ter.normal_feeder_direction.value) | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/busbranch/bus_branch.py | bus_branch.py |
from __future__ import annotations
import os
import re
from collections.abc import Sized
from typing import List, Optional, Iterable, Callable, Any, TypeVar, Generator, Dict
from uuid import UUID
__all__ = ["get_by_mrid", "contains_mrid", "safe_remove", "safe_remove_by_id", "nlen", "ngen", "is_none_or_empty", "require", "pb_or_none", "CopyableUUID"]
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import IdentifiedObject
TIdentifiedObject = TypeVar('TIdentifiedObject', bound=IdentifiedObject)
T = TypeVar('T')
def snake2camelback(name: str):
return ''.join(word.title() for word in name.split('_'))
_camel_pattern = re.compile(r'(?<!^)(?=[A-Z])')
def camel2snake(name: str):
return _camel_pattern.sub('_', name).lower()
def iter_but_not_str(obj: Any):
return isinstance(obj, Iterable) and not isinstance(obj, (str, bytes, bytearray, dict))
def get_by_mrid(collection: Optional[Iterable[TIdentifiedObject]], mrid: str) -> TIdentifiedObject:
"""
Get an `zepben.evolve.cim.iec61970.base.core.identified_object.IdentifiedObject` from `collection` based on
its mRID.
`collection` The collection to operate on
`mrid` The mRID of the `IdentifiedObject` to lookup in the collection
Returns The `IdentifiedObject`
Raises `KeyError` if `mrid` was not found in the collection.
"""
if not collection:
raise KeyError(mrid)
for io in collection:
if io.mrid == mrid:
return io
raise KeyError(mrid)
def contains_mrid(collection: Optional[Iterable[IdentifiedObject]], mrid: str) -> bool:
"""
Check if a collection of `zepben.evolve.cim.iec61970.base.core.identified_object.IdentifiedObject` contains an
object with a specified mRID.
`collection` The collection to operate on
`mrid` The mRID to look up.
Returns True if an `IdentifiedObject` is found in the collection with the specified mRID, False otherwise.
"""
if not collection:
return False
try:
if get_by_mrid(collection, mrid):
return True
except KeyError:
return False
def safe_remove(collection: Optional[List[T]], obj: T):
"""
Remove an IdentifiedObject from a collection safely.
Raises `ValueError` if `obj` is not in the collection.
Returns The collection if successfully removed or None if after removal the collection was empty.
"""
if collection is not None:
collection.remove(obj)
if not collection:
return None
return collection
else:
raise ValueError(obj)
def safe_remove_by_id(collection: Optional[Dict[str, IdentifiedObject]], obj: Optional[IdentifiedObject]):
"""
Remove an IdentifiedObject from a collection safely.
Raises `ValueError` if `obj` is not in the collection.
Returns The collection if successfully removed or None if after removal the collection was empty.
"""
if not obj or not collection:
raise KeyError(obj)
del collection[obj.mrid]
if not collection:
return None
return collection
def nlen(sized: Optional[Sized]) -> int:
"""
Get the len of a nullable sized type.
`sized` The object to get length of
Returns 0 if `sized` is None, otherwise len(`sized`)
"""
return 0 if sized is None else len(sized)
def ngen(collection: Optional[Iterable[T]]) -> Generator[T, None, None]:
if collection:
for item in collection:
yield item
def is_none_or_empty(sized: Optional[Sized]) -> bool:
"""
Check if a given object is empty and return None if it is.
`sized` Any type implementing `__len__`
Returns `sized` if len(sized) > 0, or None if sized is None or len(sized) == 0.
"""
return sized is None or not len(sized)
def require(condition: bool, lazy_message: Callable[[], Any]):
"""
Raise a `ValueError` if condition is not met, with the result of calling `lazy_message` as the message,
if the result is false.
"""
if not condition:
raise ValueError(str(lazy_message()))
def pb_or_none(cim: Optional[Any]):
""" Convert to a protobuf type or return None if cim was None """
return cim.to_pb() if cim is not None else None
class CopyableUUID(UUID):
def __init__(self):
super().__init__(bytes=os.urandom(16), version=4)
@staticmethod
def copy():
return str(UUID(bytes=os.urandom(16), version=4)) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/util.py | util.py |
from zepben.evolve.model.cim.iec61968.customers.pricing_structure import *
from zepben.evolve.model.cim.iec61968.customers.customer_agreement import *
from zepben.evolve.model.cim.iec61968.customers.customer_kind import *
from zepben.evolve.model.cim.iec61968.customers.customer import *
from zepben.evolve.model.cim.iec61968.customers.tariff import *
from zepben.evolve.model.cim.iec61968.assets.structure import *
from zepben.evolve.model.cim.iec61968.assets.asset import *
from zepben.evolve.model.cim.iec61968.assets.pole import *
from zepben.evolve.model.cim.iec61968.assets.asset_organisation_role import *
from zepben.evolve.model.cim.iec61968.assets.asset_info import *
from zepben.evolve.model.cim.iec61968.assets.streetlight import *
from zepben.evolve.model.cim.iec61968.operations.operational_restriction import *
from zepben.evolve.model.cim.iec61968.assetinfo.wire_info import *
from zepben.evolve.model.cim.iec61968.assetinfo.power_transformer_info import *
from zepben.evolve.model.cim.iec61968.assetinfo.wire_material_kind import *
from zepben.evolve.model.cim.iec61968.assetinfo.transformer_test import *
from zepben.evolve.model.cim.iec61968.assetinfo.no_load_test import *
from zepben.evolve.model.cim.iec61968.assetinfo.open_circuit_test import *
from zepben.evolve.model.cim.iec61968.assetinfo.short_circuit_test import *
from zepben.evolve.model.cim.iec61968.assetinfo.shunt_compensator_info import *
from zepben.evolve.model.cim.iec61968.assetinfo.transformer_end_info import *
from zepben.evolve.model.cim.iec61968.assetinfo.transformer_tank_info import *
from zepben.evolve.model.cim.iec61968.metering.metering import *
from zepben.evolve.model.cim.iec61968.common.organisation import *
from zepben.evolve.model.cim.iec61968.common.document import *
from zepben.evolve.model.cim.iec61968.common.organisation_role import *
from zepben.evolve.model.cim.iec61968.common.location import *
from zepben.evolve.model.cim.iec61968.infiec61968.infassetinfo.transformer_construction_kind import *
from zepben.evolve.model.cim.iec61968.infiec61968.infassetinfo.transformer_function_kind import *
from zepben.evolve.model.cim.iec61970.base.equivalents.equivalent_branch import *
from zepben.evolve.model.cim.iec61970.base.equivalents.equivalent_equipment import *
from zepben.evolve.model.cim.iec61970.base.meas.control import *
from zepben.evolve.model.cim.iec61970.base.meas.measurement import *
from zepben.evolve.model.cim.iec61970.base.meas.value import *
from zepben.evolve.model.cim.iec61970.base.meas.iopoint import *
from zepben.evolve.model.cim.iec61970.base.diagramlayout.diagram_layout import *
from zepben.evolve.model.cim.iec61970.base.diagramlayout.orientation_kind import *
from zepben.evolve.model.cim.iec61970.base.diagramlayout.diagram_style import *
from zepben.evolve.model.cim.iec61970.base.scada.remote_point import *
from zepben.evolve.model.cim.iec61970.base.scada.remote_source import *
from zepben.evolve.model.cim.iec61970.base.scada.remote_control import *
from zepben.evolve.model.cim.iec61970.base.domain.unit_symbol import *
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.auxiliary_equipment import *
from zepben.evolve.model.cim.iec61970.base.wires.generation.production.power_electronics_unit import *
from zepben.evolve.model.cim.iec61970.base.wires.generation.production.battery_state_kind import *
from zepben.evolve.model.cim.iec61970.base.wires.line import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_consumer import *
from zepben.evolve.model.cim.iec61970.base.wires.aclinesegment import *
from zepben.evolve.model.cim.iec61970.base.wires.per_length import *
from zepben.evolve.model.cim.iec61970.base.wires.vector_group import *
from zepben.evolve.model.cim.iec61970.base.wires.winding_connection import *
from zepben.evolve.model.cim.iec61970.base.wires.shunt_compensator import *
from zepben.evolve.model.cim.iec61970.base.wires.power_electronics_connection import *
from zepben.evolve.model.cim.iec61970.base.wires.power_transformer import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_source_phase import *
from zepben.evolve.model.cim.iec61970.base.wires.phase_shunt_connection_kind import *
from zepben.evolve.model.cim.iec61970.base.wires.connectors import *
from zepben.evolve.model.cim.iec61970.base.wires.switch import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_source import *
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_connection import *
from zepben.evolve.model.cim.iec61970.base.wires.transformer_star_impedance import *
from zepben.evolve.model.cim.iec61970.base.core.substation import *
from zepben.evolve.model.cim.iec61970.base.core.terminal import *
from zepben.evolve.model.cim.iec61970.base.core.equipment import *
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import *
from zepben.evolve.model.cim.iec61970.base.core.identified_object import *
from zepben.evolve.model.cim.iec61970.base.core.base_voltage import *
from zepben.evolve.model.cim.iec61970.base.core.power_system_resource import *
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node_container import *
from zepben.evolve.model.cim.iec61970.base.core.regions import *
from zepben.evolve.model.cim.iec61970.base.core.phase_code import *
from zepben.evolve.model.cim.iec61970.base.core.equipment_container import *
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node import *
from zepben.evolve.model.cim.iec61970.base.core.name import *
from zepben.evolve.model.cim.iec61970.base.core.name_type import *
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.circuit import *
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.loop import *
from zepben.evolve.model.phases import *
from zepben.evolve.model.resistance_reactance import *
from zepben.evolve.services.network.tracing.traversals.tracker import *
from zepben.evolve.services.network.tracing.traversals.traversal import *
from zepben.evolve.services.network.tracing.traversals.queue import *
from zepben.evolve.services.network.tracing.traversals.branch_recursive_tracing import *
from zepben.evolve.services.network.tracing.feeder.feeder_direction import *
from zepben.evolve.services.network.tracing.util import *
from zepben.evolve.services.network.translator.network_proto2cim import *
from zepben.evolve.services.network.translator.network_cim2proto import *
from zepben.evolve.services.network.network_service import *
from zepben.evolve.services.network.tracing.connectivity import *
from zepben.evolve.services.network.tracing.connectivity.connectivity_result import *
from zepben.evolve.services.network.tracing.connectivity.connectivity_trace import *
from zepben.evolve.services.network.tracing.connectivity.phase_paths import *
from zepben.evolve.services.network.tracing.connectivity.terminal_connectivity_connected import *
from zepben.evolve.services.network.tracing.connectivity.terminal_connectivity_internal import *
from zepben.evolve.services.network.tracing.connectivity.transformer_phase_paths import *
from zepben.evolve.services.network.tracing.connectivity.xy_candidate_phase_paths import *
from zepben.evolve.services.network.tracing.connectivity.xy_phase_step import *
from zepben.evolve.services.network.tracing.feeder.direction_status import *
from zepben.evolve.services.network.tracing.feeder.assign_to_feeders import *
from zepben.evolve.services.network.tracing.feeder.associated_terminal_trace import *
from zepben.evolve.services.network.tracing.feeder.associated_terminal_tracker import *
from zepben.evolve.services.network.tracing.feeder.set_direction import *
from zepben.evolve.services.network.tracing.feeder.remove_direction import *
from zepben.evolve.services.network.tracing.phases.phase_step import *
from zepben.evolve.services.network.tracing.phases.phase_status import *
from zepben.evolve.services.network.tracing.phases.phase_step_tracker import *
from zepben.evolve.services.network.tracing.phases.phase_trace import *
from zepben.evolve.services.network.tracing.phases.set_phases import *
from zepben.evolve.services.network.tracing.phases.phase_inferrer import *
from zepben.evolve.services.network.tracing.phases.remove_phases import *
from zepben.evolve.services.network.tracing.find import *
from zepben.evolve.services.network.tracing.tracing import *
from zepben.evolve.services.common.meta.data_source import *
from zepben.evolve.services.common.meta.metadata_collection import *
from zepben.evolve.services.common.translator.base_proto2cim import *
from zepben.evolve.services.common.base_service import *
from zepben.evolve.services.common.reference_resolvers import BoundReferenceResolver, ReferenceResolver, UnresolvedReference
import zepben.evolve.services.common.resolver as resolver
from zepben.evolve.services.diagram.translator.diagram_proto2cim import *
from zepben.evolve.services.diagram.translator.diagram_cim2proto import *
from zepben.evolve.services.diagram.diagrams import *
from zepben.evolve.services.customer.translator.customer_cim2proto import *
from zepben.evolve.services.customer.translator.customer_proto2cim import *
from zepben.evolve.services.customer.customers import *
from zepben.evolve.services.measurement.translator.measurement_cim2proto import *
from zepben.evolve.services.measurement.translator.measurement_proto2cim import *
from zepben.evolve.services.measurement.measurements import *
from zepben.evolve.streaming.exceptions import *
from zepben.evolve.streaming.get.hierarchy.data import *
from zepben.evolve.streaming.get.consumer import *
from zepben.evolve.streaming.get.customer_consumer import *
from zepben.evolve.streaming.get.diagram_consumer import *
from zepben.evolve.streaming.get.network_consumer import *
from zepben.evolve.streaming.exceptions import *
from zepben.evolve.streaming.grpc.grpc import *
from zepben.evolve.streaming.grpc.channel_builder import *
from zepben.evolve.streaming.grpc.connect import *
from zepben.evolve.util import *
from zepben.evolve.services.network.tracing.connected_equipment_trace import *
from zepben.evolve.services.network.network_extensions import *
from zepben.evolve.model.busbranch.bus_branch import *
from zepben.evolve.services.common.difference import *
from zepben.evolve.services.common.translator.service_differences import *
from zepben.evolve.services.common.base_service_comparator import BaseServiceComparator
from zepben.evolve.services.network.network_service_comparator import NetworkServiceComparator
from zepben.evolve.database.sqlite.tables.column import *
from zepben.evolve.database.sqlite.tables.sqlite_table import *
from zepben.evolve.database.sqlite.tables.metadata_tables import *
from zepben.evolve.database.sqlite.tables.associations.loop_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.circuit_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.customeragreements_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.equipment_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.usagepoints_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.assetorganisationroles_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.pricingstructure_association_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.common_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.asset_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.customer_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.metering_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.assetinfo_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.operations_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.core_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.meas_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.scada_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.equivalent_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.auxiliaryequipment_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.diagramlayout_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.container_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.switch_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.energyconnection_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.transformer_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.conductor_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.connector_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.perlength_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.generation.production_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.infiec61970.feeder_tables import *
from zepben.evolve.database.sqlite.tables.database_tables import *
from zepben.evolve.database.sqlite.tables.exceptions import *
from zepben.evolve.database.sqlite.writers.base_cim_writer import *
from zepben.evolve.database.sqlite.writers.network_cim_writer import *
from zepben.evolve.database.sqlite.writers.customer_cim_writer import *
from zepben.evolve.database.sqlite.writers.diagram_cim_writer import *
from zepben.evolve.database.sqlite.writers.metadata_entry_writer import *
from zepben.evolve.database.sqlite.writers.metadata_collection_writer import *
from zepben.evolve.database.sqlite.writers.base_service_writer import *
from zepben.evolve.database.sqlite.writers.network_service_writer import *
from zepben.evolve.database.sqlite.writers.customer_service_writer import *
from zepben.evolve.database.sqlite.writers.diagram_service_writer import *
from zepben.evolve.database.sqlite.database_writer import *
from zepben.evolve.database.sqlite.readers.result_set import ResultSet
from zepben.evolve.database.sqlite.readers.base_cim_reader import *
from zepben.evolve.database.sqlite.readers.base_service_reader import *
from zepben.evolve.database.sqlite.readers.customer_cim_reader import *
from zepben.evolve.database.sqlite.readers.customer_service_reader import *
from zepben.evolve.database.sqlite.readers.diagram_cim_reader import *
from zepben.evolve.database.sqlite.readers.diagram_service_reader import *
from zepben.evolve.database.sqlite.readers.metadata_entry_reader import *
from zepben.evolve.database.sqlite.readers.metadata_collection_reader import *
from zepben.evolve.database.sqlite.readers.network_cim_reader import *
from zepben.evolve.database.sqlite.readers.network_service_reader import *
from zepben.evolve.database.sqlite.database_reader import *
from zepben.evolve.testing.test_network_builder import * | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/__init__.py | __init__.py |
import logging
import os
import sqlite3
from contextlib import contextmanager
from typing import Generator, Set, List
from dataclassy import dataclass
from zepben.evolve import DatabaseTables, MetadataCollection, BaseService, TableVersion, MetadataCollectionWriter, MetadataEntryWriter, NetworkService, \
NetworkServiceWriter, NetworkCIMWriter, DiagramService, CustomerService, CustomerCIMWriter
from zepben.evolve.database.sqlite.writers.customer_service_writer import CustomerServiceWriter
from zepben.evolve.database.sqlite.writers.diagram_cim_writer import DiagramCIMWriter
from zepben.evolve.database.sqlite.writers.diagram_service_writer import DiagramServiceWriter
__all__ = ["DatabaseWriter", "connection", "cursor"]
logger = logging.getLogger("DatabaseWriter")
@contextmanager
def connection(connection_string: str) -> sqlite3.Connection:
try:
conn = sqlite3.connect(connection_string)
conn.isolation_level = None # autocommit off
yield conn
conn.commit()
conn.close()
except sqlite3.Error as e:
logger.error(f"Failed to connect to the database for saving: {e}")
return None
@contextmanager
def cursor(conn: sqlite3.Connection) -> Generator[sqlite3.Cursor, None, None]:
cur = conn.cursor()
cur.execute("PRAGMA journal_mode = OFF")
cur.execute("PRAGMA synchronous = OFF")
yield cur
cur.close()
@dataclass(slots=True)
class DatabaseWriter(object):
database_path: str
_database_tables: DatabaseTables = DatabaseTables()
_saved_common_mrids: Set[str] = set()
_has_been_used: bool = False
def save(self, metadata_collection: MetadataCollection, services: List[BaseService]) -> bool:
if not services:
logger.warning("No services were provided, therefore there is nothing to save")
return False
if self._has_been_used:
logger.error("You can only use the database writer once.")
return False
self._has_been_used = True
if not self._pre_save():
return False
with connection(self.database_path) as conn:
if not self._create(conn):
return False
with cursor(conn) as c:
# noinspection PyArgumentList
status = MetadataCollectionWriter().save(metadata_collection, MetadataEntryWriter(self._database_tables, c))
for service in services:
try:
if isinstance(service, NetworkService):
# noinspection PyArgumentList
status = status and NetworkServiceWriter(self.has_common, self.add_common).save(service, NetworkCIMWriter(self._database_tables, c))
elif isinstance(service, CustomerService):
# noinspection PyArgumentList
status = status and \
CustomerServiceWriter(self.has_common, self.add_common).save(service, CustomerCIMWriter(self._database_tables, c))
elif isinstance(service, DiagramService):
# noinspection PyArgumentList
status = status and DiagramServiceWriter(self.has_common, self.add_common).save(service, DiagramCIMWriter(self._database_tables, c))
else:
logger.error(f"Unsupported service of type {service.__class__.__name__} couldn't be saved.")
status = False
except Exception as e:
logger.error(f"Unable to save database: {e}")
status = False
return status and self._post_save(conn)
# connection closed here
def add_common(self, mrid: str) -> bool:
self._saved_common_mrids.add(mrid)
return True
def has_common(self, mrid: str) -> bool:
return mrid in self._saved_common_mrids
def _pre_save(self) -> bool:
return self._remove_existing()
def _remove_existing(self) -> bool:
try:
if os.path.isfile(self.database_path):
os.remove(self.database_path)
return True
except Exception as e:
logger.error(f"Unable to save database, failed to remove previous instance: {e}")
return False
def _create(self, conn: sqlite3.Connection) -> bool:
try:
version_table = self._database_tables.get_table(TableVersion)
logger.info(f"Creating database schema v{version_table.SUPPORTED_VERSION}")
with cursor(conn) as c:
for table in self._database_tables.tables:
c.execute(table.create_table_sql())
c.execute(version_table.prepared_insert_sql(), (version_table.SUPPORTED_VERSION,))
conn.commit()
return True
except sqlite3.Error as e:
logger.error(f"Failed to create database schema {e}")
return False
def _post_save(self, conn) -> bool:
try:
with cursor(conn) as c:
for table in self._database_tables.tables:
for index_sql in table.create_indexes_sql():
c.execute(index_sql)
conn.commit()
return True
except sqlite3.Error as e:
logger.error(f"Failed to create indexes and finalise the database: {e}")
return False | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/database_writer.py | database_writer.py |
import logging
import sqlite3
from sqlite3 import Connection, Cursor
from typing import Callable, Optional
from zepben.evolve import MetadataCollection, NetworkService, DiagramService, CustomerService, MetadataEntryReader, DiagramCIMReader, CustomerCIMReader, \
TableVersion, MetadataCollectionReader, DiagramServiceReader, CustomerServiceReader, Feeder, EnergySource, ConductingEquipment, connected_equipment
from zepben.evolve.database.sqlite.readers.network_cim_reader import NetworkCIMReader
from zepben.evolve.database.sqlite.readers.network_service_reader import NetworkServiceReader
from zepben.evolve.services.network.tracing import tracing
logger = logging.getLogger(__name__)
__all__ = ["DatabaseReader"]
class DatabaseReader:
def __init__(
self,
database_file: str,
get_connection: Callable[[str], Connection] = lambda database: sqlite3.connect(database),
get_cursor: Callable[[Connection], Cursor] = lambda conn: conn.cursor()
):
"""
:param database_file: the filename of the database to write.
:param get_connection: provider of the connection to the specified database.
:param get_cursor: provider of statements for the connection.
"""
self._database_file = database_file
self._get_connection = get_connection
self._get_cursor = get_cursor
_connection: Optional[Connection] = None
_has_been_used = False
def load(
self,
metadata_collection: MetadataCollection,
network_service: NetworkService,
diagram_service: DiagramService,
customer_service: CustomerService
) -> bool:
if not self._connect_database():
self._close_connection()
return False
metadata_reader = MetadataEntryReader(metadata_collection)
network_service_reader = NetworkCIMReader(network_service)
diagram_service_reader = DiagramCIMReader(diagram_service)
customer_service_reader = CustomerCIMReader(customer_service)
def get_cursor() -> Cursor:
return self._get_cursor(self._connection)
try:
status = MetadataCollectionReader(get_cursor).load(metadata_reader) \
and NetworkServiceReader(get_cursor).load(network_service_reader) \
and DiagramServiceReader(get_cursor).load(diagram_service_reader) \
and CustomerServiceReader(get_cursor).load(customer_service_reader)
except Exception as e:
logger.error(f"Unable to load database: {str(e)}")
self._close_connection()
return False
return status and self._post_load(network_service)
def _connect_database(self) -> bool:
if self._has_been_used:
logger.error("You can only use the database reader once.")
return False
self._has_been_used = True
try:
self._connection = self._get_connection(self._database_file)
cur = self._get_cursor(self._connection)
cur.execute("SELECT version FROM version")
rows = cur.fetchall()
if len(rows) == 1:
version = int(rows[0][0])
if version == TableVersion.SUPPORTED_VERSION:
return True
logger.error(f"Invalid database version. Found {version}, expected {TableVersion.SUPPORTED_VERSION}.")
else:
logger.error("Unable to read version from database. Please make sure the database is a valid EWB database.")
except Exception as e:
logger.error(f"Failed to connect to the database for reading: {str(e)}")
return False
def _close_connection(self):
if self._connection is None:
return
try:
self._connection.close()
except Exception as e:
logger.error(f"Failed to close connection to database: {str(e)}")
finally:
self._connection = None
def _post_load(self, network_service: NetworkService) -> bool:
#
# NOTE: phase and direction tracing is not yet supported
#
logger.info("Applying feeder direction to network...")
tracing.set_direction().run(network_service)
logger.info("Feeder direction applied to network.")
logger.info("Applying phases to network...")
tracing.set_phases().run(network_service)
tracing.phase_inferrer().run(network_service)
logger.info("Phasing applied to network.")
logger.info("Assigning equipment to feeders...")
tracing.assign_equipment_containers_to_feeders().run(network_service)
logger.info("Equipment assigned to feeders.")
logger.info("Validating primary sources vs feeders...")
self._validate_sources(network_service)
logger.info("Sources vs feeders validated.")
self._close_connection()
return True
def _validate_sources(self, network_service: NetworkService):
def get_head_equipment(feeder: Feeder) -> Optional[ConductingEquipment]:
if feeder.normal_head_terminal is not None:
return feeder.normal_head_terminal.conducting_equipment
else:
return None
# We do not want to warn about sources attached directly to the feeder start point.
feeder_start_points = set(filter(lambda it: it is not None, map(get_head_equipment, network_service.objects(Feeder))))
def has_been_assigned_to_feeder(energy_source: EnergySource) -> bool:
return energy_source.is_external_grid \
and self._is_on_feeder(energy_source) \
and feeder_start_points.isdisjoint(set(connected_equipment(energy_source)))
for es in filter(has_been_assigned_to_feeder, network_service.objects(EnergySource)):
logger.warning(f"External grid source {es} has been assigned to the following feeders: normal {es.normal_feeders}, current {es.current_feeders}")
@staticmethod
def _is_on_feeder(energy_source: EnergySource) -> bool:
return bool(list(energy_source.normal_feeders)) or bool(list(energy_source.current_feeders)) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/database_reader.py | database_reader.py |
from zepben.evolve.database.sqlite.tables.associations.customeragreements_association_tables import TableCustomerAgreementsPricingStructures
from zepben.evolve.database.sqlite.tables.associations.pricingstructure_association_tables import TablePricingStructuresTariffs
from zepben.evolve.database.sqlite.tables.database_tables import PreparedStatement
from zepben.evolve.database.sqlite.tables.iec61968.common_tables import TableAgreements
from zepben.evolve.database.sqlite.tables.iec61968.customer_tables import TableCustomers, TableCustomerAgreements, TablePricingStructures, TableTariffs
from zepben.evolve.database.sqlite.writers.base_cim_writer import BaseCIMWriter
from zepben.evolve.model.cim.iec61968.common.document import Agreement
from zepben.evolve.model.cim.iec61968.customers.customer import Customer
from zepben.evolve.model.cim.iec61968.customers.customer_agreement import CustomerAgreement
from zepben.evolve.model.cim.iec61968.customers.pricing_structure import PricingStructure
from zepben.evolve.model.cim.iec61968.customers.tariff import Tariff
__all__ = ["CustomerCIMWriter"]
class CustomerCIMWriter(BaseCIMWriter):
def save_agreement(self, table: TableAgreements, insert: PreparedStatement, agreement: Agreement, description: str) -> bool:
return self._save_document(table, insert, agreement, description)
def save_customer(self, customer: Customer) -> bool:
table = self.database_tables.get_table(TableCustomers)
insert = self.database_tables.get_insert(TableCustomers)
insert.add_value(table.kind.query_index, customer.kind.name)
insert.add_value(table.num_end_devices.query_index, 0) # Currently unused
return self.save_organisation_role(table, insert, customer, "Customer")
def save_customer_agreement(self, customer_agreement: CustomerAgreement) -> bool:
table = self.database_tables.get_table(TableCustomerAgreements)
insert = self.database_tables.get_insert(TableCustomerAgreements)
status = True
for ps in customer_agreement.pricing_structures:
status = status and self.save_customer_agreement_to_pricing_structure_association(customer_agreement, ps)
insert.add_value(table.customer_mrid.query_index, self._mrid_or_none(customer_agreement.customer))
return status and self.save_agreement(table, insert, customer_agreement, "CustomerAgreement")
def save_pricing_structure(self, pricing_structure: PricingStructure) -> bool:
table = self.database_tables.get_table(TablePricingStructures)
insert = self.database_tables.get_insert(TablePricingStructures)
status = True
for tariff in pricing_structure.tariffs:
status = status and self.save_pricing_structure_to_tariff_association(pricing_structure, tariff)
return status and self._save_document(table, insert, pricing_structure, "PricingStructure")
def save_tariff(self, tariff: Tariff) -> bool:
table = self.database_tables.get_table(TableTariffs)
insert = self.database_tables.get_insert(TableTariffs)
return self._save_document(table, insert, tariff, "tariff")
# Associations #
def save_customer_agreement_to_pricing_structure_association(self, customer_agreement: CustomerAgreement, pricing_structure: PricingStructure) -> bool:
table = self.database_tables.get_table(TableCustomerAgreementsPricingStructures)
insert = self.database_tables.get_insert(TableCustomerAgreementsPricingStructures)
insert.add_value(table.customer_agreement_mrid.query_index, customer_agreement.mrid)
insert.add_value(table.pricing_structure_mrid.query_index, pricing_structure.mrid)
return self.try_execute_single_update(insert, f"{customer_agreement.mrid}-to-{pricing_structure.mrid}",
"CustomerAgreement to PricingStructure association")
def save_pricing_structure_to_tariff_association(self, pricing_structure: PricingStructure, tariff: Tariff) -> bool:
table = self.database_tables.get_table(TablePricingStructuresTariffs)
insert = self.database_tables.get_insert(TablePricingStructuresTariffs)
insert.add_value(table.pricing_structure_mrid.query_index, pricing_structure.mrid)
insert.add_value(table.tariff_mrid.query_index, tariff.mrid)
return self.try_execute_single_update(insert, f"{pricing_structure.mrid}-to-{tariff.mrid}", "PricingStructure to Tariff association") | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/writers/customer_cim_writer.py | customer_cim_writer.py |
from zepben.evolve import NetworkService, CableInfo, OverheadWireInfo, PowerTransformerInfo, TransformerTankInfo, NoLoadTest, OpenCircuitTest, \
ShortCircuitTest, ShuntCompensatorInfo, TransformerEndInfo, AssetOwner, Pole, Streetlight, Location, Organisation, Meter, UsagePoint, \
OperationalRestriction, FaultIndicator, BaseVoltage, ConnectivityNode, Feeder, GeographicalRegion, Site, SubGeographicalRegion, Substation, Terminal, \
EquivalentBranch, PhotoVoltaicUnit, AcLineSegment, Breaker, LoadBreakSwitch, BusbarSection, Disconnector, EnergyConsumer, EnergyConsumerPhase, \
EnergySource, EnergySourcePhase, Fuse, Jumper, Junction, LinearShuntCompensator, PerLengthSequenceImpedance, PowerElectronicsConnection, \
PowerElectronicsConnectionPhase, PowerTransformer, PowerTransformerEnd, RatioTapChanger, Recloser, TransformerStarImpedance, Circuit, Loop, Analog, \
Accumulator, Discrete, Control, RemoteControl, RemoteSource, BatteryUnit, PowerElectronicsWindUnit
from zepben.evolve.database.sqlite.writers.base_service_writer import BaseServiceWriter
from zepben.evolve.database.sqlite.writers.network_cim_writer import NetworkCIMWriter
__all__ = ["NetworkServiceWriter"]
class NetworkServiceWriter(BaseServiceWriter):
def save(self, service: NetworkService, writer: NetworkCIMWriter) -> bool:
status = super(NetworkServiceWriter, self).save(service, writer)
status = status and self._save_all(service, CableInfo, writer.save_cable_info)
status = status and self._save_all(service, OverheadWireInfo, writer.save_overhead_wire_info)
status = status and self._save_all(service, PowerTransformerInfo, writer.save_power_transformer_info)
status = status and self._save_all(service, TransformerTankInfo, writer.save_transformer_tank_info)
status = status and self._save_all(service, NoLoadTest, writer.save_no_load_test)
status = status and self._save_all(service, OpenCircuitTest, writer.save_open_circuit_test)
status = status and self._save_all(service, ShortCircuitTest, writer.save_short_circuit_test)
status = status and self._save_all(service, ShuntCompensatorInfo, writer.save_shunt_compensator_info)
status = status and self._save_all(service, TransformerEndInfo, writer.save_transformer_end_info)
status = status and self._save_all(service, AssetOwner, writer.save_asset_owner)
status = status and self._save_all(service, Pole, writer.save_pole)
status = status and self._save_all(service, Streetlight, writer.save_streetlight)
status = status and self._save_all(service, Location, writer.save_location)
status = status and self._save_all_common(service, Organisation, writer.save_organisation)
status = status and self._save_all(service, Meter, writer.save_meter)
status = status and self._save_all(service, UsagePoint, writer.save_usage_point)
status = status and self._save_all(service, OperationalRestriction, writer.save_operational_restriction)
status = status and self._save_all(service, FaultIndicator, writer.save_fault_indicator)
status = status and self._save_all(service, BaseVoltage, writer.save_base_voltage)
status = status and self._save_all(service, ConnectivityNode, writer.save_connectivity_node)
status = status and self._save_all(service, Feeder, writer.save_feeder)
status = status and self._save_all(service, GeographicalRegion, writer.save_geographical_region)
status = status and self._save_all(service, Site, writer.save_site)
status = status and self._save_all(service, SubGeographicalRegion, writer.save_sub_geographical_region)
status = status and self._save_all(service, Substation, writer.save_substation)
status = status and self._save_all(service, Terminal, writer.save_terminal)
status = status and self._save_all(service, EquivalentBranch, writer.save_equivalent_branch)
status = status and self._save_all(service, BatteryUnit, writer.save_battery_unit)
status = status and self._save_all(service, PhotoVoltaicUnit, writer.save_photovoltaic_unit)
status = status and self._save_all(service, PowerElectronicsWindUnit, writer.save_power_electronics_wind_unit)
status = status and self._save_all(service, AcLineSegment, writer.save_ac_line_segment)
status = status and self._save_all(service, Breaker, writer.save_breaker)
status = status and self._save_all(service, LoadBreakSwitch, writer.save_load_break_switch)
status = status and self._save_all(service, BusbarSection, writer.save_bus_bar_section)
status = status and self._save_all(service, Disconnector, writer.save_disconnector)
status = status and self._save_all(service, EnergyConsumer, writer.save_energy_consumer)
status = status and self._save_all(service, EnergyConsumerPhase, writer.save_energy_consumer_phase)
status = status and self._save_all(service, EnergySource, writer.save_energy_source)
status = status and self._save_all(service, EnergySourcePhase, writer.save_energy_source_phase)
status = status and self._save_all(service, Fuse, writer.save_fuse)
status = status and self._save_all(service, Jumper, writer.save_jumper)
status = status and self._save_all(service, Junction, writer.save_junction)
status = status and self._save_all(service, LinearShuntCompensator, writer.save_linear_shunt_compensator)
status = status and self._save_all(service, PerLengthSequenceImpedance, writer.save_per_length_sequence_impedance)
status = status and self._save_all(service, PowerElectronicsConnection, writer.save_power_electronics_connection)
status = status and self._save_all(service, PowerElectronicsConnectionPhase, writer.save_power_electronics_connection_phase)
status = status and self._save_all(service, PowerTransformer, writer.save_power_transformer)
status = status and self._save_all(service, PowerTransformerEnd, writer.save_power_transformer_end)
status = status and self._save_all(service, RatioTapChanger, writer.save_ratio_tap_changer)
status = status and self._save_all(service, Recloser, writer.save_recloser)
status = status and self._save_all(service, TransformerStarImpedance, writer.save_transformer_star_impedance)
status = status and self._save_all(service, Circuit, writer.save_circuit)
status = status and self._save_all(service, Loop, writer.save_loop)
status = status and self._save_all(service, Analog, writer.save_analog)
status = status and self._save_all(service, Accumulator, writer.save_accumulator)
status = status and self._save_all(service, Discrete, writer.save_discrete)
status = status and self._save_all(service, Control, writer.save_control)
status = status and self._save_all(service, RemoteControl, writer.save_remote_control)
status = status and self._save_all(service, RemoteSource, writer.save_remote_source)
return status | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/writers/network_service_writer.py | network_service_writer.py |
import logging
from traceback import format_exc
from typing import Callable, TypeVar, Generic, Type
from dataclassy import dataclass
from zepben.evolve import BaseService, BaseCIMWriter, NameType, Name, IdentifiedObject
from zepben.evolve.database.sqlite.writers.utils import validate_save
__all__ = ["BaseServiceWriter"]
logger = logging.getLogger(__name__)
T = TypeVar("T", bound=BaseService)
W = TypeVar("W", bound=BaseCIMWriter)
S = TypeVar("S", bound=IdentifiedObject)
@dataclass(slots=True)
class BaseServiceWriter(Generic[T, W]):
has_common: Callable[[str], bool]
add_common: Callable[[str], bool]
def save(self, service: T, writer: W) -> bool:
status = True
for name_type in service.name_types:
type_name_id = f"NameType:{name_type.name}"
if not self.has_common(type_name_id):
status = status and (self._validate_save_name_type(name_type, writer.save_name_type) and self.add_common(type_name_id))
for name in name_type.names:
name_id = f"Name:{name.type.name}:{name.name}:{name.identified_object.mrid}"
if not self.has_common(name_id):
status = status and (self._validate_save_name(name, writer.save_name) and self.add_common(name_id))
return status
def try_save_common(self, obj: S, save: Callable[[S], bool]) -> bool:
if self.has_common(obj.mrid):
return True
if not self.validate_save(obj, save):
return False
return self.add_common(obj.mrid)
@staticmethod
def validate_save(it: S, saver: Callable[[S], bool]) -> bool:
return validate_save(it, saver, lambda e: logger.error(f"Failed to save {it}: {e}\n{format_exc()}"))
@staticmethod
def _validate_save_name_type(name_type: NameType, saver: Callable[[NameType], bool]) -> bool:
return validate_save(name_type, saver, lambda e: logger.error(f"Failed to save {name_type.__class__.__name__} {name_type.name}: {e}"))
@staticmethod
def _validate_save_name(name: Name, saver: Callable[[Name], bool]) -> bool:
return validate_save(name, saver, lambda e: logger.error(f"Failed to save {name.__class__.__name__} {name.name}: {e}"))
def _save_all(self, service: BaseService, type_: Type[S], save: Callable[[S], bool]) -> bool:
status = True
for obj in service.objects(type_):
status = status and self.validate_save(obj, save)
return status
def _save_all_common(self, service: BaseService, type_: Type[S], save: Callable[[S], bool]) -> bool:
status = True
for obj in service.objects(type_):
status = status and self.try_save_common(obj, save)
return status | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/writers/base_service_writer.py | base_service_writer.py |
from zepben.evolve import CableInfo, TableCableInfo, PreparedStatement, WireInfo, TableWireInfo, AssetInfo, TableOverheadWireInfo, OverheadWireInfo, \
PowerTransformerInfo, TablePowerTransformerInfo, TableAcDcTerminals, AcDcTerminal, BaseVoltage, TableBaseVoltages, TableConductingEquipment, \
ConductingEquipment, TableEquipment, Equipment, Feeder, TableEquipmentUsagePoints, ConnectivityNode, TableConnectivityNodes, \
TableConnectivityNodeContainers, ConnectivityNodeContainer, TablePowerSystemResources, PowerSystemResource, TableEquipmentContainers, EquipmentContainer, \
TableFeeders, GeographicalRegion, TableGeographicalRegions, Site, TableSites, TableSubGeographicalRegions, SubGeographicalRegion, TableSubstations, \
Substation, Terminal, TableTerminals, TableAssets, TableAssetInfo, TableAssetContainers, TablePowerElectronicsUnit, PowerElectronicsUnit, BatteryUnit, \
TableBatteryUnit, PhotoVoltaicUnit, TablePhotoVoltaicUnit, PowerElectronicsWindUnit, TablePowerElectronicsWindUnit, AcLineSegment, TableAcLineSegments, \
TableConductors, Conductor, Breaker, TableBreakers, LoadBreakSwitch, TableLoadBreakSwitches, BusbarSection, \
TableBusbarSections, TableConnectors, Connector, Disconnector, TableDisconnectors, TableEnergyConnections, EnergyConnection, TableEnergyConsumers, \
EnergyConsumer, EnergyConsumerPhase, TableEnergyConsumerPhases, EnergySource, TableEnergySources, TableEnergySourcePhases, EnergySourcePhase, Fuse, \
TableFuses, Jumper, TableJumpers, Junction, TableJunctions, TableLines, Line, LinearShuntCompensator, TableLinearShuntCompensators, \
TablePerLengthSequenceImpedances, TablePerLengthLineParameters, TableCircuitsSubstations, \
PerLengthLineParameter, PerLengthSequenceImpedance, TableRegulatingCondEq, RegulatingCondEq, TableShuntCompensators, ShuntCompensator, \
TableProtectedSwitches, ProtectedSwitch, TableSwitches, Switch, PowerElectronicsConnection, TablePowerElectronicsConnection, \
PowerElectronicsConnectionPhase, TablePowerElectronicsConnectionPhases, PowerTransformer, TablePowerTransformers, PowerTransformerEnd, \
TablePowerTransformerEnds, TableTransformerEnds, TransformerEnd, TransformerStarImpedance, TableTransformerStarImpedance, TableTapChangers, TapChanger, \
RatioTapChanger, TableRatioTapChangers, TableCircuits, Circuit, Loop, TableLoops, LoopSubstationRelationship, UsagePoint, EndDevice, \
TableUsagePointsEndDevices, AssetOrganisationRole, Asset, AssetContainer, TableAssetOrganisationRolesAssets, TableEquipmentEquipmentContainers, \
TableCircuitsTerminals, TableLoopsSubstations, TransformerEndInfo, TableTransformerEndInfo, TransformerTankInfo, TableTransformerTankInfo, NoLoadTest, \
TableNoLoadTests, TableTransformerTest, TransformerTest, ShortCircuitTest, TableShortCircuitTests, OpenCircuitTest, TableOpenCircuitTests, \
PerLengthImpedance, TablePerLengthImpedances, TableAssetOrganisationRoles, AssetOwner, TableAssetOwners, TableStructures, Structure, Pole, TablePoles, \
Streetlight, TableStreetlights, Location, TableLocations, TableLocationStreetAddressField, StreetAddress, TableLocationStreetAddresses, PositionPoint, \
TablePositionPoints, TableStreetAddresses, TableTownDetails, TownDetail, StreetDetail, TableEndDevices, Meter, TableMeters, TableUsagePoints, \
OperationalRestriction, TableOperationalRestrictions, TableFaultIndicators, TableAuxiliaryEquipment, AuxiliaryEquipment, FaultIndicator, \
TableMeasurements, Measurement, Analog, TableAnalogs, Accumulator, TableAccumulators, Discrete, TableDiscretes, Control, TableControls, TableIoPoints, \
IoPoint, TableRemotePoints, RemotePoint, RemoteControl, TableRemoteControls, RemoteSource, TableRemoteSources, ShuntCompensatorInfo, \
TableShuntCompensatorInfo, EquivalentBranch, EquivalentEquipment, Recloser, TableReclosers, TableEquipmentOperationalRestrictions
from zepben.evolve.database.sqlite.tables.iec61970.base.equivalent_tables import TableEquivalentBranches, TableEquivalentEquipment
from zepben.evolve.database.sqlite.writers.base_cim_writer import BaseCIMWriter
__all__ = ["NetworkCIMWriter"]
class NetworkCIMWriter(BaseCIMWriter):
# ************ IEC61968 ASSET INFO ************
def save_cable_info(self, cable_info: CableInfo) -> bool:
table = self.database_tables.get_table(TableCableInfo)
insert = self.database_tables.get_insert(TableCableInfo)
return self._save_wire_info(table, insert, cable_info, "cable info")
def save_no_load_test(self, no_load_test: NoLoadTest) -> bool:
table = self.database_tables.get_table(TableNoLoadTests)
insert = self.database_tables.get_insert(TableNoLoadTests)
insert.add_value(table.energised_end_voltage.query_index, no_load_test.energised_end_voltage)
insert.add_value(table.exciting_current.query_index, no_load_test.exciting_current)
insert.add_value(table.exciting_current_zero.query_index, no_load_test.exciting_current_zero)
insert.add_value(table.loss.query_index, no_load_test.loss)
insert.add_value(table.loss_zero.query_index, no_load_test.loss_zero)
return self._save_transformer_test(table, insert, no_load_test, "no load test")
def _save_transformer_test(self, table: TableTransformerTest, insert: PreparedStatement, transformer_test: TransformerTest, description: str) -> bool:
insert.add_value(table.base_power.query_index, transformer_test.base_power)
insert.add_value(table.temperature.query_index, transformer_test.temperature)
return self.save_identified_object(table, insert, transformer_test, description)
def save_short_circuit_test(self, short_circuit_test: ShortCircuitTest) -> bool:
table = self.database_tables.get_table(TableShortCircuitTests)
insert = self.database_tables.get_insert(TableShortCircuitTests)
insert.add_value(table.current.query_index, short_circuit_test.current)
insert.add_value(table.energised_end_step.query_index, short_circuit_test.energised_end_step)
insert.add_value(table.grounded_end_step.query_index, short_circuit_test.grounded_end_step)
insert.add_value(table.leakage_impedance.query_index, short_circuit_test.leakage_impedance)
insert.add_value(table.leakage_impedance_zero.query_index, short_circuit_test.leakage_impedance_zero)
insert.add_value(table.loss.query_index, short_circuit_test.loss)
insert.add_value(table.loss_zero.query_index, short_circuit_test.loss_zero)
insert.add_value(table.power.query_index, short_circuit_test.power)
insert.add_value(table.voltage.query_index, short_circuit_test.voltage)
insert.add_value(table.voltage_ohmic_part.query_index, short_circuit_test.voltage_ohmic_part)
return self._save_transformer_test(table, insert, short_circuit_test, "short circuit test")
def save_shunt_compensator_info(self, shunt_compensator_info: ShuntCompensatorInfo) -> bool:
table = self.database_tables.get_table(TableShuntCompensatorInfo)
insert = self.database_tables.get_insert(TableShuntCompensatorInfo)
insert.add_value(table.max_power_loss.query_index, shunt_compensator_info.max_power_loss)
insert.add_value(table.rated_current.query_index, shunt_compensator_info.rated_current)
insert.add_value(table.rated_reactive_power.query_index, shunt_compensator_info.rated_reactive_power)
insert.add_value(table.rated_voltage.query_index, shunt_compensator_info.rated_voltage)
return self._save_asset_info(table, insert, shunt_compensator_info, "shunt compensator info")
def save_open_circuit_test(self, open_circuit_test: OpenCircuitTest) -> bool:
table = self.database_tables.get_table(TableOpenCircuitTests)
insert = self.database_tables.get_insert(TableOpenCircuitTests)
insert.add_value(table.energised_end_step.query_index, open_circuit_test.energised_end_step)
insert.add_value(table.energised_end_voltage.query_index, open_circuit_test.energised_end_voltage)
insert.add_value(table.open_end_step.query_index, open_circuit_test.open_end_step)
insert.add_value(table.open_end_voltage.query_index, open_circuit_test.open_end_voltage)
insert.add_value(table.phase_shift.query_index, open_circuit_test.phase_shift)
return self._save_transformer_test(table, insert, open_circuit_test, "open circuit test")
def save_overhead_wire_info(self, overhead_wire_info: OverheadWireInfo) -> bool:
table = self.database_tables.get_table(TableOverheadWireInfo)
insert = self.database_tables.get_insert(TableOverheadWireInfo)
return self._save_wire_info(table, insert, overhead_wire_info, "overhead wire info")
def save_power_transformer_info(self, power_transformer_info: PowerTransformerInfo) -> bool:
table = self.database_tables.get_table(TablePowerTransformerInfo)
insert = self.database_tables.get_insert(TablePowerTransformerInfo)
return self._save_asset_info(table, insert, power_transformer_info, "power transformer info")
def save_transformer_end_info(self, transformer_end_info: TransformerEndInfo) -> bool:
table = self.database_tables.get_table(TableTransformerEndInfo)
insert = self.database_tables.get_insert(TableTransformerEndInfo)
insert.add_value(table.connection_kind.query_index, transformer_end_info.connection_kind.short_name)
insert.add_value(table.emergency_s.query_index, transformer_end_info.emergency_s)
insert.add_value(table.end_number.query_index, transformer_end_info.end_number)
insert.add_value(table.insulation_u.query_index, transformer_end_info.insulation_u)
insert.add_value(table.phase_angle_clock.query_index, transformer_end_info.phase_angle_clock)
insert.add_value(table.r.query_index, transformer_end_info.r)
insert.add_value(table.rated_s.query_index, transformer_end_info.rated_s)
insert.add_value(table.rated_u.query_index, transformer_end_info.rated_u)
insert.add_value(table.short_term_s.query_index, transformer_end_info.short_term_s)
insert.add_value(table.transformer_tank_info_mrid.query_index, self._mrid_or_none(transformer_end_info.transformer_tank_info))
insert.add_value(table.energised_end_no_load_tests.query_index, self._mrid_or_none(transformer_end_info.energised_end_no_load_tests))
insert.add_value(table.energised_end_short_circuit_tests.query_index, self._mrid_or_none(transformer_end_info.energised_end_short_circuit_tests))
insert.add_value(table.grounded_end_short_circuit_tests.query_index, self._mrid_or_none(transformer_end_info.grounded_end_short_circuit_tests))
insert.add_value(table.open_end_open_circuit_tests.query_index, self._mrid_or_none(transformer_end_info.open_end_open_circuit_tests))
insert.add_value(table.energised_end_open_circuit_tests.query_index, self._mrid_or_none(transformer_end_info.energised_end_open_circuit_tests))
return self._save_asset_info(table, insert, transformer_end_info, "transformer end info")
def save_transformer_tank_info(self, transformer_tank_info: TransformerTankInfo) -> bool:
table = self.database_tables.get_table(TableTransformerTankInfo)
insert = self.database_tables.get_insert(TableTransformerTankInfo)
insert.add_value(table.power_transformer_info_mrid.query_index, self._mrid_or_none(transformer_tank_info.power_transformer_info))
return self._save_asset_info(table, insert, transformer_tank_info, "transformer tank info")
def _save_wire_info(self, table: TableWireInfo, insert: PreparedStatement, wire_info: WireInfo, description: str) -> bool:
insert.add_value(table.rated_current.query_index, wire_info.rated_current)
insert.add_value(table.material.query_index, wire_info.material.name)
return self._save_asset_info(table, insert, wire_info, description)
def _save_asset_info(self, table: TableAssetInfo, insert: PreparedStatement, asset_info: AssetInfo, description: str) -> bool:
return self.save_identified_object(table, insert, asset_info, description)
# ************ IEC61968 ASSETS ************
def _save_asset(self, table: TableAssets, insert: PreparedStatement, asset: Asset, description: str) -> bool:
status = True
insert.add_value(table.location_mrid.query_index, self._mrid_or_none(asset.location))
for e in asset.organisation_roles:
status = status and self._save_asset_organisation_role_to_asset_association(e, asset)
return status and self.save_identified_object(table, insert, asset, description)
def save_asset_container(self, table: TableAssetContainers, insert: PreparedStatement, asset_container: AssetContainer, description: str) -> bool:
return self._save_asset(table, insert, asset_container, description)
def save_asset_info(self, table: TableAssetInfo, insert: PreparedStatement, asset_info: AssetInfo, description: str) -> bool:
return self.save_identified_object(table, insert, asset_info, description)
def save_asset_organisation_role(self,
table: TableAssetOrganisationRoles,
insert: PreparedStatement,
asset_organisation_role: AssetOrganisationRole,
description: str
) -> bool:
return self.save_organisation_role(table, insert, asset_organisation_role, description)
def save_asset_owner(self, asset_owner: AssetOwner) -> bool:
table = self.database_tables.get_table(TableAssetOwners)
insert = self.database_tables.get_insert(TableAssetOwners)
return self.save_asset_organisation_role(table, insert, asset_owner, "asset owner")
def save_structure(self, table: TableStructures, insert: PreparedStatement, structure: Structure, description: str) -> bool:
return self.save_asset_container(table, insert, structure, description)
def save_pole(self, pole: Pole) -> bool:
table = self.database_tables.get_table(TablePoles)
insert = self.database_tables.get_insert(TablePoles)
insert.add_value(table.classification.query_index, pole.classification)
return self.save_structure(table, insert, pole, "pole")
def save_streetlight(self, streetlight: Streetlight) -> bool:
table = self.database_tables.get_table(TableStreetlights)
insert = self.database_tables.get_insert(TableStreetlights)
insert.add_value(table.pole_mrid.query_index, self._mrid_or_none(streetlight.pole))
insert.add_value(table.light_rating.query_index, streetlight.light_rating)
insert.add_value(table.lamp_kind.query_index, streetlight.lamp_kind.name)
return self._save_asset(table, insert, streetlight, "streetlight")
# ************ IEC61968 COMMON ************
@staticmethod
def insert_street_detail(table: TableStreetAddresses, insert: PreparedStatement, street_detail: StreetDetail):
insert.add_value(table.building_name.query_index, street_detail.building_name if street_detail else None)
insert.add_value(table.floor_identification.query_index, street_detail.floor_identification if street_detail else None)
insert.add_value(table.street_name.query_index, street_detail.name if street_detail else None)
insert.add_value(table.number.query_index, street_detail.number if street_detail else None)
insert.add_value(table.suite_number.query_index, street_detail.suite_number if street_detail else None)
insert.add_value(table.type.query_index, street_detail.type if street_detail else None)
insert.add_value(table.display_address.query_index, street_detail.display_address if street_detail else None)
@staticmethod
def insert_town_detail(table: TableTownDetails, insert: PreparedStatement, town_detail: TownDetail):
insert.add_value(table.town_name.query_index, town_detail.name if town_detail else None)
insert.add_value(table.state_or_province.query_index, town_detail.state_or_province if town_detail else None)
def save_location(self, location: Location) -> bool:
table = self.database_tables.get_table(TableLocations)
insert = self.database_tables.get_insert(TableLocations)
status = self.save_location_street_address(location, TableLocationStreetAddressField.mainAddress, location.main_address, "location main address")
for sequence_number, point in enumerate(location.points):
status = status and self.save_position_point(location, sequence_number, point)
return status and self.save_identified_object(table, insert, location, "location")
def save_location_street_address(self, location: Location, field: TableLocationStreetAddressField, street_address: StreetAddress, description: str) -> bool:
if street_address is None:
return True
table = self.database_tables.get_table(TableLocationStreetAddresses)
insert = self.database_tables.get_insert(TableLocationStreetAddresses)
insert.add_value(table.location_mrid.query_index, location.mrid)
insert.add_value(table.address_field.query_index, field.name)
return self.save_street_address(table, insert, street_address, "{}-{}".format(location.mrid, field), description)
def save_position_point(self, location: Location, sequence_number: int, position_point: PositionPoint) -> bool:
table = self.database_tables.get_table(TablePositionPoints)
insert = self.database_tables.get_insert(TablePositionPoints)
insert.add_value(table.location_mrid.query_index, location.mrid)
insert.add_value(table.sequence_number.query_index, sequence_number)
insert.add_value(table.x_position.query_index, position_point.x_position)
insert.add_value(table.y_position.query_index, position_point.y_position)
return self.try_execute_single_update(insert, "{}-point{}".format(location.mrid, sequence_number), "position point")
def save_street_address(self, table: TableStreetAddresses, insert: PreparedStatement, street_address: StreetAddress, street_id: str,
description: str) -> bool:
insert.add_value(table.postal_code.query_index, street_address.postal_code)
insert.add_value(table.po_box.query_index, street_address.po_box)
self.insert_street_detail(table, insert, street_address.street_detail)
self.insert_town_detail(table, insert, street_address.town_detail)
return self.try_execute_single_update(insert, street_id, description)
# ************ IEC61968 METERING ************
def save_end_device(self, table: TableEndDevices, insert: PreparedStatement, end_device: EndDevice, description: str) -> bool:
insert.add_value(table.customer_mrid.query_index, end_device.customer_mrid)
insert.add_value(table.service_location_mrid.query_index, self._mrid_or_none(end_device.service_location))
status = True
for e in end_device.usage_points:
status = status and self._save_usage_point_to_end_device_association(e, end_device)
return status and self.save_asset_container(table, insert, end_device, description)
def save_meter(self, meter: Meter) -> bool:
table = self.database_tables.get_table(TableMeters)
insert = self.database_tables.get_insert(TableMeters)
return self.save_end_device(table, insert, meter, "meter")
def save_usage_point(self, usage_point: UsagePoint) -> bool:
table = self.database_tables.get_table(TableUsagePoints)
insert = self.database_tables.get_insert(TableUsagePoints)
insert.add_value(table.location_mrid.query_index, self._mrid_or_none(usage_point.usage_point_location))
insert.add_value(table.is_virtual.query_index, int(usage_point.is_virtual))
insert.add_value(table.connection_category.query_index, usage_point.connection_category)
status = True
for e in usage_point.equipment:
status = status and self._save_equipment_to_usage_point_association(e, usage_point)
return status and self.save_identified_object(table, insert, usage_point, "usage point")
# ************ IEC61968 OPERATIONS ************
def save_operational_restriction(self, operational_restriction: OperationalRestriction) -> bool:
table = self.database_tables.get_table(TableOperationalRestrictions)
insert = self.database_tables.get_insert(TableOperationalRestrictions)
status = True
for e in operational_restriction.equipment:
status = status and self._save_equipment_to_operational_restriction_association(e, operational_restriction)
return status and self._save_document(table, insert, operational_restriction, "operational restriction")
# ************ IEC61970 AUXILIARY EQUIPMENT ************
def save_auxiliary_equipment(self, table: TableAuxiliaryEquipment, insert: PreparedStatement, auxiliary_equipment: AuxiliaryEquipment,
description: str) -> bool:
insert.add_value(table.terminal_mrid.query_index, self._mrid_or_none(auxiliary_equipment.terminal))
return self.save_equipment(table, insert, auxiliary_equipment, description)
def save_fault_indicator(self, fault_indicator: FaultIndicator) -> bool:
table = self.database_tables.get_table(TableFaultIndicators)
insert = self.database_tables.get_insert(TableFaultIndicators)
return self.save_auxiliary_equipment(table, insert, fault_indicator, "fault indicator")
# ************ IEC6190 CORE ************
def _save_ac_dc_terminal(self, table: TableAcDcTerminals, insert: PreparedStatement,
ac_dc_terminal: AcDcTerminal, description: str) -> bool:
return self.save_identified_object(table, insert, ac_dc_terminal, description)
def save_base_voltage(self, base_voltage: BaseVoltage) -> bool:
table = self.database_tables.get_table(TableBaseVoltages)
insert = self.database_tables.get_insert(TableBaseVoltages)
insert.add_value(table.nominal_voltage.query_index, base_voltage.nominal_voltage)
return self.save_identified_object(table, insert, base_voltage, "base voltage")
def _save_conducting_equipment(self, table: TableConductingEquipment, insert: PreparedStatement, conducting_equipment: ConductingEquipment,
description: str) -> bool:
insert.add_value(table.base_voltage_mrid.query_index, self._mrid_or_none(conducting_equipment.base_voltage))
return self.save_equipment(table, insert, conducting_equipment, description)
def save_connectivity_node(self, connectivity_node: ConnectivityNode) -> bool:
table = self.database_tables.get_table(TableConnectivityNodes)
insert = self.database_tables.get_insert(TableConnectivityNodes)
return self.save_identified_object(table, insert, connectivity_node, "connectivity node")
def _save_connectivity_node_container(self, table: TableConnectivityNodeContainers, insert: PreparedStatement,
connectivity_node_container: ConnectivityNodeContainer, description: str) -> bool:
return self._save_power_system_resource(table, insert, connectivity_node_container, description)
def save_equipment(self, table: TableEquipment, insert: PreparedStatement, equipment: Equipment, description: str) -> bool:
insert.add_value(table.normally_in_service.query_index, int(equipment.normally_in_service))
insert.add_value(table.in_service.query_index, int(equipment.in_service))
status = True
for e in equipment.containers:
if not isinstance(e, Feeder):
status = status and self._save_equipment_to_equipment_container_association(equipment, e)
return status and self._save_power_system_resource(table, insert, equipment, description)
def _save_equipment_container(self, table: TableEquipmentContainers,
insert: PreparedStatement,
equipment_container: EquipmentContainer,
description: str) -> bool:
return self._save_connectivity_node_container(table, insert, equipment_container, description)
def save_feeder(self, feeder: Feeder):
table = self.database_tables.get_table(TableFeeders)
insert = self.database_tables.get_insert(TableFeeders)
insert.add_value(table.normal_head_terminal_mrid.query_index, self._mrid_or_none(feeder.normal_head_terminal))
insert.add_value(table.normal_energizing_substation_mrid.query_index, self._mrid_or_none(feeder.normal_energizing_substation))
return self._save_equipment_container(table, insert, feeder, "feeder")
def save_geographical_region(self, geographical_region: GeographicalRegion) -> bool:
table = self.database_tables.get_table(TableGeographicalRegions)
insert = self.database_tables.get_insert(TableGeographicalRegions)
return self.save_identified_object(table, insert, geographical_region, "geographical region")
def _save_power_system_resource(self,
table: TablePowerSystemResources,
insert: PreparedStatement,
power_system_resource: PowerSystemResource,
description: str) -> bool:
insert.add_value(table.location_mrid.query_index, self._mrid_or_none(power_system_resource.location))
insert.add_value(table.num_controls.query_index, 0) # Currently unused
return self.save_identified_object(table, insert, power_system_resource, description)
def save_site(self, site: Site) -> bool:
table = self.database_tables.get_table(TableSites)
insert = self.database_tables.get_insert(TableSites)
return self._save_equipment_container(table, insert, site, "site")
def save_sub_geographical_region(self, sub_geographical_region: SubGeographicalRegion) -> bool:
table = self.database_tables.get_table(TableSubGeographicalRegions)
insert = self.database_tables.get_insert(TableSubGeographicalRegions)
insert.add_value(table.geographical_region_mrid.query_index, self._mrid_or_none(sub_geographical_region.geographical_region))
return self.save_identified_object(table, insert, sub_geographical_region, "sub-geographical region")
def save_substation(self, substation: Substation) -> bool:
table = self.database_tables.get_table(TableSubstations)
insert = self.database_tables.get_insert(TableSubstations)
insert.add_value(table.sub_geographical_region_mrid.query_index, self._mrid_or_none(substation.sub_geographical_region))
return self._save_equipment_container(table, insert, substation, "substation")
def save_terminal(self, terminal: Terminal) -> bool:
table = self.database_tables.get_table(TableTerminals)
insert = self.database_tables.get_insert(TableTerminals)
insert.add_value(table.conducting_equipment_mrid.query_index, self._mrid_or_none(terminal.conducting_equipment))
insert.add_value(table.sequence_number.query_index, terminal.sequence_number)
insert.add_value(table.connectivity_node_mrid.query_index, self._mrid_or_none(terminal.connectivity_node))
insert.add_value(table.phases.query_index, terminal.phases.short_name)
return self._save_ac_dc_terminal(table, insert, terminal, "terminal")
# ************ IEC61970 WIRES ************
def save_equivalent_branch(self, equivalent_branch: EquivalentBranch) -> bool:
table = self.database_tables.get_table(TableEquivalentBranches)
insert = self.database_tables.get_insert(TableEquivalentBranches)
insert.add_value(table.negative_r12.query_index, equivalent_branch.negative_r12)
insert.add_value(table.negative_r21.query_index, equivalent_branch.negative_r21)
insert.add_value(table.negative_x12.query_index, equivalent_branch.negative_x12)
insert.add_value(table.negative_x21.query_index, equivalent_branch.negative_x21)
insert.add_value(table.positive_r12.query_index, equivalent_branch.positive_r12)
insert.add_value(table.positive_r21.query_index, equivalent_branch.positive_r21)
insert.add_value(table.positive_x12.query_index, equivalent_branch.positive_x12)
insert.add_value(table.positive_x21.query_index, equivalent_branch.positive_x21)
insert.add_value(table.r.query_index, equivalent_branch.r)
insert.add_value(table.r21.query_index, equivalent_branch.r21)
insert.add_value(table.x.query_index, equivalent_branch.x)
insert.add_value(table.x21.query_index, equivalent_branch.x21)
insert.add_value(table.zero_r12.query_index, equivalent_branch.zero_r12)
insert.add_value(table.zero_r21.query_index, equivalent_branch.zero_r21)
insert.add_value(table.zero_x12.query_index, equivalent_branch.zero_x12)
insert.add_value(table.zero_x21.query_index, equivalent_branch.zero_x21)
return self._save_equivalent_equipment(table, insert, equivalent_branch, "equivalent branch")
def _save_equivalent_equipment(self, table: TableEquivalentEquipment, insert: PreparedStatement, equivalent_equipment: EquivalentEquipment,
description: str) -> bool:
return self._save_conducting_equipment(table, insert, equivalent_equipment, description)
def save_power_electronics_unit(self, table: TablePowerElectronicsUnit, insert: PreparedStatement, power_electronics_unit: PowerElectronicsUnit,
description: str) -> bool:
insert.add_value(table.power_electronics_connection_mrid.query_index, self._mrid_or_none(power_electronics_unit.power_electronics_connection))
insert.add_value(table.max_p.query_index, power_electronics_unit.max_p)
insert.add_value(table.min_p.query_index, power_electronics_unit.min_p)
return self.save_equipment(table, insert, power_electronics_unit, description)
def save_battery_unit(self, battery_unit: BatteryUnit) -> bool:
table = self.database_tables.get_table(TableBatteryUnit)
insert = self.database_tables.get_insert(TableBatteryUnit)
insert.add_value(table.battery_state.query_index, battery_unit.battery_state.short_name)
insert.add_value(table.rated_e.query_index, battery_unit.rated_e)
insert.add_value(table.stored_e.query_index, battery_unit.stored_e)
return self.save_power_electronics_unit(table, insert, battery_unit, "battery unit")
def save_photovoltaic_unit(self, photovoltaic_unit: PhotoVoltaicUnit) -> bool:
table = self.database_tables.get_table(TablePhotoVoltaicUnit)
insert = self.database_tables.get_insert(TablePhotoVoltaicUnit)
return self.save_power_electronics_unit(table, insert, photovoltaic_unit, "photo voltaic unit")
def save_power_electronics_wind_unit(self, power_electronics_wind_unit: PowerElectronicsWindUnit) -> bool:
table = self.database_tables.get_table(TablePowerElectronicsWindUnit)
insert = self.database_tables.get_insert(TablePowerElectronicsWindUnit)
return self.save_power_electronics_unit(table, insert, power_electronics_wind_unit, "power electronics wind unit")
def save_ac_line_segment(self, ac_line_segment: AcLineSegment) -> bool:
table = self.database_tables.get_table(TableAcLineSegments)
insert = self.database_tables.get_insert(TableAcLineSegments)
insert.add_value(table.per_length_sequence_impedance_mrid.query_index, self._mrid_or_none(ac_line_segment.per_length_sequence_impedance))
return self._save_conductor(table, insert, ac_line_segment, "AC line segment")
def save_breaker(self, breaker: Breaker) -> bool:
table = self.database_tables.get_table(TableBreakers)
insert = self.database_tables.get_insert(TableBreakers)
return self._save_protected_switch(table, insert, breaker, "breaker")
def save_load_break_switch(self, load_break_switch: LoadBreakSwitch) -> bool:
table = self.database_tables.get_table(TableLoadBreakSwitches)
insert = self.database_tables.get_insert(TableLoadBreakSwitches)
return self._save_protected_switch(table, insert, load_break_switch, "load break switch")
def save_bus_bar_section(self, bus_bar_section: BusbarSection) -> bool:
table = self.database_tables.get_table(TableBusbarSections)
insert = self.database_tables.get_insert(TableBusbarSections)
return self._save_connector(table, insert, bus_bar_section, "busbar section")
def _save_conductor(self, table: TableConductors,
insert: PreparedStatement,
conductor: Conductor,
description: str) -> bool:
insert.add_value(table.length.query_index, conductor.length)
insert.add_value(table.wire_info_mrid.query_index, self._mrid_or_none(conductor.asset_info))
return self._save_conducting_equipment(table, insert, conductor, description)
def _save_connector(self, table: TableConnectors,
insert: PreparedStatement, connector: Connector, description: str) -> bool: \
return self._save_conducting_equipment(table, insert, connector, description)
def save_disconnector(self, disconnector: Disconnector) -> bool:
table = self.database_tables.get_table(TableDisconnectors)
insert = self.database_tables.get_insert(TableDisconnectors)
return self._save_switch(table, insert, disconnector, "disconnector")
def _save_energy_connection(self, table: TableEnergyConnections, insert: PreparedStatement, energy_connection: EnergyConnection, description: str) -> bool:
return self._save_conducting_equipment(table, insert, energy_connection, description)
def save_energy_consumer(self, energy_consumer: EnergyConsumer) -> bool:
table = self.database_tables.get_table(TableEnergyConsumers)
insert = self.database_tables.get_insert(TableEnergyConsumers)
insert.add_value(table.customer_count.query_index, energy_consumer.customer_count)
insert.add_value(table.grounded.query_index, energy_consumer.grounded)
insert.add_value(table.p.query_index, energy_consumer.p)
insert.add_value(table.q.query_index, energy_consumer.q)
insert.add_value(table.p_fixed.query_index, energy_consumer.p_fixed)
insert.add_value(table.q_fixed.query_index, energy_consumer.q_fixed)
insert.add_value(table.phase_connection.query_index, energy_consumer.phase_connection.short_name)
return self._save_energy_connection(table, insert, energy_consumer, "energy consumer")
def save_energy_consumer_phase(self, energy_consumer_phase: EnergyConsumerPhase) -> bool:
table = self.database_tables.get_table(TableEnergyConsumerPhases)
insert = self.database_tables.get_insert(TableEnergyConsumerPhases)
insert.add_value(table.energy_consumer_mrid.query_index, self._mrid_or_none(energy_consumer_phase.energy_consumer))
insert.add_value(table.phase.query_index, energy_consumer_phase.phase.short_name)
insert.add_value(table.p.query_index, energy_consumer_phase.p)
insert.add_value(table.q.query_index, energy_consumer_phase.q)
insert.add_value(table.p_fixed.query_index, energy_consumer_phase.p_fixed)
insert.add_value(table.q_fixed.query_index, energy_consumer_phase.q_fixed)
return self._save_power_system_resource(table, insert, energy_consumer_phase, "energy consumer phase")
def save_energy_source(self, energy_source: EnergySource) -> bool:
table = self.database_tables.get_table(TableEnergySources)
insert = self.database_tables.get_insert(TableEnergySources)
insert.add_value(table.active_power.query_index, energy_source.active_power)
insert.add_value(table.reactive_power.query_index, energy_source.reactive_power)
insert.add_value(table.voltage_angle.query_index, energy_source.voltage_angle)
insert.add_value(table.voltage_magnitude.query_index, energy_source.voltage_magnitude)
insert.add_value(table.p_max.query_index, energy_source.p_max)
insert.add_value(table.p_min.query_index, energy_source.p_min)
insert.add_value(table.r.query_index, energy_source.r)
insert.add_value(table.r0.query_index, energy_source.r0)
insert.add_value(table.rn.query_index, energy_source.rn)
insert.add_value(table.x.query_index, energy_source.x)
insert.add_value(table.x0.query_index, energy_source.x0)
insert.add_value(table.xn.query_index, energy_source.xn)
insert.add_value(table.is_external_grid.query_index, energy_source.is_external_grid)
insert.add_value(table.r_min.query_index, energy_source.r_min)
insert.add_value(table.rn_min.query_index, energy_source.rn_min)
insert.add_value(table.r0_min.query_index, energy_source.r0_min)
insert.add_value(table.x_min.query_index, energy_source.x_min)
insert.add_value(table.xn_min.query_index, energy_source.xn_min)
insert.add_value(table.x0_min.query_index, energy_source.x0_min)
insert.add_value(table.r_max.query_index, energy_source.r_max)
insert.add_value(table.rn_max.query_index, energy_source.rn_max)
insert.add_value(table.r0_max.query_index, energy_source.r0_max)
insert.add_value(table.x_max.query_index, energy_source.x_max)
insert.add_value(table.xn_max.query_index, energy_source.xn_max)
insert.add_value(table.x0_max.query_index, energy_source.x0_max)
return self._save_energy_connection(table, insert, energy_source, "energy source")
def save_energy_source_phase(self, energy_source_phase: EnergySourcePhase) -> bool:
table = self.database_tables.get_table(TableEnergySourcePhases)
insert = self.database_tables.get_insert(TableEnergySourcePhases)
insert.add_value(table.energy_source_mrid.query_index, self._mrid_or_none(energy_source_phase.energy_source))
insert.add_value(table.phase.query_index, energy_source_phase.phase.short_name)
return self._save_power_system_resource(table, insert, energy_source_phase, "energy source phase")
def save_fuse(self, fuse: Fuse) -> bool:
table = self.database_tables.get_table(TableFuses)
insert = self.database_tables.get_insert(TableFuses)
return self._save_switch(table, insert, fuse, "fuse")
def save_jumper(self, jumper: Jumper) -> bool:
table = self.database_tables.get_table(TableJumpers)
insert = self.database_tables.get_insert(TableJumpers)
return self._save_switch(table, insert, jumper, "jumper")
def save_junction(self, junction: Junction) -> bool:
table = self.database_tables.get_table(TableJunctions)
insert = self.database_tables.get_insert(TableJunctions)
return self._save_connector(table, insert, junction, "junction")
def _save_line(self, table: TableLines, insert: PreparedStatement, line: Line, description: str) -> bool:
return self._save_equipment_container(table, insert, line, description)
def save_linear_shunt_compensator(self, linear_shunt_compensator: LinearShuntCompensator) -> bool:
table = self.database_tables.get_table(TableLinearShuntCompensators)
insert = self.database_tables.get_insert(TableLinearShuntCompensators)
insert.add_value(table.b0_per_section.query_index, linear_shunt_compensator.b0_per_section)
insert.add_value(table.b_per_section.query_index, linear_shunt_compensator.b_per_section)
insert.add_value(table.g0_per_section.query_index, linear_shunt_compensator.g0_per_section)
insert.add_value(table.g_per_section.query_index, linear_shunt_compensator.g_per_section)
return self._save_shunt_compensator(table, insert, linear_shunt_compensator, "linear shunt compensator")
def _save_per_length_impedance(self, table: TablePerLengthImpedances,
insert: PreparedStatement,
per_length_sequence_impedance: PerLengthImpedance, description: str) -> bool:
return self._save_per_length_line_parameter(table, insert, per_length_sequence_impedance, description)
def _save_per_length_line_parameter(self, table: TablePerLengthLineParameters,
insert: PreparedStatement,
per_length_line_parameter: PerLengthLineParameter,
description: str) -> bool:
return self.save_identified_object(table, insert, per_length_line_parameter, description)
def save_per_length_sequence_impedance(self, per_length_sequence_impedance: PerLengthSequenceImpedance) -> bool:
table = self.database_tables.get_table(TablePerLengthSequenceImpedances)
insert = self.database_tables.get_insert(TablePerLengthSequenceImpedances)
insert.add_value(table.r.query_index, per_length_sequence_impedance.r)
insert.add_value(table.x.query_index, per_length_sequence_impedance.x)
insert.add_value(table.r0.query_index, per_length_sequence_impedance.r0)
insert.add_value(table.x0.query_index, per_length_sequence_impedance.x0)
insert.add_value(table.bch.query_index, per_length_sequence_impedance.bch)
insert.add_value(table.gch.query_index, per_length_sequence_impedance.gch)
insert.add_value(table.b0ch.query_index, per_length_sequence_impedance.b0ch)
insert.add_value(table.g0ch.query_index, per_length_sequence_impedance.g0ch)
return self._save_per_length_impedance(table, insert, per_length_sequence_impedance, "per length sequence impedance")
def save_power_electronics_connection(self, power_electronics_connection: PowerElectronicsConnection) -> bool:
table = self.database_tables.get_table(TablePowerElectronicsConnection)
insert = self.database_tables.get_insert(TablePowerElectronicsConnection)
insert.add_value(table.max_i_fault.query_index, power_electronics_connection.max_i_fault)
insert.add_value(table.max_q.query_index, power_electronics_connection.max_q)
insert.add_value(table.min_q.query_index, power_electronics_connection.min_q)
insert.add_value(table.p.query_index, power_electronics_connection.p)
insert.add_value(table.q.query_index, power_electronics_connection.q)
insert.add_value(table.rated_s.query_index, power_electronics_connection.rated_s)
insert.add_value(table.rated_u.query_index, power_electronics_connection.rated_u)
return self._save_regulating_cond_eq(table, insert, power_electronics_connection, "power electronics connection")
def save_power_electronics_connection_phase(self, power_electronics_connection_phase: PowerElectronicsConnectionPhase) -> bool:
table = self.database_tables.get_table(TablePowerElectronicsConnectionPhases)
insert = self.database_tables.get_insert(TablePowerElectronicsConnectionPhases)
insert.add_value(table.power_electronics_connection_mrid.query_index,
self._mrid_or_none(power_electronics_connection_phase.power_electronics_connection))
insert.add_value(table.p.query_index, power_electronics_connection_phase.p)
insert.add_value(table.phase.query_index, power_electronics_connection_phase.phase.short_name)
insert.add_value(table.q.query_index, power_electronics_connection_phase.q)
return self._save_power_system_resource(table, insert, power_electronics_connection_phase,
"power electronics connection phase")
def save_power_transformer(self, power_transformer: PowerTransformer) -> bool:
table = self.database_tables.get_table(TablePowerTransformers)
insert = self.database_tables.get_insert(TablePowerTransformers)
insert.add_value(table.vector_group.query_index, power_transformer.vector_group.short_name)
insert.add_value(table.transformer_utilisation.query_index, power_transformer.transformer_utilisation)
insert.add_value(table.construction_kind.query_index, power_transformer.construction_kind.short_name)
insert.add_value(table.function.query_index, power_transformer.function.short_name)
insert.add_value(table.power_transformer_info_mrid.query_index, self._mrid_or_none(power_transformer.asset_info))
return self._save_conducting_equipment(table, insert, power_transformer, "power transformer")
def save_power_transformer_end(self, power_transformer_end: PowerTransformerEnd) -> bool:
table = self.database_tables.get_table(TablePowerTransformerEnds)
insert = self.database_tables.get_insert(TablePowerTransformerEnds)
insert.add_value(table.power_transformer_mrid.query_index, self._mrid_or_none(power_transformer_end.power_transformer))
insert.add_value(table.connection_kind.query_index, power_transformer_end.connection_kind.short_name)
insert.add_value(table.phase_angle_clock.query_index, power_transformer_end.phase_angle_clock)
insert.add_value(table.b.query_index, power_transformer_end.b)
insert.add_value(table.b0.query_index, power_transformer_end.b0)
insert.add_value(table.g.query_index, power_transformer_end.g)
insert.add_value(table.g0.query_index, power_transformer_end.g0)
insert.add_value(table.r.query_index, power_transformer_end.r)
insert.add_value(table.r0.query_index, power_transformer_end.r0)
insert.add_value(table.rated_s.query_index, power_transformer_end.rated_s)
insert.add_value(table.rated_u.query_index, power_transformer_end.rated_u)
insert.add_value(table.x.query_index, power_transformer_end.x)
insert.add_value(table.x0.query_index, power_transformer_end.x0)
return self._save_transformer_end(table, insert, power_transformer_end, "power transformer end")
def _save_protected_switch(self, table: TableProtectedSwitches, insert: PreparedStatement, protected_switch: ProtectedSwitch, description: str) -> bool:
return self._save_switch(table, insert, protected_switch, description)
def save_ratio_tap_changer(self, ratio_tap_changer: RatioTapChanger) -> bool:
table = self.database_tables.get_table(TableRatioTapChangers)
insert = self.database_tables.get_insert(TableRatioTapChangers)
insert.add_value(table.transformer_end_mrid.query_index, self._mrid_or_none(ratio_tap_changer.transformer_end))
insert.add_value(table.step_voltage_increment.query_index, ratio_tap_changer.step_voltage_increment)
return self._save_tap_changer(table, insert, ratio_tap_changer, "ratio tap changer")
def save_recloser(self, recloser: Recloser) -> bool:
table = self.database_tables.get_table(TableReclosers)
insert = self.database_tables.get_insert(TableReclosers)
return self._save_protected_switch(table, insert, recloser, "recloser")
def _save_regulating_cond_eq(self, table: TableRegulatingCondEq, insert: PreparedStatement, regulating_cond_eq: RegulatingCondEq, description: str) -> bool:
insert.add_value(table.control_enabled.query_index, regulating_cond_eq.control_enabled)
return self._save_energy_connection(table, insert, regulating_cond_eq, description)
def _save_shunt_compensator(self, table: TableShuntCompensators, insert: PreparedStatement, shunt_compensator: ShuntCompensator, description: str) -> bool:
insert.add_value(table.shunt_compensator_info_mrid.query_index, self._mrid_or_none(shunt_compensator.shunt_compensator_info))
insert.add_value(table.grounded.query_index, shunt_compensator.grounded)
insert.add_value(table.nom_u.query_index, shunt_compensator.nom_u)
insert.add_value(table.phase_connection.query_index, shunt_compensator.phase_connection.short_name)
insert.add_value(table.sections.query_index, shunt_compensator.sections)
return self._save_regulating_cond_eq(table, insert, shunt_compensator, description)
def _save_switch(self, table: TableSwitches,
insert: PreparedStatement, switch: Switch, description: str) -> bool:
insert.add_value(table.normal_open.query_index, int(switch.is_normally_open()))
insert.add_value(table.open.query_index, int(switch.is_open()))
return self._save_conducting_equipment(table, insert, switch, description)
def _save_tap_changer(self, table: TableTapChangers, insert: PreparedStatement, tap_changer: TapChanger, description: str) -> bool:
insert.add_value(table.control_enabled.query_index, tap_changer.control_enabled)
insert.add_value(table.high_step.query_index, tap_changer.high_step)
insert.add_value(table.low_step.query_index, tap_changer.low_step)
insert.add_value(table.neutral_step.query_index, tap_changer.neutral_step)
insert.add_value(table.neutral_u.query_index, tap_changer.neutral_u)
insert.add_value(table.normal_step.query_index, tap_changer.normal_step)
insert.add_value(table.step.query_index, tap_changer.step)
return self._save_power_system_resource(table, insert, tap_changer, description)
def _save_transformer_end(self, table: TableTransformerEnds, insert: PreparedStatement, transformer_end: TransformerEnd, description: str) -> bool:
insert.add_value(table.end_number.query_index, transformer_end.end_number)
insert.add_value(table.terminal_mrid.query_index, self._mrid_or_none(transformer_end.terminal))
insert.add_value(table.base_voltage_mrid.query_index, self._mrid_or_none(transformer_end.base_voltage))
insert.add_value(table.grounded.query_index, transformer_end.grounded)
insert.add_value(table.r_ground.query_index, transformer_end.r_ground)
insert.add_value(table.x_ground.query_index, transformer_end.x_ground)
insert.add_value(table.star_impedance_mrid.query_index, self._mrid_or_none(transformer_end.star_impedance))
return self.save_identified_object(table, insert, transformer_end, description)
def save_transformer_star_impedance(self, transformer_star_impedance: TransformerStarImpedance) -> bool:
table = self.database_tables.get_table(TableTransformerStarImpedance)
insert = self.database_tables.get_insert(TableTransformerStarImpedance)
insert.add_value(table.r.query_index, transformer_star_impedance.r)
insert.add_value(table.r0.query_index, transformer_star_impedance.r0)
insert.add_value(table.x.query_index, transformer_star_impedance.x)
insert.add_value(table.x0.query_index, transformer_star_impedance.x0)
insert.add_value(table.transformer_end_info_mrid.query_index, self._mrid_or_none(transformer_star_impedance.transformer_end_info))
return self.save_identified_object(table, insert, transformer_star_impedance, "transformer star impedance")
# ************ IEC61970 InfIEC61970 ************
def save_circuit(self, circuit: Circuit) -> bool:
table = self.database_tables.get_table(TableCircuits)
insert = self.database_tables.get_insert(TableCircuits)
insert.add_value(table.loop_mrid.query_index, self._mrid_or_none(circuit.loop))
status = True
for sub in circuit.end_substations:
status = status and self._save_circuit_to_substation_association(circuit, sub)
for t in circuit.end_terminals:
status = status and self._save_circuit_to_terminal_association(circuit, t)
return status and self._save_line(table, insert, circuit, "circuit")
def save_loop(self, loop: Loop) -> bool:
table = self.database_tables.get_table(TableLoops)
insert = self.database_tables.get_insert(TableLoops)
status = True
for sub in loop.energizing_substations:
status = status and self._save_loop_to_substation_association(loop, sub, LoopSubstationRelationship.SUBSTATION_ENERGIZES_LOOP)
for sub in loop.substations:
status = status and self._save_loop_to_substation_association(loop, sub, LoopSubstationRelationship.LOOP_ENERGIZES_SUBSTATION)
return status and self.save_identified_object(table, insert, loop, "loop")
# ************ IEC61970 MEAS ************
def save_measurement(self, table: TableMeasurements, insert: PreparedStatement, measurement: Measurement, description: str) -> bool:
insert.add_value(table.power_system_resource_mrid.query_index, measurement.power_system_resource_mrid)
insert.add_value(table.remote_source_mrid.query_index, self._mrid_or_none(measurement.remote_source))
insert.add_value(table.terminal_mrid.query_index, measurement.terminal_mrid)
insert.add_value(table.phases.query_index, measurement.phases.short_name)
insert.add_value(table.unit_symbol.query_index, measurement.unit_symbol.short_name)
return self.save_identified_object(table, insert, measurement, description)
def save_analog(self, analog: Analog) -> bool:
table = self.database_tables.get_table(TableAnalogs)
insert = self.database_tables.get_insert(TableAnalogs)
insert.add_value(table.positive_flow_in.query_index, analog.positive_flow_in)
return self.save_measurement(table, insert, analog, "analog")
def save_accumulator(self, accumulator: Accumulator) -> bool:
table = self.database_tables.get_table(TableAccumulators)
insert = self.database_tables.get_insert(TableAccumulators)
return self.save_measurement(table, insert, accumulator, "accumulator")
def save_discrete(self, discrete: Discrete) -> bool:
table = self.database_tables.get_table(TableDiscretes)
insert = self.database_tables.get_insert(TableDiscretes)
return self.save_measurement(table, insert, discrete, "discrete")
def save_control(self, control: Control) -> bool:
table = self.database_tables.get_table(TableControls)
insert = self.database_tables.get_insert(TableControls)
insert.add_value(table.power_system_resource_mrid.query_index, control.power_system_resource_mrid)
return self.save_io_point(table, insert, control, "control")
def save_io_point(self, table: TableIoPoints, insert: PreparedStatement, io_point: IoPoint, description: str) -> bool:
return self.save_identified_object(table, insert, io_point, description)
# ************ IEC61970 SCADA ************
def save_remote_control(self, remote_control: RemoteControl) -> bool:
table = self.database_tables.get_table(TableRemoteControls)
insert = self.database_tables.get_insert(TableRemoteControls)
insert.add_value(table.control_mrid.query_index, self._mrid_or_none(remote_control.control))
return self.save_remote_point(table, insert, remote_control, "remote control")
def save_remote_point(self, table: TableRemotePoints, insert: PreparedStatement, remote_point: RemotePoint, description: str) -> bool:
return self.save_identified_object(table, insert, remote_point, description)
def save_remote_source(self, remote_source: RemoteSource) -> bool:
table = self.database_tables.get_table(TableRemoteSources)
insert = self.database_tables.get_insert(TableRemoteSources)
insert.add_value(table.measurement_mrid.query_index, self._mrid_or_none(remote_source.measurement))
return self.save_remote_point(table, insert, remote_source, "remote source")
# ************ ASSOCIATIONS ************
def _save_asset_organisation_role_to_asset_association(self, asset_organisation_role: AssetOrganisationRole, asset: Asset) -> bool:
table = self.database_tables.get_table(TableAssetOrganisationRolesAssets)
insert = self.database_tables.get_insert(TableAssetOrganisationRolesAssets)
insert.add_value(table.asset_organisation_role_mrid.query_index, asset_organisation_role.mrid)
insert.add_value(table.asset_mrid.query_index, asset.mrid)
return self.try_execute_single_update(insert, f"{asset_organisation_role.mrid}-to-{asset.mrid}", "asset organisation role to asset association")
def _save_usage_point_to_end_device_association(self, usage_point: UsagePoint, end_device: EndDevice) -> bool:
table = self.database_tables.get_table(TableUsagePointsEndDevices)
insert = self.database_tables.get_insert(TableUsagePointsEndDevices)
insert.add_value(table.usage_point_mrid.query_index, usage_point.mrid)
insert.add_value(table.end_device_mrid.query_index, end_device.mrid)
return self.try_execute_single_update(insert, f"{usage_point.mrid}-to-{end_device.mrid}", "usage point to end device association")
def _save_equipment_to_usage_point_association(self, equipment: Equipment, usage_point: UsagePoint) -> bool:
table = self.database_tables.get_table(TableEquipmentUsagePoints)
insert = self.database_tables.get_insert(TableEquipmentUsagePoints)
insert.add_value(table.equipment_mrid.query_index, equipment.mrid)
insert.add_value(table.usage_point_mrid.query_index, usage_point.mrid)
return self.try_execute_single_update(insert, f"{equipment.mrid}-to-{usage_point.mrid}", "Equipment to UsagePoint association ")
def _save_equipment_to_operational_restriction_association(self, equipment: Equipment, operational_restriction: OperationalRestriction) -> bool:
table = self.database_tables.get_table(TableEquipmentOperationalRestrictions)
insert = self.database_tables.get_insert(TableEquipmentOperationalRestrictions)
insert.add_value(table.equipment_mrid.query_index, equipment.mrid)
insert.add_value(table.operational_restriction_mrid.query_index, operational_restriction.mrid)
return self.try_execute_single_update(insert, f"{equipment.mrid}-to-{operational_restriction.mrid}", "equipment to operational restriction association")
def _save_equipment_to_equipment_container_association(self, equipment: Equipment, equipment_container: EquipmentContainer) -> bool:
table = self.database_tables.get_table(TableEquipmentEquipmentContainers)
insert = self.database_tables.get_insert(TableEquipmentEquipmentContainers)
insert.add_value(table.equipment_mrid.query_index, equipment.mrid)
insert.add_value(table.equipment_container_mrid.query_index, equipment_container.mrid)
return self.try_execute_single_update(insert, f"{equipment.mrid}-to-{equipment_container.mrid}", "equipment to equipment container association")
def _save_circuit_to_substation_association(self, circuit: Circuit, substation: Substation) -> bool:
table = self.database_tables.get_table(TableCircuitsSubstations)
insert = self.database_tables.get_insert(TableCircuitsSubstations)
insert.add_value(table.circuit_mrid.query_index, circuit.mrid)
insert.add_value(table.substation_mrid.query_index, substation.mrid)
return self.try_execute_single_update(insert, f"{circuit.mrid}-to-{substation.mrid}", "circuit to substation association")
def _save_circuit_to_terminal_association(self, circuit: Circuit, terminal: Terminal) -> bool:
table = self.database_tables.get_table(TableCircuitsTerminals)
insert = self.database_tables.get_insert(TableCircuitsTerminals)
insert.add_value(table.circuit_mrid.query_index, circuit.mrid)
insert.add_value(table.terminal_mrid.query_index, terminal.mrid)
return self.try_execute_single_update(insert, f"{circuit.mrid}-to-{terminal.mrid}", "circuit to terminal association")
def _save_loop_to_substation_association(self, loop: Loop, substation: Substation, relationship: LoopSubstationRelationship) -> bool:
table = self.database_tables.get_table(TableLoopsSubstations)
insert = self.database_tables.get_insert(TableLoopsSubstations)
insert.add_value(table.loop_mrid.query_index, loop.mrid)
insert.add_value(table.substation_mrid.query_index, substation.mrid)
insert.add_value(table.relationship.query_index, relationship.short_name)
return self.try_execute_single_update(insert, f"{loop.mrid}-to-{substation.mrid}", f"loop to substation association") | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/writers/network_cim_writer.py | network_cim_writer.py |
from __future__ import annotations
import logging
from sqlite3 import Cursor
from typing import Set, Optional
from dataclassy import dataclass
from zepben.evolve import NameType, Name
from zepben.evolve.database.sqlite.tables.database_tables import DatabaseTables, PreparedStatement
from zepben.evolve.database.sqlite.tables.iec61968.common_tables import TableDocuments, TableOrganisations, TableOrganisationRoles
from zepben.evolve.database.sqlite.tables.iec61970.base.core_tables import TableIdentifiedObjects, TableNameTypes, TableNames
from zepben.evolve.database.sqlite.writers.utils import try_execute_single_update
from zepben.evolve.model.cim.iec61968.common.document import Document
from zepben.evolve.model.cim.iec61968.common.organisation import Organisation
from zepben.evolve.model.cim.iec61968.common.organisation_role import OrganisationRole
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
logger = logging.getLogger(__name__)
__all__ = ["BaseCIMWriter"]
@dataclass(slots=True)
class BaseCIMWriter(object):
"""
Helper methods for building insert statements. Note all fields need to be populated.
"""
database_tables: DatabaseTables
cursor: Cursor
_failed_ids: Set[str] = set()
def _save_document(self, table: TableDocuments, insert: PreparedStatement, document: Document, description: str) -> bool:
insert.add_value(table.title.query_index, document.title)
# TODO: JVM seems to use Z as TZ offset (for UTC+0?) while python uses +HH:mm format. Need to investigate here
insert.add_value(table.created_date_time.query_index, f"{document.created_date_time.isoformat()}Z" if document.created_date_time else None)
insert.add_value(table.author_name.query_index, document.author_name)
insert.add_value(table.type.query_index, document.type)
insert.add_value(table.status.query_index, document.status)
insert.add_value(table.comment.query_index, document.comment)
return self.save_identified_object(table, insert, document, description)
def save_organisation(self, organisation: Organisation) -> bool:
table = self.database_tables.get_table(TableOrganisations)
insert = self.database_tables.get_insert(TableOrganisations)
return self.save_identified_object(table, insert, organisation, "Organisation")
def save_name_type(self, name_type: NameType) -> bool:
table = self.database_tables.get_table(TableNameTypes)
insert = self.database_tables.get_insert(TableNameTypes)
insert.add_value(table.name_.query_index, name_type.name)
insert.add_value(table.description.query_index, name_type.description)
return self.try_execute_single_update(insert, name_type.name, "name type")
def save_name(self, name: Name) -> bool:
table = self.database_tables.get_table(TableNames)
insert = self.database_tables.get_insert(TableNames)
insert.add_value(table.name_.query_index, name.name)
insert.add_value(table.name_type_name.query_index, name.type.name)
insert.add_value(table.identified_object_mrid.query_index, name.identified_object.mrid)
return self.try_execute_single_update(insert, name.name, "name")
def save_organisation_role(self, table: TableOrganisationRoles, insert: PreparedStatement, organisation_role: OrganisationRole, description: str) -> bool:
insert.add_value(table.organisation_mrid.query_index, self._mrid_or_none(organisation_role.organisation))
return self.save_identified_object(table, insert, organisation_role, description)
def save_identified_object(self, table: TableIdentifiedObjects, insert: PreparedStatement, identified_object: IdentifiedObject, description: str) -> bool:
insert.add_value(table.mrid.query_index, identified_object.mrid)
insert.add_value(table.name_.query_index, identified_object.name)
insert.add_value(table.description.query_index, identified_object.description)
insert.add_value(table.num_diagram_objects.query_index, 0) # Currently unused
return self.try_execute_single_update(insert, identified_object.mrid, description)
def try_execute_single_update(self, query: PreparedStatement, mrid: str, description: str) -> bool:
"""
Execute an update on the database with the given `query`.
Failures will be logged as warnings.
`query` The PreparedStatement to execute.
`mrid` The mRID of the relevant object that is being saved
`description` A description of the type of object (e.g AcLineSegment)
Returns True if the execute was successful, False otherwise.
"""
return try_execute_single_update(query, self.cursor, description, lambda: self._failed_ids.add(mrid))
@staticmethod
def _mrid_or_none(io: Optional[IdentifiedObject]) -> Optional[str]:
if io is not None:
return io.mrid
else:
return None | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/writers/base_cim_writer.py | base_cim_writer.py |
from zepben.evolve import DiagramObject, TableDiagramObjects, Diagram, TableDiagrams, DiagramObjectPoint, TableDiagramObjectPoints
from zepben.evolve.database.sqlite.writers.base_cim_writer import BaseCIMWriter
__all__ = ["DiagramCIMWriter"]
class DiagramCIMWriter(BaseCIMWriter):
# ************ IEC61970 DIAGRAM LAYOUT ************
def save_diagram(self, diagram: Diagram) -> bool:
table = self.database_tables.get_table(TableDiagrams)
insert = self.database_tables.get_insert(TableDiagrams)
insert.add_value(table.diagram_style.query_index, diagram.diagram_style.name)
insert.add_value(table.orientation_kind.query_index, diagram.orientation_kind.name)
return self.save_identified_object(table, insert, diagram, "diagram")
def save_diagram_object(self, diagram_object: DiagramObject) -> bool:
table = self.database_tables.get_table(TableDiagramObjects)
insert = self.database_tables.get_insert(TableDiagramObjects)
status = True
for sequence, point in enumerate(diagram_object.points):
status = status and self.save_diagram_object_point(diagram_object, point, sequence)
insert.add_value(table.identified_object_mrid.query_index, diagram_object.identified_object_mrid)
insert.add_value(table.diagram_mrid.query_index, self._mrid_or_none(diagram_object.diagram))
insert.add_value(table.style.query_index, diagram_object.style)
insert.add_value(table.rotation.query_index, diagram_object.rotation)
return status and self.save_identified_object(table, insert, diagram_object, "diagram object")
def save_diagram_object_point(self, diagram_object: DiagramObject, diagram_object_point: DiagramObjectPoint, sequence_number: int) -> bool:
table = self.database_tables.get_table(TableDiagramObjectPoints)
insert = self.database_tables.get_insert(TableDiagramObjectPoints)
insert.add_value(table.diagram_object_mrid.query_index, diagram_object.mrid)
insert.add_value(table.sequence_number.query_index, sequence_number)
insert.add_value(table.x_position.query_index, diagram_object_point.x_position)
insert.add_value(table.y_position.query_index, diagram_object_point.y_position)
return self.try_execute_single_update(insert, "{}-point{}".format(diagram_object.mrid, sequence_number), "diagram object point") | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/writers/diagram_cim_writer.py | diagram_cim_writer.py |
from __future__ import annotations
import inspect
from abc import abstractmethod
from typing import List, Optional, Type, TypeVar, Any
from dataclassy import dataclass
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
__all__ = ["SqliteTable"]
@dataclass(slots=True)
class SqliteTable(object):
"""
Represents a table in an Sqlite Database. This class should be extended and initialised to build the DDL for a Table.
Methods that need to be overridden are those marked @abstractmethod.
Methods that can be optionally overridden are unique_index_columns() and non_unique_index_columns().
Columns must be assigned in __init__ and column_index must be incremented for each Column created.
See existing implementations such as TableVersion for examples.
"""
column_index: int = 0
"""Used to specify index of the column in the table during initialisation. Always increment BEFORE creating a Column. Indices start from 1."""
_column_set: Optional[List[Column]] = None
_create_table_sql: Optional[str] = None
_prepared_insert_sql: Optional[str] = None
_prepared_update_sql: Optional[str] = None
_create_indexes_sql: Optional[List[str]] = None
_select_sql: Optional[str] = None
@abstractmethod
def name(self) -> str:
pass
def unique_index_columns(self) -> List[List[Column]]:
return []
def non_unique_index_columns(self) -> List[List[Column]]:
return []
def column_set(self) -> List[Column]:
return self._column_set if self._column_set else self._build_column_set(self.__class__, self)
def create_table_sql(self):
return self._create_table_sql if self._create_table_sql else self._build_create_table_sql()
def select_sql(self):
return self._select_sql if self._select_sql else self._build_select_sql()
def prepared_insert_sql(self):
return self._prepared_insert_sql if self._prepared_insert_sql else self._build_prepared_insert_sql()
def prepared_update_sql(self):
return self._prepared_update_sql if self._prepared_update_sql else self._build_prepared_update_sql()
def create_indexes_sql(self):
return self._create_indexes_sql if self._create_indexes_sql else self._build_indexes_sql()
def _build_column_set(self, clazz: Type[Any], instance: Any) -> List[Column]:
"""
Builds the list of columns for use in DDL statements for this table.
:param clazz: The class of this table.
:param instance:
:return:
"""
cols = list()
attributes = inspect.getmembers(clazz, lambda it: not inspect.isroutine(it))
declared_fields = [a for a in attributes if not a[0].startswith('_')]
for field, _ in declared_fields:
try:
x = getattr(instance, field)
if isinstance(x, Column):
for c in cols:
if x.query_index == c.query_index:
raise ValueError(
f"Field {field} in SQL Table class {clazz.__name__} is using an index that has already been used. "
f"Did you forget to increment column_index?"
)
cols.append(x)
except Exception as e:
raise ValueError(f"Unable to retrieve field {field}. It will be missing from the database. Error was: {str(e)}")
self._column_set = sorted(cols, key=lambda it: it.query_index)
return self._column_set
def _build_create_table_sql(self) -> str:
self._create_table_sql = f"CREATE TABLE {self.name()} ({', '.join([str(c) for c in self.column_set()])})"
return self._create_table_sql
def _build_select_sql(self) -> str:
self._select_sql = f"SELECT {', '.join([c.name for c in self.column_set()])} FROM {self.name()}"
return self._select_sql
def _build_prepared_insert_sql(self) -> str:
self._prepared_insert_sql = f"INSERT INTO {self.name()} ({', '.join([c.name for c in self.column_set()])}) " \
f"VALUES ({', '.join(['?' for _ in self.column_set()])})"
return self._prepared_insert_sql
def _build_prepared_update_sql(self) -> str:
self._prepared_update_sql = f"UPDATE {self.name()} SET {', '.join([f'{c.name} = ?' for c in self.column_set()])}"
return self._prepared_update_sql
def _build_indexes_sql(self) -> List[str]:
statements = []
for index_col in self.unique_index_columns():
statements.append(self._build_index_sql(index_col, True))
for index_col in self.non_unique_index_columns():
statements.append(self._build_index_sql(index_col, False))
self._create_indexes_sql = statements
return self._create_indexes_sql
def _build_index_sql(self, index_col: List[Column], is_unique: bool):
id_string = f"{self.name()}_{'_'.join(map(lambda c: c.name, index_col))}"
col_string = ', '.join(map(lambda c: c.name, index_col))
return f"CREATE {'UNIQUE ' if is_unique else ''}INDEX {id_string} ON {self.name()} ({col_string})"
def _create_column(self,
name: str,
type_: str,
nullable: Nullable = Nullable.NONE
) -> Column:
self.column_index += 1
# noinspection PyArgumentList
return Column(self.column_index, name, type_, nullable)
T = TypeVar("T", bound=SqliteTable) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/sqlite_table.py | sqlite_table.py |
from sqlite3 import Cursor
from typing import Dict, TypeVar, Type, Any
from dataclassy import dataclass
from zepben.evolve.database.sqlite.tables.associations.assetorganisationroles_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.circuit_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.customeragreements_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.equipment_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.loop_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.pricingstructure_association_tables import *
from zepben.evolve.database.sqlite.tables.associations.usagepoints_association_tables import *
from zepben.evolve.database.sqlite.tables.exceptions import MissingTableConfigException, SqlException
from zepben.evolve.database.sqlite.tables.iec61968.asset_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.assetinfo_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.common_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.customer_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.metering_tables import *
from zepben.evolve.database.sqlite.tables.iec61968.operations_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.auxiliaryequipment_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.core_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.diagramlayout_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.equivalent_tables import TableEquivalentBranches
from zepben.evolve.database.sqlite.tables.iec61970.base.infiec61970.feeder_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.meas_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.scada_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.conductor_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.connector_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.energyconnection_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.generation.production_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.perlength_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.switch_tables import *
from zepben.evolve.database.sqlite.tables.iec61970.base.wires.transformer_tables import *
from zepben.evolve.database.sqlite.tables.metadata_tables import *
from zepben.evolve.database.sqlite.tables.sqlite_table import *
__all__ = ["DatabaseTables", "PreparedStatement"]
T = TypeVar("T", bound=SqliteTable)
def _create_tables() -> Dict[Type[T], T]:
return {
TableAcLineSegments: TableAcLineSegments(),
TableAccumulators: TableAccumulators(),
TableAnalogs: TableAnalogs(),
TableAssetOrganisationRolesAssets: TableAssetOrganisationRolesAssets(),
TableAssetOwners: TableAssetOwners(),
TableBaseVoltages: TableBaseVoltages(),
TableBatteryUnit: TableBatteryUnit(),
TableBreakers: TableBreakers(),
TableBusbarSections: TableBusbarSections(),
TableCableInfo: TableCableInfo(),
TableCircuits: TableCircuits(),
TableCircuitsSubstations: TableCircuitsSubstations(),
TableCircuitsTerminals: TableCircuitsTerminals(),
TableConnectivityNodes: TableConnectivityNodes(),
TableControls: TableControls(),
TableCustomerAgreements: TableCustomerAgreements(),
TableCustomerAgreementsPricingStructures: TableCustomerAgreementsPricingStructures(),
TableCustomers: TableCustomers(),
TableDiagramObjectPoints: TableDiagramObjectPoints(),
TableDiagramObjects: TableDiagramObjects(),
TableDiagrams: TableDiagrams(),
TableDisconnectors: TableDisconnectors(),
TableDiscretes: TableDiscretes(),
TableEnergyConsumerPhases: TableEnergyConsumerPhases(),
TableEnergyConsumers: TableEnergyConsumers(),
TableEnergySourcePhases: TableEnergySourcePhases(),
TableEnergySources: TableEnergySources(),
TableEquipmentEquipmentContainers: TableEquipmentEquipmentContainers(),
TableEquipmentOperationalRestrictions: TableEquipmentOperationalRestrictions(),
TableEquipmentUsagePoints: TableEquipmentUsagePoints(),
TableEquivalentBranches: TableEquivalentBranches(),
TableFaultIndicators: TableFaultIndicators(),
TableFeeders: TableFeeders(),
TableFuses: TableFuses(),
TableGeographicalRegions: TableGeographicalRegions(),
TableJumpers: TableJumpers(),
TableJunctions: TableJunctions(),
TableLinearShuntCompensators: TableLinearShuntCompensators(),
TableLoadBreakSwitches: TableLoadBreakSwitches(),
TableLocationStreetAddresses: TableLocationStreetAddresses(),
TableLocations: TableLocations(),
TableLoops: TableLoops(),
TableLoopsSubstations: TableLoopsSubstations(),
TableMetadataDataSources: TableMetadataDataSources(),
TableMeters: TableMeters(),
TableNameTypes: TableNameTypes(),
TableNames: TableNames(),
TableNoLoadTests: TableNoLoadTests(),
TableOpenCircuitTests: TableOpenCircuitTests(),
TableOperationalRestrictions: TableOperationalRestrictions(),
TableOrganisations: TableOrganisations(),
TableOverheadWireInfo: TableOverheadWireInfo(),
TablePerLengthSequenceImpedances: TablePerLengthSequenceImpedances(),
TablePhotoVoltaicUnit: TablePhotoVoltaicUnit(),
TablePoles: TablePoles(),
TablePositionPoints: TablePositionPoints(),
TablePowerElectronicsConnection: TablePowerElectronicsConnection(),
TablePowerElectronicsConnectionPhases: TablePowerElectronicsConnectionPhases(),
TablePowerElectronicsWindUnit: TablePowerElectronicsWindUnit(),
TablePowerTransformerEnds: TablePowerTransformerEnds(),
TablePowerTransformerInfo: TablePowerTransformerInfo(),
TablePowerTransformers: TablePowerTransformers(),
TablePricingStructures: TablePricingStructures(),
TablePricingStructuresTariffs: TablePricingStructuresTariffs(),
TableRatioTapChangers: TableRatioTapChangers(),
TableReclosers: TableReclosers(),
TableRemoteControls: TableRemoteControls(),
TableRemoteSources: TableRemoteSources(),
TableShortCircuitTests: TableShortCircuitTests(),
TableShuntCompensatorInfo: TableShuntCompensatorInfo(),
TableSites: TableSites(),
TableStreetlights: TableStreetlights(),
TableSubGeographicalRegions: TableSubGeographicalRegions(),
TableSubstations: TableSubstations(),
TableTariffs: TableTariffs(),
TableTerminals: TableTerminals(),
TableTransformerEndInfo: TableTransformerEndInfo(),
TableTransformerStarImpedance: TableTransformerStarImpedance(),
TableTransformerTankInfo: TableTransformerTankInfo(),
TableUsagePoints: TableUsagePoints(),
TableUsagePointsEndDevices: TableUsagePointsEndDevices(),
TableVersion: TableVersion(),
}
@dataclass(slots=True)
class PreparedStatement(object):
statement: str
_values: Dict[int, Any] = dict()
_num_cols: int = None
def __init__(self):
self._num_cols = self.statement.count('?')
@property
def num_columns(self):
return self._num_cols
@property
def parameters(self):
"""
Get the string representation of the current parameters set on this PreparedStatement.
'(unset)' means this index has not yet been set.
This function should be used for error handling and debugging only.
Returns the string representation of all parameters that have been set on this PreparedStatement, separated by commas.
"""
pm = []
for i in range(1, self.num_columns + 1):
try:
pm.append(str(self._values[i]))
except KeyError:
pm.append("(unset)")
return ", ".join(pm)
def execute(self, cursor: Cursor):
"""
Execute this PreparedStatement using the given `cursor`.
Throws any exception possible from cursor.execute, typically `sqlite3.DatabaseError`
"""
parameters = []
missing = []
for i in range(1, self.num_columns + 1):
try:
parameters.append(self._values[i])
except KeyError:
missing.append(str(i))
if missing:
raise SqlException(f"Missing values for indices {', '.join(missing)}. Ensure all ?'s have a corresponding value in the prepared statement.")
cursor.execute(self.statement, parameters)
def add_value(self, index: int, value: Any):
if 0 < index <= self._num_cols:
self._values[index] = value
else:
raise SqlException(f"index must be between 1 and {self.num_columns} for this statement, got {index}")
@dataclass(slots=True)
class DatabaseTables(object):
_tables: Dict[Type[T], T] = _create_tables()
_insert_statements: Dict[Type[T], PreparedStatement] = dict()
def __init__(self):
self._insert_statements.clear()
for t, table in self._tables.items():
self._insert_statements[t] = PreparedStatement(table.prepared_insert_sql())
def get_table(self, clazz: Type[T]) -> T:
try:
return self._tables[clazz]
except KeyError:
raise MissingTableConfigException(f"No table has been registered for {clazz}. Add the table to database_tables.py")
def get_insert(self, clazz: Type[T]) -> PreparedStatement:
try:
return self._insert_statements[clazz]
except KeyError:
raise MissingTableConfigException(f"No prepared insert statement has been registered for {clazz}. Add the to database_tables.py")
@property
def tables(self):
for t in self._tables.values():
yield t
@staticmethod
def copy():
return DatabaseTables() | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/database_tables.py | database_tables.py |
from typing import List
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
from zepben.evolve.database.sqlite.tables.iec61970.base.core_tables import TableIdentifiedObjects
__all__ = ["TableMeasurements", "TableAnalogs", "TableControls", "TableAccumulators", "TableDiscretes", "TableIoPoints"]
# noinspection PyAbstractClass
class TableMeasurements(TableIdentifiedObjects):
power_system_resource_mrid: Column = None
remote_source_mrid: Column = None
terminal_mrid: Column = None
phases: Column = None
unit_symbol: Column = None
def __init__(self):
super(TableMeasurements, self).__init__()
self.power_system_resource_mrid = self._create_column("power_system_resource_mrid", "TEXT", Nullable.NULL)
self.remote_source_mrid = self._create_column("remote_source_mrid", "TEXT", Nullable.NULL)
self.terminal_mrid = self._create_column("terminal_mrid", "TEXT", Nullable.NULL)
self.phases = self._create_column("phases", "TEXT", Nullable.NOT_NULL)
self.unit_symbol = self._create_column("unit_symbol", "TEXT", Nullable.NOT_NULL)
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableMeasurements, self).non_unique_index_columns()
cols.append([self.power_system_resource_mrid])
cols.append([self.remote_source_mrid])
cols.append([self.terminal_mrid])
return cols
class TableAccumulators(TableMeasurements):
def name(self) -> str:
return "accumulators"
class TableAnalogs(TableMeasurements):
positive_flow_in: Column = None
def __init__(self):
super(TableAnalogs, self).__init__()
self.positive_flow_in = self._create_column("positive_flow_in", "BOOLEAN", Nullable.NOT_NULL)
def name(self) -> str:
return "analogs"
# noinspection PyAbstractClass
class TableIoPoints(TableIdentifiedObjects):
pass
class TableControls(TableIoPoints):
power_system_resource_mrid: Column = None
def __init__(self):
super(TableControls, self).__init__()
self.power_system_resource_mrid = self._create_column("power_system_resource_mrid", "TEXT", Nullable.NULL)
def name(self) -> str:
return "controls"
class TableDiscretes(TableMeasurements):
def name(self) -> str:
return "discretes" | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/iec61970/base/meas_tables.py | meas_tables.py |
from zepben.evolve import Column, TableConductingEquipment, Nullable
__all__ = ["TableEquivalentBranches", "TableEquivalentEquipment"]
# noinspection PyAbstractClass
class TableEquivalentEquipment(TableConductingEquipment):
pass
class TableEquivalentBranches(TableEquivalentEquipment):
negative_r12: Column = None
negative_r21: Column = None
negative_x12: Column = None
negative_x21: Column = None
positive_r12: Column = None
positive_r21: Column = None
positive_x12: Column = None
positive_x21: Column = None
r: Column = None
r21: Column = None
x: Column = None
x21: Column = None
zero_r12: Column = None
zero_r21: Column = None
zero_x12: Column = None
zero_x21: Column = None
def __init__(self):
super(TableEquivalentBranches, self).__init__()
self.negative_r12 = self._create_column("negative_r12", "NUMBER", Nullable.NULL)
self.negative_r21 = self._create_column("negative_r21", "NUMBER", Nullable.NULL)
self.negative_x12 = self._create_column("negative_x12", "NUMBER", Nullable.NULL)
self.negative_x21 = self._create_column("negative_x21", "NUMBER", Nullable.NULL)
self.positive_r12 = self._create_column("positive_r12", "NUMBER", Nullable.NULL)
self.positive_r21 = self._create_column("positive_r21", "NUMBER", Nullable.NULL)
self.positive_x12 = self._create_column("positive_x12", "NUMBER", Nullable.NULL)
self.positive_x21 = self._create_column("positive_x21", "NUMBER", Nullable.NULL)
self.r = self._create_column("r", "NUMBER", Nullable.NULL)
self.r21 = self._create_column("r21", "NUMBER", Nullable.NULL)
self.x = self._create_column("x", "NUMBER", Nullable.NULL)
self.x21 = self._create_column("x21", "NUMBER", Nullable.NULL)
self.zero_r12 = self._create_column("zero_r12", "NUMBER", Nullable.NULL)
self.zero_r21 = self._create_column("zero_r21", "NUMBER", Nullable.NULL)
self.zero_x12 = self._create_column("zero_x12", "NUMBER", Nullable.NULL)
self.zero_x21 = self._create_column("zero_x21", "NUMBER", Nullable.NULL)
def name(self) -> str:
return "equivalent_branches" | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/iec61970/base/equivalent_tables.py | equivalent_tables.py |
from typing import List
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
from zepben.evolve.database.sqlite.tables.sqlite_table import SqliteTable
__all__ = ["TablePowerSystemResources", "TableSites", "TableNames", "TableTerminals", "TableFeeders", "TableIdentifiedObjects", "TableSubstations",
"TableAcDcTerminals", "TableEquipmentContainers", "TableEquipment", "TableConnectivityNodeContainers", "TableConductingEquipment",
"TableBaseVoltages", "TableConnectivityNodes", "TableSubGeographicalRegions", "TableNameTypes", "TableEquipment", "TableGeographicalRegions"]
# noinspection PyAbstractClass
class TableIdentifiedObjects(SqliteTable):
mrid: Column = None
name_: Column = None
description: Column = None
num_diagram_objects: Column = None
def __init__(self):
self.mrid = self._create_column("mrid", "TEXT", Nullable.NOT_NULL)
self.name_ = self._create_column("name", "TEXT", Nullable.NOT_NULL)
self.description = self._create_column("description", "TEXT", Nullable.NOT_NULL)
self.num_diagram_objects = self._create_column("num_diagram_objects", "INTEGER", Nullable.NOT_NULL)
def unique_index_columns(self) -> List[List[Column]]:
return [[self.mrid]]
def non_unique_index_columns(self) -> List[List[Column]]:
return [[self.name_]]
# noinspection PyAbstractClass
class TableAcDcTerminals(TableIdentifiedObjects):
pass
class TableBaseVoltages(TableIdentifiedObjects):
nominal_voltage: Column = None
def __init__(self):
super(TableBaseVoltages, self).__init__()
self.nominal_voltage = self._create_column("nominal_voltage", "INTEGER", Nullable.NOT_NULL)
def name(self) -> str:
return "base_voltages"
# noinspection PyAbstractClass
class TablePowerSystemResources(TableIdentifiedObjects):
location_mrid: Column = None
num_controls: Column = None
def __init__(self):
super(TablePowerSystemResources, self).__init__()
self.location_mrid = self._create_column("location_mrid", "TEXT", Nullable.NULL)
self.num_controls = self._create_column("num_controls", "INTEGER", Nullable.NOT_NULL)
# noinspection PyAbstractClass
class TableConnectivityNodeContainers(TablePowerSystemResources):
pass
class TableConnectivityNodes(TableIdentifiedObjects):
def name(self) -> str:
return "connectivity_nodes"
# noinspection PyAbstractClass
class TableEquipment(TablePowerSystemResources):
normally_in_service: Column = None
in_service: Column = None
def __init__(self):
super(TableEquipment, self).__init__()
self.normally_in_service = self._create_column("normally_in_service", "BOOLEAN")
self.in_service = self._create_column("in_service", "BOOLEAN")
# noinspection PyAbstractClass
class TableConductingEquipment(TableEquipment):
base_voltage_mrid: Column = None
def __init__(self):
super(TableConductingEquipment, self).__init__()
self.base_voltage_mrid = self._create_column("base_voltage_mrid", "TEXT", Nullable.NULL)
# noinspection PyAbstractClass
class TableEquipmentContainers(TableConnectivityNodeContainers):
pass
class TableFeeders(TableEquipmentContainers):
normal_head_terminal_mrid: Column = None
normal_energizing_substation_mrid: Column = None
def __init__(self):
super(TableFeeders, self).__init__()
self.normal_head_terminal_mrid = self._create_column("normal_head_terminal_mrid", "TEXT", Nullable.NULL)
self.normal_energizing_substation_mrid = self._create_column("normal_energizing_substation_mrid", "TEXT", Nullable.NULL)
def name(self) -> str:
return "feeders"
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEquipmentContainers, self).non_unique_index_columns()
cols.append([self.normal_energizing_substation_mrid])
return cols
class TableGeographicalRegions(TableIdentifiedObjects):
def name(self) -> str:
return "geographical_regions"
class TableNames(SqliteTable):
name_: Column = None
identified_object_mrid: Column = None
name_type_name: Column = None
def __init__(self):
super(TableNames, self).__init__()
self.name_ = self._create_column("name", "TEXT", Nullable.NOT_NULL)
self.identified_object_mrid = self._create_column("identified_object_mrid", "TEXT", Nullable.NOT_NULL)
self.name_type_name = self._create_column("name_type_name", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "names"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableNames, self).unique_index_columns()
cols.append([self.identified_object_mrid, self.name_type_name, self.name_])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableNames, self).non_unique_index_columns()
cols.append([self.identified_object_mrid])
cols.append([self.name_type_name])
cols.append([self.name_])
return cols
class TableNameTypes(SqliteTable):
name_: Column = None
description: Column = None
def __init__(self):
super(TableNameTypes, self).__init__()
self.name_ = self._create_column("name", "TEXT", Nullable.NOT_NULL)
self.description = self._create_column("description", "TEXT", Nullable.NULL)
def name(self) -> str:
return "name_types"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableNameTypes, self).unique_index_columns()
cols.append([self.name_])
return cols
class TableSites(TableEquipmentContainers):
def name(self) -> str:
return "sites"
class TableSubGeographicalRegions(TableIdentifiedObjects):
geographical_region_mrid: Column = None
def __init__(self):
super(TableSubGeographicalRegions, self).__init__()
self.geographical_region_mrid = self._create_column("geographical_region_mrid", "TEXT", Nullable.NULL)
def name(self) -> str:
return "sub_geographical_regions"
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableSubGeographicalRegions, self).non_unique_index_columns()
cols.append([self.geographical_region_mrid])
return cols
class TableSubstations(TableEquipmentContainers):
sub_geographical_region_mrid: Column = None
def __init__(self):
super(TableSubstations, self).__init__()
self.sub_geographical_region_mrid = self._create_column("sub_geographical_region_mrid", "TEXT", Nullable.NULL)
def name(self) -> str:
return "substations"
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableSubstations, self).non_unique_index_columns()
cols.append([self.sub_geographical_region_mrid])
return cols
class TableTerminals(TableAcDcTerminals):
conducting_equipment_mrid: Column = None
sequence_number: Column = None
connectivity_node_mrid: Column = None
phases: Column = None
def __init__(self):
super(TableTerminals, self).__init__()
self.conducting_equipment_mrid = self._create_column("conducting_equipment_mrid", "TEXT", Nullable.NULL)
self.sequence_number = self._create_column("sequence_number", "INTEGER", Nullable.NOT_NULL)
self.connectivity_node_mrid = self._create_column("connectivity_node_mrid", "TEXT", Nullable.NULL)
self.phases = self._create_column("phases", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "terminals"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableTerminals, self).unique_index_columns()
cols.append([self.conducting_equipment_mrid, self.sequence_number])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableTerminals, self).non_unique_index_columns()
cols.append([self.connectivity_node_mrid])
return cols | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/iec61970/base/core_tables.py | core_tables.py |
from typing import List
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
from zepben.evolve.database.sqlite.tables.iec61970.base.core_tables import TableIdentifiedObjects
from zepben.evolve.database.sqlite.tables.sqlite_table import SqliteTable
__all__ = ["TableDiagrams", "TableDiagramObjects", "TableDiagramObjects", "TableDiagramObjectPoints"]
class TableDiagramObjectPoints(SqliteTable):
diagram_object_mrid: Column = None
sequence_number: Column = None
x_position: Column = None
y_position: Column = None
def __init__(self):
super(TableDiagramObjectPoints, self).__init__()
self.diagram_object_mrid = self._create_column("diagram_object_mrid", "TEXT", Nullable.NOT_NULL)
self.sequence_number = self._create_column("sequence_number", "INTEGER", Nullable.NOT_NULL)
self.x_position = self._create_column("x_position", "NUMBER", Nullable.NULL)
self.y_position = self._create_column("y_position", "NUMBER", Nullable.NULL)
def name(self) -> str:
return "diagram_object_points"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableDiagramObjectPoints, self).unique_index_columns()
cols.append([self.diagram_object_mrid, self.sequence_number])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableDiagramObjectPoints, self).non_unique_index_columns()
cols.append([self.diagram_object_mrid])
return cols
class TableDiagramObjects(TableIdentifiedObjects):
identified_object_mrid: Column = None
diagram_mrid: Column = None
style: Column = None
rotation: Column = None
def __init__(self):
super(TableDiagramObjects, self).__init__()
self.identified_object_mrid = self._create_column("identified_object_mrid", "TEXT", Nullable.NULL)
self.diagram_mrid = self._create_column("diagram_mrid", "TEXT", Nullable.NULL)
self.style = self._create_column("style", "TEXT", Nullable.NULL)
self.rotation = self._create_column("rotation", "NUMBER", Nullable.NOT_NULL)
def name(self) -> str:
return "diagram_objects"
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableDiagramObjects, self).non_unique_index_columns()
cols.append([self.identified_object_mrid])
cols.append([self.diagram_mrid])
return cols
class TableDiagrams(TableIdentifiedObjects):
diagram_style: Column = None
orientation_kind: Column = None
def __init__(self):
super(TableDiagrams, self).__init__()
self.diagram_style = self._create_column("diagram_style", "TEXT", Nullable.NOT_NULL)
self.orientation_kind = self._create_column("orientation_kind", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "diagrams" | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/iec61970/base/diagramlayout_tables.py | diagramlayout_tables.py |
from typing import List
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
from zepben.evolve.database.sqlite.tables.iec61970.base.core_tables import TableIdentifiedObjects, TableConductingEquipment, TablePowerSystemResources
__all__ = ["TableTransformerEnds", "TablePowerTransformerEnds", "TablePowerTransformers", "TableTapChangers", "TableRatioTapChangers",
"TableTransformerStarImpedance"]
# noinspection PyAbstractClass
class TableTransformerEnds(TableIdentifiedObjects):
end_number: Column = None
terminal_mrid: Column = None
base_voltage_mrid: Column = None
grounded: Column = None
r_ground: Column = None
x_ground: Column = None
star_impedance_mrid: Column = None
def __init__(self):
super(TableTransformerEnds, self).__init__()
self.end_number = self._create_column("end_number", "INTEGER", Nullable.NOT_NULL)
self.terminal_mrid = self._create_column("terminal_mrid", "TEXT", Nullable.NULL)
self.base_voltage_mrid = self._create_column("base_voltage_mrid", "TEXT", Nullable.NULL)
self.grounded = self._create_column("grounded", "BOOLEAN", Nullable.NOT_NULL)
self.r_ground = self._create_column("r_ground", "NUMBER", Nullable.NULL)
self.x_ground = self._create_column("x_ground", "NUMBER", Nullable.NULL)
self.star_impedance_mrid = self._create_column("star_impedance_mrid", "TEXT", Nullable.NULL)
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableTransformerEnds, self).non_unique_index_columns()
cols.append([self.star_impedance_mrid])
return cols
class TablePowerTransformerEnds(TableTransformerEnds):
power_transformer_mrid: Column = None
connection_kind: Column = None
phase_angle_clock: Column = None
b: Column = None
b0: Column = None
g: Column = None
g0: Column = None
r: Column = None
r0: Column = None
rated_s: Column = None
rated_u: Column = None
x: Column = None
x0: Column = None
def __init__(self):
super(TablePowerTransformerEnds, self).__init__()
self.power_transformer_mrid = self._create_column("power_transformer_mrid", "TEXT", Nullable.NULL)
self.connection_kind = self._create_column("connection_kind", "TEXT", Nullable.NOT_NULL)
self.phase_angle_clock = self._create_column("phase_angle_clock", "INTEGER", Nullable.NULL)
self.b = self._create_column("b", "NUMBER", Nullable.NULL)
self.b0 = self._create_column("b0", "NUMBER", Nullable.NULL)
self.g = self._create_column("g", "NUMBER", Nullable.NULL)
self.g0 = self._create_column("g0", "NUMBER", Nullable.NULL)
self.r = self._create_column("r", "NUMBER", Nullable.NULL)
self.r0 = self._create_column("r0", "NUMBER", Nullable.NULL)
self.rated_s = self._create_column("rated_s", "INTEGER", Nullable.NULL)
self.rated_u = self._create_column("rated_u", "INTEGER", Nullable.NULL)
self.x = self._create_column("x", "NUMBER", Nullable.NULL)
self.x0 = self._create_column("x0", "NUMBER", Nullable.NULL)
def name(self) -> str:
return "power_transformer_ends"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TablePowerTransformerEnds, self).unique_index_columns()
cols.append([self.power_transformer_mrid, self.end_number])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TablePowerTransformerEnds, self).non_unique_index_columns()
cols.append([self.power_transformer_mrid])
return cols
class TablePowerTransformers(TableConductingEquipment):
vector_group: Column = None
transformer_utilisation: Column = None
construction_kind: Column = None
function: Column = None
power_transformer_info_mrid: Column = None
def __init__(self):
super(TablePowerTransformers, self).__init__()
self.vector_group = self._create_column("vector_group", "TEXT", Nullable.NOT_NULL)
self.transformer_utilisation = self._create_column("transformer_utilisation", "NUMBER", Nullable.NULL)
self.construction_kind = self._create_column("construction_kind", "TEXT", Nullable.NOT_NULL)
self.function = self._create_column("function", "TEXT", Nullable.NOT_NULL)
self.power_transformer_info_mrid = self._create_column("power_transformer_info_mrid", "TEXT", Nullable.NULL)
def name(self) -> str:
return "power_transformers"
# noinspection PyAbstractClass
class TableTapChangers(TablePowerSystemResources):
control_enabled: Column = None
high_step: Column = None
low_step: Column = None
neutral_step: Column = None
neutral_u: Column = None
normal_step: Column = None
step: Column = None
def __init__(self):
super(TableTapChangers, self).__init__()
self.control_enabled = self._create_column("control_enabled", "BOOLEAN", Nullable.NOT_NULL)
self.high_step = self._create_column("high_step", "INTEGER", Nullable.NULL)
self.low_step = self._create_column("low_step", "INTEGER", Nullable.NULL)
self.neutral_step = self._create_column("neutral_step", "INTEGER", Nullable.NULL)
self.neutral_u = self._create_column("neutral_u", "INTEGER", Nullable.NULL)
self.normal_step = self._create_column("normal_step", "INTEGER", Nullable.NULL)
self.step = self._create_column("step", "NUMBER", Nullable.NULL)
class TableRatioTapChangers(TableTapChangers):
transformer_end_mrid: Column = None
step_voltage_increment: Column = None
def __init__(self):
super(TableRatioTapChangers, self).__init__()
self.transformer_end_mrid = self._create_column("transformer_end_mrid", "TEXT", Nullable.NULL)
self.step_voltage_increment = self._create_column("step_voltage_increment", "NUMBER", Nullable.NULL)
def name(self) -> str:
return "ratio_tap_changers"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableRatioTapChangers, self).unique_index_columns()
cols.append([self.transformer_end_mrid])
return cols
class TableTransformerStarImpedance(TableIdentifiedObjects):
r: Column = None
r0: Column = None
x: Column = None
x0: Column = None
transformer_end_info_mrid: Column = None
def __init__(self):
super(TableTransformerStarImpedance, self).__init__()
# Note r, r0, x, x0 use nullable number types.
self.r = self._create_column("R", "NUMBER", Nullable.NULL)
self.r0 = self._create_column("R0", "NUMBER", Nullable.NULL)
self.x = self._create_column("X", "NUMBER", Nullable.NULL)
self.x0 = self._create_column("X0", "NUMBER", Nullable.NULL)
self.transformer_end_info_mrid = self._create_column("transformer_end_info_mrid", "TEXT", Nullable.NULL)
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableTransformerStarImpedance, self).unique_index_columns()
cols.append([self.transformer_end_info_mrid])
return cols
def name(self) -> str:
return "transformer_star_impedance" | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/iec61970/base/wires/transformer_tables.py | transformer_tables.py |
from typing import List
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
from zepben.evolve.database.sqlite.tables.iec61970.base.core_tables import TableConductingEquipment, TablePowerSystemResources
__all__ = ["TableEnergyConnections", "TableEnergyConsumerPhases", "TableEnergyConsumers", "TableEnergySources", "TableEnergySourcePhases",
"TableRegulatingCondEq", "TableShuntCompensators", "TableLinearShuntCompensators", "TablePowerElectronicsConnection",
"TablePowerElectronicsConnectionPhases"]
# noinspection PyAbstractClass
class TableEnergyConnections(TableConductingEquipment):
pass
class TableEnergyConsumerPhases(TablePowerSystemResources):
energy_consumer_mrid: Column = None
phase: Column = None
p: Column = None
q: Column = None
p_fixed: Column = None
q_fixed: Column = None
def __init__(self):
super(TableEnergyConsumerPhases, self).__init__()
self.energy_consumer_mrid = self._create_column("energy_consumer_mrid", "TEXT", Nullable.NOT_NULL)
self.phase = self._create_column("phase", "TEXT", Nullable.NOT_NULL)
self.p = self._create_column("p", "NUMBER", Nullable.NULL)
self.q = self._create_column("q", "NUMBER", Nullable.NULL)
self.p_fixed = self._create_column("p_fixed", "NUMBER", Nullable.NULL)
self.q_fixed = self._create_column("q_fixed", "NUMBER", Nullable.NULL)
def name(self) -> str:
return "energy_consumer_phases"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEnergyConsumerPhases, self).unique_index_columns()
cols.append([self.energy_consumer_mrid, self.phase])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEnergyConsumerPhases, self).non_unique_index_columns()
cols.append([self.energy_consumer_mrid])
return cols
class TableEnergyConsumers(TableEnergyConnections):
customer_count: Column = None
grounded: Column = None
p: Column = None
q: Column = None
p_fixed: Column = None
q_fixed: Column = None
phase_connection: Column = None
def __init__(self):
super(TableEnergyConsumers, self).__init__()
self.customer_count = self._create_column("customer_count", "INTEGER", Nullable.NULL)
self.grounded = self._create_column("grounded", "BOOLEAN", Nullable.NOT_NULL)
self.p = self._create_column("p", "NUMBER", Nullable.NULL)
self.q = self._create_column("q", "NUMBER", Nullable.NULL)
self.p_fixed = self._create_column("p_fixed", "NUMBER", Nullable.NULL)
self.q_fixed = self._create_column("q_fixed", "NUMBER", Nullable.NULL)
self.phase_connection = self._create_column("phase_connection", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "energy_consumers"
class TableEnergySourcePhases(TablePowerSystemResources):
energy_source_mrid: Column = None
phase: Column = None
def __init__(self):
super(TableEnergySourcePhases, self).__init__()
self.energy_source_mrid = self._create_column("energy_source_mrid", "TEXT", Nullable.NOT_NULL)
self.phase = self._create_column("phase", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "energy_source_phases"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEnergySourcePhases, self).unique_index_columns()
cols.append([self.energy_source_mrid, self.phase])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEnergySourcePhases, self).non_unique_index_columns()
cols.append([self.energy_source_mrid])
return cols
class TableEnergySources(TableEnergyConnections):
active_power: Column = None
reactive_power: Column = None
voltage_angle: Column = None
voltage_magnitude: Column = None
p_max: Column = None
p_min: Column = None
r: Column = None
r0: Column = None
rn: Column = None
x: Column = None
x0: Column = None
xn: Column = None
is_external_grid: Column = None
r_min: Column = None
rn_min: Column = None
r0_min: Column = None
x_min: Column = None
xn_min: Column = None
x0_min: Column = None
r_max: Column = None
rn_max: Column = None
r0_max: Column = None
x_max: Column = None
xn_max: Column = None
x0_max: Column = None
def __init__(self):
super(TableEnergySources, self).__init__()
self.active_power = self._create_column("active_power", "NUMBER", Nullable.NULL)
self.reactive_power = self._create_column("reactive_power", "NUMBER", Nullable.NULL)
self.voltage_angle = self._create_column("voltage_angle", "NUMBER", Nullable.NULL)
self.voltage_magnitude = self._create_column("voltage_magnitude", "NUMBER", Nullable.NULL)
self.p_max = self._create_column("p_max", "NUMBER", Nullable.NULL)
self.p_min = self._create_column("p_min", "NUMBER", Nullable.NULL)
self.r = self._create_column("r", "NUMBER", Nullable.NULL)
self.r0 = self._create_column("r0", "NUMBER", Nullable.NULL)
self.rn = self._create_column("rn", "NUMBER", Nullable.NULL)
self.x = self._create_column("x", "NUMBER", Nullable.NULL)
self.x0 = self._create_column("x0", "NUMBER", Nullable.NULL)
self.xn = self._create_column("xn", "NUMBER", Nullable.NULL)
self.is_external_grid = self._create_column("is_external_grid", "BOOLEAN", Nullable.NOT_NULL)
self.r_min = self._create_column("r_min", "NUMBER", Nullable.NULL)
self.rn_min = self._create_column("rn_min", "NUMBER", Nullable.NULL)
self.r0_min = self._create_column("r0_min", "NUMBER", Nullable.NULL)
self.x_min = self._create_column("x_min", "NUMBER", Nullable.NULL)
self.xn_min = self._create_column("xn_min", "NUMBER", Nullable.NULL)
self.x0_min = self._create_column("x0_min", "NUMBER", Nullable.NULL)
self.r_max = self._create_column("r_max", "NUMBER", Nullable.NULL)
self.rn_max = self._create_column("rn_max", "NUMBER", Nullable.NULL)
self.r0_max = self._create_column("r0_max", "NUMBER", Nullable.NULL)
self.x_max = self._create_column("x_max", "NUMBER", Nullable.NULL)
self.xn_max = self._create_column("xn_max", "NUMBER", Nullable.NULL)
self.x0_max = self._create_column("x0_max", "NUMBER", Nullable.NULL)
def name(self) -> str:
return "energy_sources"
# noinspection PyAbstractClass
class TableRegulatingCondEq(TableEnergyConnections):
control_enabled: Column = None
def __init__(self):
super(TableRegulatingCondEq, self).__init__()
self.control_enabled = self._create_column("control_enabled", "BOOLEAN", Nullable.NOT_NULL)
# noinspection PyAbstractClass
class TableShuntCompensators(TableRegulatingCondEq):
shunt_compensator_info_mrid: Column = None
grounded: Column = None
nom_u: Column = None
phase_connection: Column = None
sections: Column = None
def __init__(self):
super(TableShuntCompensators, self).__init__()
self.shunt_compensator_info_mrid = self._create_column("shunt_compensator_info_mrid", "TEXT", Nullable.NULL)
self.grounded = self._create_column("grounded", "BOOLEAN", Nullable.NOT_NULL)
self.nom_u = self._create_column("nom_u", "INTEGER", Nullable.NULL)
self.phase_connection = self._create_column("phase_connection", "TEXT", Nullable.NOT_NULL)
self.sections = self._create_column("sections", "NUMBER", Nullable.NULL)
class TableLinearShuntCompensators(TableShuntCompensators):
b0_per_section: Column = None
b_per_section: Column = None
g0_per_section: Column = None
g_per_section: Column = None
def __init__(self):
super(TableLinearShuntCompensators, self).__init__()
self.b0_per_section = self._create_column("b0_per_section", "NUMBER", Nullable.NULL)
self.b_per_section = self._create_column("b_per_section", "NUMBER", Nullable.NULL)
self.g0_per_section = self._create_column("g0_per_section", "NUMBER", Nullable.NULL)
self.g_per_section = self._create_column("g_per_section", "NUMBER", Nullable.NULL)
def name(self) -> str:
return "linear_shunt_compensators"
class TablePowerElectronicsConnection(TableRegulatingCondEq):
max_i_fault: Column = None
max_q: Column = None
min_q: Column = None
p: Column = None
q: Column = None
rated_s: Column = None
rated_u: Column = None
def __init__(self):
super(TablePowerElectronicsConnection, self).__init__()
self.max_i_fault = self._create_column("max_i_fault", "INTEGER", Nullable.NULL)
self.max_q = self._create_column("max_q", "NUMBER", Nullable.NULL)
self.min_q = self._create_column("min_q", "NUMBER", Nullable.NULL)
self.p = self._create_column("p", "NUMBER", Nullable.NULL)
self.q = self._create_column("q", "NUMBER", Nullable.NULL)
self.rated_s = self._create_column("rated_s", "INTEGER", Nullable.NULL)
self.rated_u = self._create_column("rated_u", "INTEGER", Nullable.NULL)
def name(self) -> str:
return "power_electronics_connection"
class TablePowerElectronicsConnectionPhases(TablePowerSystemResources):
power_electronics_connection_mrid: Column = None
p: Column = None
phase: Column = None
q: Column = None
def __init__(self):
super(TablePowerElectronicsConnectionPhases, self).__init__()
self.power_electronics_connection_mrid = self._create_column("power_electronics_connection_mrid", "TEXT", Nullable.NULL)
self.p = self._create_column("p", "NUMBER", Nullable.NULL)
self.phase = self._create_column("phase", "TEXT", Nullable.NOT_NULL)
self.q = self._create_column("q", "NUMBER", Nullable.NULL)
def name(self) -> str:
return "power_electronics_connection_phase"
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TablePowerElectronicsConnectionPhases, self).non_unique_index_columns()
cols.append([self.power_electronics_connection_mrid])
return cols | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/iec61970/base/wires/energyconnection_tables.py | energyconnection_tables.py |
from typing import List
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
from zepben.evolve.database.sqlite.tables.sqlite_table import SqliteTable
__all__ = ["TableEquipmentEquipmentContainers", "TableEquipmentUsagePoints", "TableEquipmentOperationalRestrictions"]
class TableEquipmentEquipmentContainers(SqliteTable):
equipment_mrid: Column = None
equipment_container_mrid: Column = None
def __init__(self):
super(TableEquipmentEquipmentContainers, self).__init__()
self.equipment_mrid = self._create_column("equipment_mrid", "TEXT", Nullable.NOT_NULL)
self.equipment_container_mrid = self._create_column("equipment_container_mrid", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "equipment_equipment_containers"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEquipmentEquipmentContainers, self).unique_index_columns()
cols.append([self.equipment_mrid, self.equipment_container_mrid])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEquipmentEquipmentContainers, self).non_unique_index_columns()
cols.append([self.equipment_mrid])
cols.append([self.equipment_container_mrid])
return cols
class TableEquipmentOperationalRestrictions(SqliteTable):
equipment_mrid: Column = None
operational_restriction_mrid: Column = None
def __init__(self):
super(TableEquipmentOperationalRestrictions, self).__init__()
self.equipment_mrid = self._create_column("equipment_mrid", "TEXT", Nullable.NOT_NULL)
self.operational_restriction_mrid = self._create_column("operational_restriction_mrid", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "equipment_operational_restrictions"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEquipmentOperationalRestrictions, self).unique_index_columns()
cols.append([self.equipment_mrid, self.operational_restriction_mrid])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEquipmentOperationalRestrictions, self).non_unique_index_columns()
cols.append([self.equipment_mrid])
cols.append([self.operational_restriction_mrid])
return cols
class TableEquipmentUsagePoints(SqliteTable):
equipment_mrid: Column = None
usage_point_mrid: Column = None
def __init__(self):
super(TableEquipmentUsagePoints, self).__init__()
self.equipment_mrid = self._create_column("equipment_mrid", "TEXT", Nullable.NOT_NULL)
self.usage_point_mrid = self._create_column("usage_point_mrid", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "equipment_usage_points"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEquipmentUsagePoints, self).unique_index_columns()
cols.append([self.equipment_mrid, self.usage_point_mrid])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableEquipmentUsagePoints, self).non_unique_index_columns()
cols.append([self.equipment_mrid])
cols.append([self.usage_point_mrid])
return cols | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/associations/equipment_association_tables.py | equipment_association_tables.py |
from typing import List
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
from zepben.evolve.database.sqlite.tables.sqlite_table import SqliteTable
__all__ = ["TableCircuitsSubstations", "TableCircuitsTerminals"]
class TableCircuitsSubstations(SqliteTable):
circuit_mrid: Column = None
substation_mrid: Column = None
def __init__(self):
super(TableCircuitsSubstations, self).__init__()
self.circuit_mrid = self._create_column("circuit_mrid", "TEXT", Nullable.NOT_NULL)
self.substation_mrid = self._create_column("substation_mrid", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "circuits_substations"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableCircuitsSubstations, self).unique_index_columns()
cols.append([self.circuit_mrid, self.substation_mrid])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableCircuitsSubstations, self).non_unique_index_columns()
cols.append([self.circuit_mrid])
cols.append([self.substation_mrid])
return cols
class TableCircuitsTerminals(SqliteTable):
circuit_mrid: Column = None
terminal_mrid: Column = None
def __init__(self):
super(TableCircuitsTerminals, self).__init__()
self.circuit_mrid = self._create_column("circuit_mrid", "TEXT", Nullable.NOT_NULL)
self.terminal_mrid = self._create_column("terminal_mrid", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "circuits_terminals"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableCircuitsTerminals, self).unique_index_columns()
cols.append([self.circuit_mrid, self.terminal_mrid])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableCircuitsTerminals, self).non_unique_index_columns()
cols.append([self.circuit_mrid])
cols.append([self.terminal_mrid])
return cols | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/associations/circuit_association_tables.py | circuit_association_tables.py |
from typing import List
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
from zepben.evolve.database.sqlite.tables.iec61968.asset_tables import TableAssetInfo
__all__ = ["TablePowerTransformerInfo", "TableTransformerEndInfo", "TableTransformerTankInfo", "TableWireInfo", "TableCableInfo", "TableAssetInfo",
"TableOverheadWireInfo", "TableNoLoadTests", "TableOpenCircuitTests", "TableShortCircuitTests", "TableTransformerTest", "TableShuntCompensatorInfo"]
# noinspection PyAbstractClass
class TableTransformerTest(TableAssetInfo):
base_power: Column = None
temperature: Column = None
def __init__(self):
super(TableTransformerTest, self).__init__()
self.base_power = self._create_column("base_power", "INTEGER", Nullable.NULL)
self.temperature = self._create_column("temperature", "NUMBER", Nullable.NULL)
class TableNoLoadTests(TableTransformerTest):
energised_end_voltage: Column = None
exciting_current: Column = None
exciting_current_zero: Column = None
loss: Column = None
loss_zero: Column = None
def name(self) -> str:
return "no_load_tests"
def __init__(self):
super(TableNoLoadTests, self).__init__()
self.energised_end_voltage = self._create_column("energised_end_voltage", "INTEGER", Nullable.NULL)
self.exciting_current = self._create_column("exciting_current", "NUMBER", Nullable.NULL)
self.exciting_current_zero = self._create_column("exciting_current_zero", "NUMBER", Nullable.NULL)
self.loss = self._create_column("loss", "NUMBER", Nullable.NULL)
self.loss_zero = self._create_column("loss_zero", "INTEGER", Nullable.NULL)
class TableOpenCircuitTests(TableTransformerTest):
energised_end_step: Column = None
energised_end_voltage: Column = None
open_end_step: Column = None
open_end_voltage: Column = None
phase_shift: Column = None
def name(self) -> str:
return "open_circuit_tests"
def __init__(self):
super(TableOpenCircuitTests, self).__init__()
self.energised_end_voltage = self._create_column("energised_end_step", "INTEGER", Nullable.NULL)
self.energised_end_step = self._create_column("energised_end_voltage", "INTEGER", Nullable.NULL)
self.open_end_step = self._create_column("open_end_step", "INTEGER", Nullable.NULL)
self.open_end_voltage = self._create_column("open_end_voltage", "INTEGER", Nullable.NULL)
self.phase_shift = self._create_column("phase_shift", "NUMBER", Nullable.NULL)
class TablePowerTransformerInfo(TableAssetInfo):
def name(self) -> str:
return "power_transformer_info"
class TableShortCircuitTests(TableTransformerTest):
current: Column = None
energised_end_step: Column = None
grounded_end_step: Column = None
leakage_impedance: Column = None
leakage_impedance_zero: Column = None
loss: Column = None
loss_zero: Column = None
power: Column = None
voltage: Column = None
voltage_ohmic_part: Column = None
def name(self) -> str:
return "short_circuit_tests"
def __init__(self):
super(TableShortCircuitTests, self).__init__()
self.current = self._create_column("current", "NUMBER", Nullable.NULL)
self.energised_end_step = self._create_column("energised_end_step", "INTEGER", Nullable.NULL)
self.grounded_end_step = self._create_column("grounded_end_step", "INTEGER", Nullable.NULL)
self.leakage_impedance = self._create_column("leakage_impedance", "NUMBER", Nullable.NULL)
self.leakage_impedance_zero = self._create_column("leakage_impedance_zero", "NUMBER", Nullable.NULL)
self.loss = self._create_column("loss", "INTEGER", Nullable.NULL)
self.loss_zero = self._create_column("loss_zero", "INTEGER", Nullable.NULL)
self.power = self._create_column("power", "NUMBER", Nullable.NULL)
self.voltage = self._create_column("voltage", "NUMBER", Nullable.NULL)
self.voltage_ohmic_part = self._create_column("voltage_ohmic_part", "NUMBER", Nullable.NULL)
class TableShuntCompensatorInfo(TableAssetInfo):
max_power_loss: Column = None
rated_current: Column = None
rated_reactive_power: Column = None
rated_voltage: Column = None
def __init__(self):
super(TableShuntCompensatorInfo, self).__init__()
self.max_power_loss = self._create_column("max_power_loss", "INTEGER", Nullable.NULL)
self.rated_current = self._create_column("rated_current", "INTEGER", Nullable.NULL)
self.rated_reactive_power = self._create_column("rated_reactive_power", "INTEGER", Nullable.NULL)
self.rated_voltage = self._create_column("rated_voltage", "INTEGER", Nullable.NULL)
def name(self) -> str:
return "shunt_compensator_info"
class TableTransformerEndInfo(TableAssetInfo):
connection_kind: Column = None
emergency_s: Column = None
end_number: Column = None
insulation_u: Column = None
phase_angle_clock: Column = None
r: Column = None
rated_s: Column = None
rated_u: Column = None
short_term_s: Column = None
transformer_tank_info_mrid: Column = None
energised_end_no_load_tests: Column = None
energised_end_short_circuit_tests: Column = None
grounded_end_short_circuit_tests: Column = None
open_end_open_circuit_tests: Column = None
energised_end_open_circuit_tests: Column = None
def __init__(self):
super(TableTransformerEndInfo, self).__init__()
self.connection_kind = self._create_column("connection_kind", "TEXT", Nullable.NOT_NULL)
self.emergency_s = self._create_column("emergency_s", "INTEGER", Nullable.NULL)
self.end_number = self._create_column("end_number", "INTEGER", Nullable.NOT_NULL)
self.insulation_u = self._create_column("insulation_u", "INTEGER", Nullable.NULL)
self.phase_angle_clock = self._create_column("phase_angle_clock", "INTEGER", Nullable.NULL)
self.r = self._create_column("r", "NUMBER", Nullable.NULL)
self.rated_s = self._create_column("rated_s", "INTEGER", Nullable.NULL)
self.rated_u = self._create_column("rated_u", "INTEGER", Nullable.NULL)
self.short_term_s = self._create_column("short_term_s", "INTEGER", Nullable.NULL)
self.transformer_tank_info_mrid = self._create_column("transformer_tank_info_mrid", "TEXT", Nullable.NULL)
self.energised_end_no_load_tests = self._create_column("energised_end_no_load_tests", "TEST", Nullable.NULL)
self.energised_end_short_circuit_tests = self._create_column("energised_end_short_circuit_tests", "TEST", Nullable.NULL)
self.grounded_end_short_circuit_tests = self._create_column("grounded_end_short_circuit_tests", "TEST", Nullable.NULL)
self.open_end_open_circuit_tests = self._create_column("open_end_open_circuit_tests", "TEST", Nullable.NULL)
self.energised_end_open_circuit_tests = self._create_column("energised_end_open_circuit_tests", "TEST", Nullable.NULL)
def name(self) -> str:
return "transformer_end_info"
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableTransformerEndInfo, self).non_unique_index_columns()
cols.append([self.transformer_tank_info_mrid])
return cols
class TableTransformerTankInfo(TableAssetInfo):
power_transformer_info_mrid: Column = None
def __init__(self):
super(TableTransformerTankInfo, self).__init__()
self.power_transformer_info_mrid = self._create_column("power_transformer_info_mrid", "TEXT", Nullable.NULL)
def name(self) -> str:
return "transformer_tank_info"
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableTransformerTankInfo, self).non_unique_index_columns()
cols.append([self.power_transformer_info_mrid])
return cols
# noinspection PyAbstractClass
class TableWireInfo(TableAssetInfo):
rated_current: Column = None
material: Column = None
def __init__(self):
super(TableWireInfo, self).__init__()
self.rated_current = self._create_column("rated_current", "NUMBER", Nullable.NULL)
self.material = self._create_column("material", "TEXT", Nullable.NOT_NULL)
class TableCableInfo(TableWireInfo):
def name(self) -> str:
return "cable_info"
class TableOverheadWireInfo(TableWireInfo):
def name(self) -> str:
return "overhead_wire_info" | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/iec61968/assetinfo_tables.py | assetinfo_tables.py |
from enum import Enum
from typing import List
from zepben.evolve.database.sqlite.tables.column import Column, Nullable
from zepben.evolve.database.sqlite.tables.iec61970.base.core_tables import TableIdentifiedObjects
from zepben.evolve.database.sqlite.tables.sqlite_table import SqliteTable
__all__ = ["TableDocuments", "TableAgreements", "TableLocations", "TableTownDetails", "TableStreetAddresses", "TableLocationStreetAddresses",
"TableLocationStreetAddressField", "TableOrganisationRoles", "TablePositionPoints", "TableOrganisations"]
# noinspection PyAbstractClass
class TableDocuments(TableIdentifiedObjects):
title: Column = None
created_date_time: Column = None
author_name: Column = None
type: Column = None
status: Column = None
comment: Column = None
def __init__(self):
super(TableDocuments, self).__init__()
self.title = self._create_column("title", "TEXT", Nullable.NOT_NULL)
self.created_date_time = self._create_column("created_date_time", "TEXT", Nullable.NULL)
self.author_name = self._create_column("author_name", "TEXT", Nullable.NOT_NULL)
self.type = self._create_column("type", "TEXT", Nullable.NOT_NULL)
self.status = self._create_column("status", "TEXT", Nullable.NOT_NULL)
self.comment = self._create_column("comment", "TEXT", Nullable.NOT_NULL)
# noinspection PyAbstractClass
class TableAgreements(TableDocuments):
pass
class TableLocations(TableIdentifiedObjects):
def name(self) -> str:
return "locations"
# noinspection PyAbstractClass
class TableTownDetails(SqliteTable):
town_name: Column = None
state_or_province: Column = None
def __init__(self):
super(TableTownDetails, self).__init__()
self.town_name = self._create_column("town_name", "TEXT", Nullable.NULL)
self.state_or_province = self._create_column("state_or_province", "TEXT", Nullable.NULL)
# noinspection PyAbstractClass
class TableStreetAddresses(TableTownDetails):
postal_code: Column = None
po_box: Column = None
building_name: Column = None
floor_identification: Column = None
street_name: Column = None
number: Column = None
suite_number: Column = None
type: Column = None
display_address: Column = None
def __init__(self):
super(TableStreetAddresses, self).__init__()
self.postal_code = self._create_column("postal_code", "TEXT", Nullable.NOT_NULL)
self.po_box = self._create_column("po_box", "TEXT", Nullable.NULL)
self.building_name = self._create_column("building_name", "TEXT", Nullable.NULL)
self.floor_identification = self._create_column("floor_identification", "TEXT", Nullable.NULL)
self.street_name = self._create_column("name", "TEXT", Nullable.NULL)
self.number = self._create_column("number", "TEXT", Nullable.NULL)
self.suite_number = self._create_column("suite_number", "TEXT", Nullable.NULL)
self.type = self._create_column("type", "TEXT", Nullable.NULL)
self.display_address = self._create_column("display_address", "TEXT", Nullable.NULL)
class TableLocationStreetAddresses(TableStreetAddresses):
location_mrid: Column = None
address_field: Column = None
def __init__(self):
super(TableLocationStreetAddresses, self).__init__()
self.location_mrid = self._create_column("location_mrid", "TEXT", Nullable.NOT_NULL)
self.address_field = self._create_column("address_field", "TEXT", Nullable.NOT_NULL)
def name(self) -> str:
return "location_street_addresses"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TableLocationStreetAddresses, self).unique_index_columns()
cols.append([self.location_mrid, self.address_field])
return cols
def non_unique_index_columns(self) -> List[List[Column]]:
cols = super(TableLocationStreetAddresses, self).non_unique_index_columns()
cols.append([self.location_mrid])
return cols
class TableLocationStreetAddressField(Enum):
mainAddress = 0
# secondaryAddress = 1
# noinspection PyAbstractClass
class TableOrganisationRoles(TableIdentifiedObjects):
organisation_mrid: Column = None
def __init__(self):
super(TableOrganisationRoles, self).__init__()
self.organisation_mrid = self._create_column("organisation_mrid", "TEXT", Nullable.NULL)
class TableOrganisations(TableIdentifiedObjects):
def name(self) -> str:
return "organisations"
class TablePositionPoints(SqliteTable):
location_mrid: Column = None
sequence_number: Column = None
x_position: Column = None
y_position: Column = None
def __init__(self):
super(TablePositionPoints, self).__init__()
self.location_mrid = self._create_column("location_mrid", "TEXT", Nullable.NOT_NULL)
self.sequence_number = self._create_column("sequence_number", "INTEGER", Nullable.NOT_NULL)
self.x_position = self._create_column("x_position", "NUMBER", Nullable.NOT_NULL)
self.y_position = self._create_column("y_position", "NUMBER", Nullable.NOT_NULL)
def name(self) -> str:
return "position_points"
def unique_index_columns(self) -> List[List[Column]]:
cols = super(TablePositionPoints, self).unique_index_columns()
cols.append([self.location_mrid, self.sequence_number])
return cols | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/tables/iec61968/common_tables.py | common_tables.py |
from typing import Callable
from zepben.evolve import BaseCIMReader, TableDiagrams, ResultSet, Diagram, DiagramStyle, OrientationKind, TableDiagramObjects, DiagramObject, \
TableDiagramObjectPoints, DiagramObjectPoint, DiagramService
__all__ = ["DiagramCIMReader"]
from zepben.evolve.database.sqlite.readers.base_cim_reader import DuplicateMRIDException
class DiagramCIMReader(BaseCIMReader):
_diagram_service: DiagramService
def __init__(self, diagram_service: DiagramService):
super().__init__(diagram_service)
# ************ IEC61970 DIAGRAM LAYOUT ************
def load_diagram(self, table: TableDiagrams, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
diagram = Diagram(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
diagram.diagram_style = DiagramStyle[rs.get_string(table.diagram_style.query_index)]
diagram.orientation_kind = OrientationKind[rs.get_string(table.orientation_kind.query_index)]
return self._load_identified_object(diagram, table, rs) and self._add_or_throw(diagram)
def load_diagram_object(self, table: TableDiagramObjects, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
diagram_object = DiagramObject(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
diagram = self._ensure_get(rs.get_string(table.diagram_mrid.query_index, None), Diagram)
if diagram is not None:
diagram.add_diagram_object(diagram_object)
diagram_object.identified_object_mrid = rs.get_string(table.identified_object_mrid.query_index, None)
diagram_object.style = rs.get_string(table.style.query_index, None)
diagram_object.rotation = rs.get_double(table.rotation.query_index)
if not self._load_identified_object(diagram_object, table, rs):
return False
# noinspection PyUnresolvedReferences
if self._base_service.add_diagram_object(diagram_object):
return True
else:
raise DuplicateMRIDException(
f"Failed to load {diagram_object}. Unable to add to service '{self._base_service.name}': duplicate MRID ({self._base_service.get(diagram_object.mrid)})"
)
def load_diagram_object_point(self, table: TableDiagramObjectPoints, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
diagram_object_mrid = set_last_mrid(rs.get_string(table.diagram_object_mrid.query_index))
sequence_number = rs.get_int(table.sequence_number.query_index)
set_last_mrid(f"{diagram_object_mrid}-point{sequence_number}")
# noinspection PyArgumentList
diagram_object_point = DiagramObjectPoint(
rs.get_double(table.x_position.query_index),
rs.get_double(table.y_position.query_index)
)
diagram_object = self._base_service.get(diagram_object_mrid, DiagramObject)
diagram_object.insert_point(diagram_object_point, sequence_number)
return True | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/readers/diagram_cim_reader.py | diagram_cim_reader.py |
import logging
from typing import Callable, Optional, Type, TypeVar
from zepben.evolve import BaseService, Document, TableDocuments, Organisation, TableOrganisations, TableNameTypes, NameType, TableNames, IdentifiedObject, \
OrganisationRole, TableOrganisationRoles, TableIdentifiedObjects, ResultSet
logger = logging.getLogger(__name__)
__all__ = ["BaseCIMReader"]
class DuplicateMRIDException(Exception):
pass
T = TypeVar("T", bound=IdentifiedObject)
class BaseCIMReader(object):
_base_service: BaseService
def __init__(self, base_service: BaseService):
self._base_service = base_service
# ************ IEC61968 COMMON ************
def _load_document(self, document: Document, table: TableDocuments, rs: ResultSet) -> bool:
document.title = rs.get_string(table.title.query_index, "")
document.created_date_time = rs.get_instant(table.created_date_time.query_index, None)
document.author_name = rs.get_string(table.author_name.query_index, "")
document.type = rs.get_string(table.type.query_index, "")
document.status = rs.get_string(table.status.query_index, "")
document.comment = rs.get_string(table.comment.query_index, "")
return self._load_identified_object(document, table, rs)
def load_organisation(self, table: TableOrganisations, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
organisation = Organisation(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_identified_object(organisation, table, rs) and self._add_or_throw(organisation)
def load_name_type(self, table: TableNameTypes, rs: ResultSet, set_last_name_type: Callable[[str], str]) -> bool:
# noinspection PyArgumentList
name_type = NameType(name=set_last_name_type(rs.get_string(table.name_.query_index)))
name_type.description = rs.get_string(table.description.query_index, None)
return self._add_or_throw_name_type(name_type)
def load_name(self, table: TableNames, rs: ResultSet, set_last_name: Callable[[str], str]) -> bool:
name_type_name = rs.get_string(table.name_type_name.query_index)
name_name = rs.get_string(table.name_.query_index)
set_last_name(f"{name_type_name}:{name_name}")
name_type = self._base_service.get_name_type(name_type_name)
# Because each service type loads all the name types, but not all services hold all identified objects, there can
# be records in the names table that only apply to certain services. We attempt to find the IdentifiedObject on this
# service and add a name for it if it exists, but ignore if it doesn't. Note that this can potentially lead to there being
# a name record that never gets used because that identified object doesn't exist in any service and currently we
# don't check or warn about that.
io = self._base_service.get(rs.get_string(table.identified_object_mrid.query_index), default=None)
if io is not None:
name = name_type.get_or_add_name(name_name, io)
io.add_name(name)
return True
def _load_organisation_role(self, organisation_role: OrganisationRole, table: TableOrganisationRoles, rs: ResultSet) -> bool:
organisation_role.organisation = self._ensure_get(rs.get_string(table.organisation_mrid.query_index, None), Organisation)
return self._load_identified_object(organisation_role, table, rs)
# ************ IEC61970 CORE ************
@staticmethod
def _load_identified_object(identified_object: IdentifiedObject, table: TableIdentifiedObjects, rs: ResultSet) -> bool:
identified_object.name = rs.get_string(table.name_.query_index, "")
identified_object.description = rs.get_string(table.description.query_index, "")
# Currently unused identified_object.num_diagram_objects = rs.get_int(table.num_diagram_objects.query_index)
return True
def _add_or_throw(self, identified_object: IdentifiedObject) -> bool:
if self._base_service.add(identified_object):
return True
else:
duplicate = self._base_service.get(identified_object.mrid)
raise DuplicateMRIDException(
f"Failed to load {identified_object}. " +
f"Unable to add to service '{self._base_service.name}': duplicate MRID ({duplicate})"
)
def _add_or_throw_name_type(self, name_type: NameType) -> bool:
if self._base_service.add_name_type(name_type):
return True
else:
raise DuplicateMRIDException(
f"Failed to load NameType {name_type.name}. " +
f"Unable to add to service '{self._base_service.name}': duplicate NameType)"
)
def _ensure_get(self, mrid: Optional[str], type_: Type[T] = IdentifiedObject) -> Optional[T]:
if (mrid is None) or (len(mrid) == 0):
return None
else:
return self._base_service.get(mrid, type_) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/readers/base_cim_reader.py | base_cim_reader.py |
import logging
from sqlite3 import Cursor
from typing import Callable, Type, TypeVar
from zepben.evolve import DatabaseTables, BaseCIMReader, TableNameTypes, TableNames, SqliteTable, ResultSet
logger = logging.getLogger(__name__)
__all__ = ["BaseServiceReader"]
TSqliteTable = TypeVar("TSqliteTable", bound=SqliteTable)
class BaseServiceReader(object):
"""
Base class for reading a service from the database.
"""
_get_cursor: Callable[[], Cursor]
_database_tables = DatabaseTables()
def __init__(self, get_cursor: Callable[[], Cursor]):
"""
:param get_cursor: Provider of cursors for the connection.
"""
self._get_cursor = get_cursor
def load_name_types(self, reader: BaseCIMReader) -> bool:
status = True
status = status and self._load_each(TableNameTypes, "name type", reader.load_name_type)
return status
def load_names(self, reader: BaseCIMReader) -> bool:
status = True
status = status and self._load_each(TableNames, "name", reader.load_name)
return status
def _load_each(
self,
table_type: Type[TSqliteTable],
description: str,
process_row: Callable[[TSqliteTable, ResultSet, Callable[[str], str]], bool]
) -> bool:
def process_rows(db_table: SqliteTable, results: ResultSet):
last_identifier = None
def set_last_identifier(identifier: str) -> str:
nonlocal last_identifier
last_identifier = identifier
return identifier
try:
count = 0
while results.next():
if process_row(db_table, results, set_last_identifier):
count = count + 1
return count
except Exception as e:
logger.error(f"Failed to load '{last_identifier}' from '{db_table.name()}': {str(e)}")
raise e
return self._load_table(table_type, description, process_rows)
def _load_table(
self,
table_type: Type[TSqliteTable],
description: str,
process_rows: Callable[[TSqliteTable, ResultSet], int]
) -> bool:
logger.info(f"Loading {description}...")
table = self._database_tables.get_table(table_type)
try:
cur = self._get_cursor()
cur.execute(table.select_sql())
count = process_rows(table, ResultSet(cur.fetchall()))
logger.info(f"Successfully loaded {count} {description}.")
return True
except Exception as e:
logger.error(f"Failed to read the {description} from '{table.name()}': {str(e)}", exc_info=e)
return False | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/readers/base_service_reader.py | base_service_reader.py |
from zepben.evolve import BaseServiceReader, TableCableInfo, TableOverheadWireInfo, TablePowerTransformerInfo, TableTransformerTankInfo, TableNoLoadTests, \
TableOpenCircuitTests, TableShortCircuitTests, TableShuntCompensatorInfo, TableTransformerEndInfo, TableLocations, TableOrganisations, TableAssetOwners, \
TablePoles, TableStreetlights, TableMeters, TableUsagePoints, TableOperationalRestrictions, TableBaseVoltages, TableConnectivityNodes, \
TableGeographicalRegions, TableSubGeographicalRegions, TableSubstations, TableSites, TablePerLengthSequenceImpedances, TableEquivalentBranches, \
TablePowerElectronicsConnection, TablePowerElectronicsConnectionPhases, TableBatteryUnit, TablePhotoVoltaicUnit, TablePowerElectronicsWindUnit, \
TableAcLineSegments, TableBreakers, TableLoadBreakSwitches, TableBusbarSections, TableDisconnectors, TableEnergyConsumers, TableEnergyConsumerPhases, \
TableEnergySources, TableEnergySourcePhases, TableFuses, TableJumpers, TableJunctions, TableLinearShuntCompensators, TablePowerTransformers, \
TableReclosers, TableTerminals, TableTransformerStarImpedance, TablePowerTransformerEnds, TableRatioTapChangers, TableFaultIndicators, TableFeeders, \
TableLoops, TableCircuits, TablePositionPoints, TableLocationStreetAddresses, TableAssetOrganisationRolesAssets, TableUsagePointsEndDevices, \
TableEquipmentUsagePoints, TableEquipmentOperationalRestrictions, TableEquipmentEquipmentContainers, TableCircuitsSubstations, TableCircuitsTerminals, \
TableLoopsSubstations, TableControls, TableRemoteControls, TableRemoteSources, TableAnalogs, TableAccumulators, TableDiscretes
from zepben.evolve.database.sqlite.readers.network_cim_reader import NetworkCIMReader
__all__ = ["NetworkServiceReader"]
class NetworkServiceReader(BaseServiceReader):
"""
Class for reading a `NetworkService` from the database.
"""
def load(self, reader: NetworkCIMReader) -> bool:
status = self.load_name_types(reader)
status = status and self._load_each(TableCableInfo, "cable info", reader.load_cable_info)
status = status and self._load_each(TableOverheadWireInfo, "overhead wire info", reader.load_overhead_wire_info)
status = status and self._load_each(TablePowerTransformerInfo, "power transformer info", reader.load_power_transformer_info)
status = status and self._load_each(TableTransformerTankInfo, "transformer tank info", reader.load_transformer_tank_info)
status = status and self._load_each(TableNoLoadTests, "no load tests", reader.load_no_load_test)
status = status and self._load_each(TableOpenCircuitTests, "open circuit tests", reader.load_open_circuit_test)
status = status and self._load_each(TableShortCircuitTests, "short circuit tests", reader.load_short_circuit_test)
status = status and self._load_each(TableShuntCompensatorInfo, "shunt compensator info", reader.load_shunt_compensator_info)
status = status and self._load_each(TableTransformerEndInfo, "transformer end info", reader.load_transformer_end_info)
status = status and self._load_each(TableLocations, "locations", reader.load_location)
status = status and self._load_each(TableOrganisations, "organisations", reader.load_organisation)
status = status and self._load_each(TableAssetOwners, "asset owners", reader.load_asset_owner)
status = status and self._load_each(TablePoles, "poles", reader.load_pole)
status = status and self._load_each(TableStreetlights, "streetlights", reader.load_streetlight)
status = status and self._load_each(TableMeters, "meters", reader.load_meter)
status = status and self._load_each(TableUsagePoints, "usage points", reader.load_usage_point)
status = status and self._load_each(TableOperationalRestrictions, "operational restrictions", reader.load_operational_restriction)
status = status and self._load_each(TableBaseVoltages, "base voltages", reader.load_base_voltage)
status = status and self._load_each(TableConnectivityNodes, "connectivity nodes", reader.load_connectivity_node)
status = status and self._load_each(TableGeographicalRegions, "geographical regions", reader.load_geographical_region)
status = status and self._load_each(TableSubGeographicalRegions, "sub-geographical regions", reader.load_sub_geographical_region)
status = status and self._load_each(TableSubstations, "substations", reader.load_substation)
status = status and self._load_each(TableSites, "sites", reader.load_site)
status = status and self._load_each(TablePerLengthSequenceImpedances, "per length sequence impedances", reader.load_per_length_sequence_impedance)
status = status and self._load_each(TableEquivalentBranches, "equivalent branches", reader.load_equivalent_branch)
status = status and self._load_each(TablePowerElectronicsConnection, "power electronics connection", reader.load_power_electronics_connection)
status = status and self._load_each(
TablePowerElectronicsConnectionPhases,
"power electronics connection phases",
reader.load_power_electronics_connection_phase
)
status = status and self._load_each(TableBatteryUnit, "battery unit", reader.load_battery_unit)
status = status and self._load_each(TablePhotoVoltaicUnit, "photo voltaic unit", reader.load_photo_voltaic_unit)
status = status and self._load_each(TablePowerElectronicsWindUnit, "power electronics wind unit", reader.load_power_electronics_wind_unit)
status = status and self._load_each(TableAcLineSegments, "AC line segments", reader.load_ac_line_segment)
status = status and self._load_each(TableBreakers, "breakers", reader.load_breaker)
status = status and self._load_each(TableLoadBreakSwitches, "load break switches", reader.load_load_break_switch)
status = status and self._load_each(TableBusbarSections, "busbar sections", reader.load_busbar_section)
status = status and self._load_each(TableDisconnectors, "disconnectors", reader.load_disconnector)
status = status and self._load_each(TableEnergyConsumers, "energy consumers", reader.load_energy_consumer)
status = status and self._load_each(TableEnergyConsumerPhases, "energy consumer phases", reader.load_energy_consumer_phase)
status = status and self._load_each(TableEnergySources, "energy sources", reader.load_energy_source)
status = status and self._load_each(TableEnergySourcePhases, "energy source phases", reader.load_energy_source_phase)
status = status and self._load_each(TableFuses, "fuses", reader.load_fuse)
status = status and self._load_each(TableJumpers, "jumpers", reader.load_jumper)
status = status and self._load_each(TableJunctions, "junctions", reader.load_junction)
status = status and self._load_each(TableLinearShuntCompensators, "linear shunt compensators", reader.load_linear_shunt_compensator)
status = status and self._load_each(TablePowerTransformers, "power transformers", reader.load_power_transformer)
status = status and self._load_each(TableReclosers, "reclosers", reader.load_recloser)
status = status and self._load_each(TableTerminals, "terminals", reader.load_terminal)
status = status and self._load_each(TableTransformerStarImpedance, "transformer star impedance", reader.load_transformer_star_impedance)
status = status and self._load_each(TablePowerTransformerEnds, "power transformer ends", reader.load_power_transformer_end)
status = status and self._load_each(TableRatioTapChangers, "ratio tap changers", reader.load_ratio_tap_changer)
status = status and self._load_each(TableFaultIndicators, "fault indicators", reader.load_fault_indicator)
status = status and self._load_each(TableFeeders, "feeders", reader.load_feeder)
status = status and self._load_each(TableLoops, "loops", reader.load_loop)
status = status and self._load_each(TableCircuits, "circuits", reader.load_circuit)
status = status and self._load_each(TablePositionPoints, "position points", reader.load_position_point)
status = status and self._load_each(TableLocationStreetAddresses, "location street addresses", reader.load_location_street_address)
status = status and self._load_each(
TableAssetOrganisationRolesAssets,
"asset organisation role to asset associations",
reader.load_asset_organisation_role_asset
)
status = status and self._load_each(TableUsagePointsEndDevices, "usage point to end device associations", reader.load_usage_point_end_device)
status = status and self._load_each(TableEquipmentUsagePoints, "equipment to usage point associations", reader.load_equipment_usage_point)
status = status and self._load_each(
TableEquipmentOperationalRestrictions,
"equipment to operational restriction associations",
reader.load_equipment_operational_restriction
)
status = status and self._load_each(
TableEquipmentEquipmentContainers,
"equipment to equipment container associations",
reader.load_equipment_equipment_container
)
status = status and self._load_each(TableCircuitsSubstations, "circuit to substation associations", reader.load_circuit_substation)
status = status and self._load_each(TableCircuitsTerminals, "circuit to terminal associations", reader.load_circuit_terminal)
status = status and self._load_each(TableLoopsSubstations, "loop to substation associations", reader.load_loop_substation)
status = status and self._load_each(TableControls, "controls", reader.load_control)
status = status and self._load_each(TableRemoteControls, "remote controls", reader.load_remote_control)
status = status and self._load_each(TableRemoteSources, "remote sources", reader.load_remote_source)
status = status and self._load_each(TableAnalogs, "analogs", reader.load_analog)
status = status and self._load_each(TableAccumulators, "accumulators", reader.load_accumulator)
status = status and self._load_each(TableDiscretes, "discretes", reader.load_discrete)
status = status and self.load_names(reader)
return status | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/readers/network_service_reader.py | network_service_reader.py |
from datetime import datetime
from typing import Any, Optional, Union, Type, TypeVar, List
__all__ = ["ResultSet"]
T = TypeVar("T")
class ResultSet:
"""
Wrapper class for records read from a database.
"""
# The values of this row
_rows: List[List[Any]]
# The index of the next row to process
_next_row_index: int = 0
# The current row being processed
_current_row: Optional[List[Any]] = None
def __init__(self, rows: List[List[Any]]):
self._rows = rows
def next(self) -> bool:
"""
Move to the next row.
:return: True if a new row was available, otherwise False.
"""
if self._next_row_index >= len(self._rows):
self._current_row = None
return False
self._current_row = self._rows[self._next_row_index]
self._next_row_index = self._next_row_index + 1
return True
def get_string(self, column_index: int, on_none: Union[Optional[str], Type[Exception]] = ValueError) -> Optional[str]:
"""
Get the value in the specified `column_index` as a string.
:param column_index: The column to read the value from. This uses 1 based indexes.
:param on_none: The value to use if a null is read from the database, or an exception to raise if a null value is not be supported.
:return: The string read from the column, or the `on_none` value if there was no value.
"""
if (column_index <= 0) or (column_index > len(self._current_row)):
raise IndexError
value = self._current_row[column_index - 1]
if value is None:
return self._value_or_raise(on_none)
elif isinstance(value, str):
return value
else:
raise ValueError
def get_int(self, column_index: int, on_none: Union[Optional[int], Type[Exception]] = ValueError) -> Optional[int]:
"""
Get the value in the specified `column_index` as an integer.
:param column_index: The column to read the value from. This uses 1 based indexes.
:param on_none: The value to use if a null is read from the database, or an exception to raise if a null value is not be supported.
:return: The integer read from the column, or the `on_none` value if there was no value.
"""
if (column_index <= 0) or (column_index > len(self._current_row)):
raise IndexError
value = self._current_row[column_index - 1]
if value is None:
return self._value_or_raise(on_none)
elif isinstance(value, int):
return value
else:
raise ValueError
def get_double(self, column_index: int, on_none: Union[Optional[float], Type[Exception]] = ValueError) -> Optional[float]:
"""
Get the value in the specified `column_index` as a float.
:param column_index: The column to read the value from. This uses 1 based indexes.
:param on_none: The value to use if a null is read from the database, or an exception to raise if a null value is not be supported.
:return: The float read from the column, or the `on_none` value if there was no value.
"""
if (column_index <= 0) or (column_index > len(self._current_row)):
raise IndexError
value = self._current_row[column_index - 1]
if value is None:
return self._value_or_raise(on_none)
elif isinstance(value, float) or isinstance(value, int):
return value
else:
raise ValueError
def get_boolean(self, column_index: int, on_none: Union[Optional[bool], Type[Exception]] = ValueError) -> Optional[bool]:
"""
Get the value in the specified `column_index` as a bool.
:param column_index: The column to read the value from. This uses 1 based indexes.
:param on_none: The value to use if a null is read from the database, or an exception to raise if a null value is not be supported.
:return: The bool read from the column, or the `on_none` value if there was no value.
"""
if (column_index <= 0) or (column_index > len(self._current_row)):
raise IndexError
value = self._current_row[column_index - 1]
if value is None:
return self._value_or_raise(on_none)
else:
return bool(value)
def get_instant(self, column_index: int, on_none: Union[Optional[datetime], Type[Exception]] = ValueError) -> Optional[datetime]:
"""
Get the value in the specified `column_index` as a datetime.
:param column_index: The column to read the value from. This uses 1 based indexes.
:param on_none: The value to use if a null is read from the database, or an exception to raise if a null value is not be supported.
:return: The datetime read from the column, or the `on_none` value if there was no value.
"""
value = self.get_string(column_index, None)
if value is None:
return self._value_or_raise(on_none)
else:
# TODO: JVM seems to use Z as TZ offset (for UTC+0?) while python uses +HH:mm format. Need to investigate here
return datetime.fromisoformat(value.rstrip('Z'))
@staticmethod
def _value_or_raise(on_none: Union[Optional[T], Type[Exception]]) -> T:
if type(on_none) is type and issubclass(on_none, Exception):
raise on_none
else:
return on_none | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/readers/result_set.py | result_set.py |
from typing import Callable
from zepben.evolve import BaseCIMReader, CustomerService, Agreement, TableAgreements, ResultSet, TableCustomers, Customer, CustomerKind, \
TableCustomerAgreements, CustomerAgreement, TablePricingStructures, PricingStructure, TableTariffs, Tariff, TableCustomerAgreementsPricingStructures, \
TablePricingStructuresTariffs
__all__ = ["CustomerCIMReader"]
class CustomerCIMReader(BaseCIMReader):
_customer_service: CustomerService
def __init__(self, customer_service: CustomerService):
super().__init__(customer_service)
self._customer_service = customer_service
# ************ IEC61968 COMMON ************
def _load_agreement(self, agreement: Agreement, table: TableAgreements, rs: ResultSet) -> bool:
return self._load_document(agreement, table, rs)
# ************ IEC61968 CUSTOMERS ************
def load_customer(self, table: TableCustomers, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
customer = Customer(mrid=set_last_mrid(rs.get_string(table.mrid.query_index, ValueError)))
customer.kind = CustomerKind[rs.get_string(table.kind.query_index)]
# Currently unused customer.num_end_devices = rs.get_int(table.num_end_devices.query_index, None)
return self._load_organisation_role(customer, table, rs) and self._add_or_throw(customer)
def load_customer_agreement(self, table: TableCustomerAgreements, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
customer_agreement = CustomerAgreement(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
customer_agreement.customer = self._ensure_get(rs.get_string(table.customer_mrid.query_index, None), Customer)
if customer_agreement.customer is not None:
customer_agreement.customer.add_agreement(customer_agreement)
return self._load_agreement(customer_agreement, table, rs) and self._add_or_throw(customer_agreement)
def load_pricing_structure(self, table: TablePricingStructures, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
pricing_structure = PricingStructure(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_document(pricing_structure, table, rs) and self._add_or_throw(pricing_structure)
def load_tariff(self, table: TableTariffs, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
tariff = Tariff(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_document(tariff, table, rs) and self._add_or_throw(tariff)
# ************ ASSOCIATIONS ************
def load_customer_agreement_pricing_structure(
self,
table: TableCustomerAgreementsPricingStructures,
rs: ResultSet,
set_last_mrid: Callable[[str], str]
) -> bool:
customer_agreement_mrid = set_last_mrid(rs.get_string(table.customer_agreement_mrid.query_index))
set_last_mrid(f"{customer_agreement_mrid}-to-UNKNOWN")
pricing_structure_mrid = rs.get_string(table.pricing_structure_mrid.query_index)
set_last_mrid(f"{customer_agreement_mrid}-to-{pricing_structure_mrid}")
customer_agreement = self._ensure_get(customer_agreement_mrid, CustomerAgreement)
pricing_structure = self._ensure_get(pricing_structure_mrid, PricingStructure)
if (customer_agreement is not None) and (pricing_structure is not None):
customer_agreement.add_pricing_structure(pricing_structure)
return True
def load_pricing_structure_tariff(self, table: TablePricingStructuresTariffs, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
pricing_structure_mrid = set_last_mrid(rs.get_string(table.pricing_structure_mrid.query_index))
set_last_mrid(f"{pricing_structure_mrid}-to-UNKNOWN")
tariff_mrid = rs.get_string(table.tariff_mrid.query_index)
set_last_mrid(f"{pricing_structure_mrid}-to-{tariff_mrid}")
pricing_structure = self._ensure_get(pricing_structure_mrid, PricingStructure)
tariff = self._ensure_get(tariff_mrid, Tariff)
if (pricing_structure is not None) and (tariff is not None):
pricing_structure.add_tariff(tariff)
return True | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/readers/customer_cim_reader.py | customer_cim_reader.py |
from typing import Callable, Optional
from zepben.evolve import BaseCIMReader, TableCableInfo, ResultSet, CableInfo, TableNoLoadTests, NoLoadTest, TableOpenCircuitTests, \
OpenCircuitTest, TableOverheadWireInfo, OverheadWireInfo, TablePowerTransformerInfo, PowerTransformerInfo, TableShortCircuitTests, ShortCircuitTest, \
TableShuntCompensatorInfo, ShuntCompensatorInfo, TableTransformerEndInfo, TransformerEndInfo, WindingConnection, TransformerTankInfo, \
TableTransformerTankInfo, TransformerTest, TableTransformerTest, WireInfo, TableWireInfo, WireMaterialKind, Asset, TableAssets, Location, AssetContainer, \
TableAssetContainers, AssetInfo, TableAssetInfo, AssetOrganisationRole, TableAssetOrganisationRoles, Structure, TableStructures, TableAssetOwners, \
AssetOwner, TablePoles, Pole, TableStreetlights, Streetlight, StreetlightLampKind, TableLocations, TableLocationStreetAddresses, \
TableLocationStreetAddressField, TablePositionPoints, PositionPoint, TableStreetAddresses, StreetAddress, TableTownDetails, TownDetail, StreetDetail, \
TransformerConstructionKind, TransformerFunctionKind, EndDevice, TableEndDevices, TableMeters, Meter, TableUsagePoints, \
UsagePoint, TableOperationalRestrictions, OperationalRestriction, AuxiliaryEquipment, TableAuxiliaryEquipment, Terminal, TableFaultIndicators, \
FaultIndicator, AcDcTerminal, TableAcDcTerminals, TableBaseVoltages, BaseVoltage, ConductingEquipment, TableConductingEquipment, TableConnectivityNodes, \
ConnectivityNode, ConnectivityNodeContainer, TableConnectivityNodeContainers, Equipment, TableEquipment, EquipmentContainer, TableEquipmentContainers, \
TableFeeders, Feeder, Substation, GeographicalRegion, TableGeographicalRegions, PowerSystemResource, TablePowerSystemResources, TableSites, Site, \
TableSubGeographicalRegions, SubGeographicalRegion, TableSubstations, TableTerminals, PhaseCode, TableEquivalentBranches, EquivalentBranch, \
EquivalentEquipment, TableEquivalentEquipment, TableAccumulators, Accumulator, TableAnalogs, Analog, TableControls, Control, TableDiscretes, Discrete, \
IoPoint, TableIoPoints, Measurement, TableMeasurements, RemoteSource, UnitSymbol, TableRemoteControls, RemoteControl, RemotePoint, TableRemotePoints, \
TableRemoteSources, TableBatteryUnit, BatteryUnit, BatteryStateKind, TablePhotoVoltaicUnit, PhotoVoltaicUnit, PowerElectronicsUnit, \
TablePowerElectronicsUnit, PowerElectronicsConnection, TablePowerElectronicsWindUnit, PowerElectronicsWindUnit, TableAcLineSegments, AcLineSegment, \
PerLengthSequenceImpedance, TableBreakers, Breaker, TableLoadBreakSwitches, LoadBreakSwitch, TableBusbarSections, BusbarSection, Conductor, \
TableConductors, Connector, TableConnectors, TableDisconnectors, Disconnector, EnergyConnection, TableEnergyConnections, TableEnergyConsumers, \
EnergyConsumer, PhaseShuntConnectionKind, TableEnergyConsumerPhases, EnergyConsumerPhase, SinglePhaseKind, TableEnergySources, EnergySource, \
TableEnergySourcePhases, EnergySourcePhase, TableFuses, Fuse, TableJumpers, Jumper, TableJunctions, Junction, Line, TableLines, \
TableLinearShuntCompensators, LinearShuntCompensator, PerLengthImpedance, TablePerLengthImpedances, PerLengthLineParameter, TablePerLengthLineParameters, \
TablePerLengthSequenceImpedances, TablePowerElectronicsConnection, TablePowerElectronicsConnectionPhases, PowerElectronicsConnectionPhase, \
TablePowerTransformers, PowerTransformer, VectorGroup, TablePowerTransformerEnds, PowerTransformerEnd, ProtectedSwitch, TableProtectedSwitches, \
TableRatioTapChangers, RatioTapChanger, TransformerEnd, TableReclosers, Recloser, RegulatingCondEq, TableRegulatingCondEq, ShuntCompensator, \
TableShuntCompensators, Switch, TableSwitches, TapChanger, TableTapChangers, TableTransformerEnds, TransformerStarImpedance, \
TableTransformerStarImpedance, TableCircuits, Circuit, Loop, TableLoops, TableAssetOrganisationRolesAssets, TableEquipmentEquipmentContainers, \
TableEquipmentOperationalRestrictions, TableEquipmentUsagePoints, TableUsagePointsEndDevices, TableCircuitsSubstations, TableCircuitsTerminals, \
TableLoopsSubstations, LoopSubstationRelationship
__all__ = ["NetworkCIMReader"]
class NetworkCIMReader(BaseCIMReader):
# ************ IEC61968 ASSET INFO ************
def load_cable_info(self, table: TableCableInfo, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
cable_info = CableInfo(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_wire_info(cable_info, table, rs) and self._add_or_throw(cable_info)
def load_no_load_test(self, table: TableNoLoadTests, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
no_load_test = NoLoadTest(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
no_load_test.energised_end_voltage = rs.get_int(table.energised_end_voltage.query_index, None)
no_load_test.exciting_current = rs.get_double(table.exciting_current.query_index, None)
no_load_test.exciting_current_zero = rs.get_double(table.exciting_current_zero.query_index, None)
no_load_test.loss = rs.get_int(table.loss.query_index, None)
no_load_test.loss_zero = rs.get_int(table.loss_zero.query_index, None)
return self._load_transformer_test(no_load_test, table, rs) and self._add_or_throw(no_load_test)
def load_open_circuit_test(self, table: TableOpenCircuitTests, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
open_circuit_test = OpenCircuitTest(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
open_circuit_test.energised_end_step = rs.get_int(table.energised_end_step.query_index, None)
open_circuit_test.energised_end_voltage = rs.get_int(table.energised_end_voltage.query_index, None)
open_circuit_test.open_end_step = rs.get_int(table.open_end_step.query_index, None)
open_circuit_test.open_end_voltage = rs.get_int(table.open_end_voltage.query_index, None)
open_circuit_test.phase_shift = rs.get_double(table.phase_shift.query_index, None)
return self._load_transformer_test(open_circuit_test, table, rs) and self._add_or_throw(open_circuit_test)
def load_overhead_wire_info(self, table: TableOverheadWireInfo, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
overhead_wire_info = OverheadWireInfo(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_wire_info(overhead_wire_info, table, rs) and self._add_or_throw(overhead_wire_info)
def load_power_transformer_info(self, table: TablePowerTransformerInfo, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
power_transformer_info = PowerTransformerInfo(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_asset_info(power_transformer_info, table, rs) and self._add_or_throw(power_transformer_info)
def load_short_circuit_test(self, table: TableShortCircuitTests, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
short_circuit_test = ShortCircuitTest(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
short_circuit_test.current = rs.get_double(table.current.query_index, None)
short_circuit_test.energised_end_step = rs.get_int(table.energised_end_step.query_index, None)
short_circuit_test.grounded_end_step = rs.get_int(table.grounded_end_step.query_index, None)
short_circuit_test.leakage_impedance = rs.get_double(table.leakage_impedance.query_index, None)
short_circuit_test.leakage_impedance_zero = rs.get_double(table.leakage_impedance_zero.query_index, None)
short_circuit_test.loss = rs.get_int(table.loss.query_index, None)
short_circuit_test.loss_zero = rs.get_int(table.loss_zero.query_index, None)
short_circuit_test.power = rs.get_int(table.power.query_index, None)
short_circuit_test.voltage = rs.get_double(table.voltage.query_index, None)
short_circuit_test.voltage_ohmic_part = rs.get_double(table.voltage_ohmic_part.query_index, None)
return self._load_transformer_test(short_circuit_test, table, rs) and self._add_or_throw(short_circuit_test)
def load_shunt_compensator_info(self, table: TableShuntCompensatorInfo, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
shunt_compensator_info = ShuntCompensatorInfo(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
shunt_compensator_info.max_power_loss = rs.get_int(table.max_power_loss.query_index, None)
shunt_compensator_info.rated_current = rs.get_int(table.rated_current.query_index, None)
shunt_compensator_info.rated_reactive_power = rs.get_int(table.rated_reactive_power.query_index, None)
shunt_compensator_info.rated_voltage = rs.get_int(table.rated_voltage.query_index, None)
return self._load_asset_info(shunt_compensator_info, table, rs) and self._add_or_throw(shunt_compensator_info)
def load_transformer_end_info(self, table: TableTransformerEndInfo, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
transformer_end_info = TransformerEndInfo(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
transformer_end_info.connection_kind = WindingConnection[rs.get_string(table.connection_kind.query_index)]
transformer_end_info.emergency_s = rs.get_int(table.emergency_s.query_index, None)
transformer_end_info.end_number = rs.get_int(table.end_number.query_index)
transformer_end_info.insulation_u = rs.get_int(table.insulation_u.query_index, None)
transformer_end_info.phase_angle_clock = rs.get_int(table.phase_angle_clock.query_index, None)
transformer_end_info.r = rs.get_double(table.r.query_index, None)
transformer_end_info.rated_s = rs.get_int(table.rated_s.query_index, None)
transformer_end_info.rated_u = rs.get_int(table.rated_u.query_index, None)
transformer_end_info.short_term_s = rs.get_int(table.short_term_s.query_index, None)
transformer_end_info.transformer_tank_info = self._ensure_get(rs.get_string(table.transformer_tank_info_mrid.query_index, None), TransformerTankInfo)
transformer_end_info.energised_end_no_load_tests = self._ensure_get(rs.get_string(table.energised_end_no_load_tests.query_index, None), NoLoadTest)
transformer_end_info.energised_end_short_circuit_tests = self._ensure_get(rs.get_string(table.energised_end_short_circuit_tests.query_index, None),
ShortCircuitTest)
transformer_end_info.grounded_end_short_circuit_tests = self._ensure_get(rs.get_string(table.grounded_end_short_circuit_tests.query_index, None),
ShortCircuitTest)
transformer_end_info.open_end_open_circuit_tests = self._ensure_get(rs.get_string(table.open_end_open_circuit_tests.query_index, None), OpenCircuitTest)
transformer_end_info.energised_end_open_circuit_tests = self._ensure_get(rs.get_string(table.energised_end_open_circuit_tests.query_index, None),
OpenCircuitTest)
if transformer_end_info.transformer_tank_info is not None:
transformer_end_info.transformer_tank_info.add_transformer_end_info(transformer_end_info)
return self._load_asset_info(transformer_end_info, table, rs) and self._add_or_throw(transformer_end_info)
def load_transformer_tank_info(self, table: TableTransformerTankInfo, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
transformer_tank_info = TransformerTankInfo(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
transformer_tank_info.power_transformer_info = self._ensure_get(rs.get_string(table.power_transformer_info_mrid.query_index, None),
PowerTransformerInfo)
if transformer_tank_info.power_transformer_info is not None:
transformer_tank_info.power_transformer_info.add_transformer_tank_info(transformer_tank_info)
return self._load_asset_info(transformer_tank_info, table, rs) and self._add_or_throw(transformer_tank_info)
def _load_transformer_test(self, transformer_test: TransformerTest, table: TableTransformerTest, rs: ResultSet) -> bool:
transformer_test.base_power = rs.get_int(table.base_power.query_index, None)
transformer_test.temperature = rs.get_double(table.temperature.query_index, None)
return self._load_identified_object(transformer_test, table, rs)
def _load_wire_info(self, wire_info: WireInfo, table: TableWireInfo, rs: ResultSet) -> bool:
wire_info.rated_current = rs.get_int(table.rated_current.query_index, None)
wire_info.material = WireMaterialKind[rs.get_string(table.material.query_index)]
return self._load_asset_info(wire_info, table, rs)
# ************ IEC61968 ASSETS ************
def _load_asset(self, asset: Asset, table: TableAssets, rs: ResultSet) -> bool:
asset.location = self._ensure_get(rs.get_string(table.location_mrid.query_index, None), Location)
return self._load_identified_object(asset, table, rs)
def _load_asset_container(self, asset_container: AssetContainer, table: TableAssetContainers, rs: ResultSet) -> bool:
return self._load_asset(asset_container, table, rs)
def _load_asset_info(self, asset_info: AssetInfo, table: TableAssetInfo, rs: ResultSet) -> bool:
return self._load_identified_object(asset_info, table, rs)
def _load_asset_organisation_role(self, asset_organisation_role: AssetOrganisationRole, table: TableAssetOrganisationRoles, rs: ResultSet) -> bool:
return self._load_organisation_role(asset_organisation_role, table, rs)
def _load_structure(self, structure: Structure, table: TableStructures, rs: ResultSet) -> bool:
return self._load_asset_container(structure, table, rs)
def load_asset_owner(self, table: TableAssetOwners, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
asset_owner = AssetOwner(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_asset_organisation_role(asset_owner, table, rs) and self._add_or_throw(asset_owner)
def load_pole(self, table: TablePoles, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
pole = Pole(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
pole.classification = rs.get_string(table.classification.query_index, "")
return self._load_structure(pole, table, rs) and self._add_or_throw(pole)
def load_streetlight(self, table: TableStreetlights, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
streetlight = Streetlight(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
streetlight.lamp_kind = StreetlightLampKind[rs.get_string(table.lamp_kind.query_index)]
streetlight.light_rating = rs.get_int(table.light_rating.query_index, None)
streetlight.pole = self._ensure_get(rs.get_string(table.pole_mrid.query_index, None), Pole)
if streetlight.pole is not None:
streetlight.pole.add_streetlight(streetlight)
return self._load_asset(streetlight, table, rs) and self._add_or_throw(streetlight)
# ************ IEC61968 COMMON ************
def load_location(self, table: TableLocations, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
location = Location(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_identified_object(location, table, rs) and self._add_or_throw(location)
def load_location_street_address(self, table: TableLocationStreetAddresses, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
location_mrid = set_last_mrid(rs.get_string(table.location_mrid.query_index))
field = TableLocationStreetAddressField[rs.get_string(table.address_field.query_index)]
set_last_mrid(f"{location_mrid}-to-{field}")
location = self._base_service.get(location_mrid, Location)
if field == TableLocationStreetAddressField.mainAddress:
location.main_address = self._load_street_address(table, rs)
return True
def load_position_point(self, table: TablePositionPoints, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
location_mrid = set_last_mrid(rs.get_string(table.location_mrid.query_index))
sequence_number = rs.get_int(table.sequence_number.query_index)
set_last_mrid(f"{location_mrid}-point{sequence_number}")
location = self._base_service.get(location_mrid, Location)
# noinspection PyArgumentList
position_point = PositionPoint(
rs.get_double(table.x_position.query_index),
rs.get_double(table.y_position.query_index)
)
location.insert_point(position_point, sequence_number)
return True
def _load_street_address(self, table: TableStreetAddresses, rs: ResultSet) -> StreetAddress:
# noinspection PyArgumentList
return StreetAddress(
rs.get_string(table.postal_code.query_index, ""),
self._load_town_detail(table, rs),
rs.get_string(table.po_box.query_index, ""),
self._load_street_detail(table, rs)
)
@staticmethod
def _load_street_detail(table: TableStreetAddresses, rs: ResultSet) -> Optional[StreetDetail]:
# noinspection PyArgumentList
street_detail = StreetDetail(
rs.get_string(table.building_name.query_index, ""),
rs.get_string(table.floor_identification.query_index, ""),
rs.get_string(table.street_name.query_index, ""),
rs.get_string(table.number.query_index, ""),
rs.get_string(table.suite_number.query_index, ""),
rs.get_string(table.type.query_index, ""),
rs.get_string(table.display_address.query_index, "")
)
return None if street_detail.all_fields_empty() else street_detail
@staticmethod
def _load_town_detail(table: TableTownDetails, rs: ResultSet) -> Optional[TownDetail]:
# noinspection PyArgumentList
town_detail = TownDetail(
rs.get_string(table.town_name.query_index, ""),
rs.get_string(table.state_or_province.query_index, "")
)
return None if town_detail.all_fields_null_or_empty() else town_detail
# ************ IEC61968 METERING ************
def _load_end_device(self, end_device: EndDevice, table: TableEndDevices, rs: ResultSet) -> bool:
end_device.customer_mrid = rs.get_string(table.customer_mrid.query_index, None)
end_device.service_location = self._ensure_get(rs.get_string(table.service_location_mrid.query_index, None), Location)
return self._load_asset_container(end_device, table, rs)
def load_meter(self, table: TableMeters, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
meter = Meter(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_end_device(meter, table, rs) and self._add_or_throw(meter)
def load_usage_point(self, table: TableUsagePoints, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
usage_point = UsagePoint(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
usage_point.usage_point_location = self._ensure_get(rs.get_string(table.location_mrid.query_index, None), Location)
usage_point.is_virtual = rs.get_boolean(table.is_virtual.query_index)
usage_point.connection_category = rs.get_string(table.connection_category.query_index, None)
return self._load_identified_object(usage_point, table, rs) and self._add_or_throw(usage_point)
# ************ IEC61968 OPERATIONS ************
def load_operational_restriction(self, table: TableOperationalRestrictions, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
operational_restriction = OperationalRestriction(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_document(operational_restriction, table, rs) and self._add_or_throw(operational_restriction)
# ************ IEC61970 BASE AUXILIARY EQUIPMENT ************
def _load_auxiliary_equipment(self, auxiliary_equipment: AuxiliaryEquipment, table: TableAuxiliaryEquipment, rs: ResultSet) -> bool:
auxiliary_equipment.terminal = self._ensure_get(rs.get_string(table.terminal_mrid.query_index, None), Terminal)
return self._load_equipment(auxiliary_equipment, table, rs)
def load_fault_indicator(self, table: TableFaultIndicators, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
fault_indicator = FaultIndicator(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_auxiliary_equipment(fault_indicator, table, rs) and self._add_or_throw(fault_indicator)
# ************ IEC61970 BASE CORE ************
def _load_ac_dc_terminal(self, ac_dc_terminal: AcDcTerminal, table: TableAcDcTerminals, rs: ResultSet) -> bool:
return self._load_identified_object(ac_dc_terminal, table, rs)
def load_base_voltage(self, table: TableBaseVoltages, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
base_voltage = BaseVoltage(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
base_voltage.nominal_voltage = rs.get_int(table.nominal_voltage.query_index)
return self._load_identified_object(base_voltage, table, rs) and self._add_or_throw(base_voltage)
def _load_conducting_equipment(self, conducting_equipment: ConductingEquipment, table: TableConductingEquipment, rs: ResultSet) -> bool:
conducting_equipment.base_voltage = self._ensure_get(rs.get_string(table.base_voltage_mrid.query_index, None), BaseVoltage)
return self._load_equipment(conducting_equipment, table, rs)
def load_connectivity_node(self, table: TableConnectivityNodes, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
connectivity_node = ConnectivityNode(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_identified_object(connectivity_node, table, rs) and self._add_or_throw(connectivity_node)
def _load_connectivity_node_container(
self,
connectivity_node_container: ConnectivityNodeContainer,
table: TableConnectivityNodeContainers,
rs: ResultSet
) -> bool:
return self._load_power_system_resource(connectivity_node_container, table, rs)
def _load_equipment(self, equipment: Equipment, table: TableEquipment, rs: ResultSet) -> bool:
equipment.normally_in_service = rs.get_boolean(table.normally_in_service.query_index)
equipment.in_service = rs.get_boolean(table.in_service.query_index)
return self._load_power_system_resource(equipment, table, rs)
def _load_equipment_container(self, equipment_container: EquipmentContainer, table: TableEquipmentContainers, rs: ResultSet) -> bool:
return self._load_connectivity_node_container(equipment_container, table, rs)
def load_feeder(self, table: TableFeeders, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
feeder = Feeder(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
feeder.normal_head_terminal = self._ensure_get(rs.get_string(table.normal_head_terminal_mrid.query_index, None), Terminal)
feeder.normal_energizing_substation = self._ensure_get(rs.get_string(table.normal_energizing_substation_mrid.query_index, None), Substation)
if feeder.normal_energizing_substation is not None:
feeder.normal_energizing_substation.add_feeder(feeder)
return self._load_equipment_container(feeder, table, rs) and self._add_or_throw(feeder)
def load_geographical_region(self, table: TableGeographicalRegions, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
geographical_region = GeographicalRegion(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_identified_object(geographical_region, table, rs) and self._add_or_throw(geographical_region)
def _load_power_system_resource(self, power_system_resource: PowerSystemResource, table: TablePowerSystemResources, rs: ResultSet) -> bool:
power_system_resource.location = self._ensure_get(rs.get_string(table.location_mrid.query_index, None), Location)
# Currently unused power_system_resource.num_controls = rs.get_int(table.num_controls.query_index)
return self._load_identified_object(power_system_resource, table, rs)
def load_site(self, table: TableSites, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
site = Site(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_equipment_container(site, table, rs) and self._add_or_throw(site)
def load_sub_geographical_region(self, table: TableSubGeographicalRegions, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
sub_geographical_region = SubGeographicalRegion(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
sub_geographical_region.geographical_region = self._ensure_get(rs.get_string(table.geographical_region_mrid.query_index, None), GeographicalRegion)
if sub_geographical_region.geographical_region is not None:
sub_geographical_region.geographical_region.add_sub_geographical_region(sub_geographical_region)
return self._load_identified_object(sub_geographical_region, table, rs) and self._add_or_throw(sub_geographical_region)
def load_substation(self, table: TableSubstations, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
substation = Substation(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
substation.sub_geographical_region = self._ensure_get(rs.get_string(table.sub_geographical_region_mrid.query_index, None), SubGeographicalRegion)
if substation.sub_geographical_region is not None:
substation.sub_geographical_region.add_substation(substation)
return self._load_equipment_container(substation, table, rs) and self._add_or_throw(substation)
def load_terminal(self, table: TableTerminals, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
terminal = Terminal(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
terminal.sequence_number = rs.get_int(table.sequence_number.query_index)
terminal.conducting_equipment = self._ensure_get(rs.get_string(table.conducting_equipment_mrid.query_index, None), ConductingEquipment)
if terminal.conducting_equipment is not None:
terminal.conducting_equipment.add_terminal(terminal)
terminal.phases = PhaseCode[rs.get_string(table.phases.query_index)]
# noinspection PyUnresolvedReferences
self._base_service.connect_by_mrid(terminal, rs.get_string(table.connectivity_node_mrid.query_index, None))
return self._load_ac_dc_terminal(terminal, table, rs) and self._add_or_throw(terminal)
# ************ IEC61970 BASE EQUIVALENTS ************
def load_equivalent_branch(self, table: TableEquivalentBranches, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
equivalent_branch = EquivalentBranch(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
equivalent_branch.negative_r12 = rs.get_double(table.negative_r12.query_index, None)
equivalent_branch.negative_r21 = rs.get_double(table.negative_r21.query_index, None)
equivalent_branch.negative_x12 = rs.get_double(table.negative_x12.query_index, None)
equivalent_branch.negative_x21 = rs.get_double(table.negative_x21.query_index, None)
equivalent_branch.positive_r12 = rs.get_double(table.positive_r12.query_index, None)
equivalent_branch.positive_r21 = rs.get_double(table.positive_r21.query_index, None)
equivalent_branch.positive_x12 = rs.get_double(table.positive_x12.query_index, None)
equivalent_branch.positive_x21 = rs.get_double(table.positive_x21.query_index, None)
equivalent_branch.r = rs.get_double(table.r.query_index, None)
equivalent_branch.r21 = rs.get_double(table.r21.query_index, None)
equivalent_branch.x = rs.get_double(table.x.query_index, None)
equivalent_branch.x21 = rs.get_double(table.x21.query_index, None)
equivalent_branch.zero_r12 = rs.get_double(table.zero_r12.query_index, None)
equivalent_branch.zero_r21 = rs.get_double(table.zero_r21.query_index, None)
equivalent_branch.zero_x12 = rs.get_double(table.zero_x12.query_index, None)
equivalent_branch.zero_x21 = rs.get_double(table.zero_x21.query_index, None)
return self._load_equivalent_equipment(equivalent_branch, table, rs) and self._add_or_throw(equivalent_branch)
def _load_equivalent_equipment(self, equivalent_equipment: EquivalentEquipment, table: TableEquivalentEquipment, rs: ResultSet) -> bool:
return self._load_conducting_equipment(equivalent_equipment, table, rs)
# ************ IEC61970 BASE MEAS ************
def load_accumulator(self, table: TableAccumulators, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
meas = Accumulator(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_measurement(meas, table, rs) and self._add_or_throw(meas)
def load_analog(self, table: TableAnalogs, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
meas = Analog(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
meas.positive_flow_in = rs.get_boolean(table.positive_flow_in.query_index)
return self._load_measurement(meas, table, rs) and self._add_or_throw(meas)
def load_control(self, table: TableControls, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
control = Control(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
control.power_system_resource_mrid = rs.get_string(table.power_system_resource_mrid.query_index, None)
return self._load_io_point(control, table, rs) and self._add_or_throw(control)
def load_discrete(self, table: TableDiscretes, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
meas = Discrete(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_measurement(meas, table, rs) and self._add_or_throw(meas)
def _load_io_point(self, io_point: IoPoint, table: TableIoPoints, rs: ResultSet) -> bool:
return self._load_identified_object(io_point, table, rs)
def _load_measurement(self, measurement: Measurement, table: TableMeasurements, rs: ResultSet) -> bool:
measurement.power_system_resource_mrid = rs.get_string(table.power_system_resource_mrid.query_index, None)
measurement.remote_source = self._ensure_get(rs.get_string(table.remote_source_mrid.query_index, None), RemoteSource)
if measurement.remote_source is not None:
measurement.remote_source.measurement = measurement
measurement.terminal_mrid = rs.get_string(table.terminal_mrid.query_index, None)
measurement.phases = PhaseCode[rs.get_string(table.phases.query_index)]
measurement.unit_symbol = UnitSymbol[rs.get_string(table.unit_symbol.query_index)]
return self._load_identified_object(measurement, table, rs)
# ************ IEC61970 BASE SCADA ************
def load_remote_control(self, table: TableRemoteControls, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
remote_control = RemoteControl(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
remote_control.control = self._ensure_get(rs.get_string(table.control_mrid.query_index, None), Control)
if remote_control.control is not None:
remote_control.control.remote_control = remote_control
return self._load_remote_point(remote_control, table, rs) and self._add_or_throw(remote_control)
def _load_remote_point(self, remote_point: RemotePoint, table: TableRemotePoints, rs: ResultSet) -> bool:
return self._load_identified_object(remote_point, table, rs)
def load_remote_source(self, table: TableRemoteSources, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
remote_source = RemoteSource(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_remote_point(remote_source, table, rs) and self._add_or_throw(remote_source)
# ************ IEC61970 BASE WIRES GENERATION PRODUCTION ************
def load_battery_unit(self, table: TableBatteryUnit, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
battery_unit = BatteryUnit(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
battery_unit.battery_state = BatteryStateKind[rs.get_string(table.battery_state.query_index)]
battery_unit.rated_e = rs.get_int(table.rated_e.query_index, None)
battery_unit.stored_e = rs.get_int(table.stored_e.query_index, None)
return self._load_power_electronics_unit(battery_unit, table, rs) and self._add_or_throw(battery_unit)
def load_photo_voltaic_unit(self, table: TablePhotoVoltaicUnit, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
photo_voltaic_unit = PhotoVoltaicUnit(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_power_electronics_unit(photo_voltaic_unit, table, rs) and self._add_or_throw(photo_voltaic_unit)
def _load_power_electronics_unit(self, power_electronics_unit: PowerElectronicsUnit, table: TablePowerElectronicsUnit, rs: ResultSet) -> bool:
power_electronics_unit.power_electronics_connection = self._ensure_get(
rs.get_string(table.power_electronics_connection_mrid.query_index, None),
PowerElectronicsConnection
)
if power_electronics_unit.power_electronics_connection is not None:
power_electronics_unit.power_electronics_connection.add_unit(power_electronics_unit)
power_electronics_unit.max_p = rs.get_int(table.max_p.query_index, None)
power_electronics_unit.min_p = rs.get_int(table.min_p.query_index, None)
return self._load_equipment(power_electronics_unit, table, rs)
def load_power_electronics_wind_unit(self, table: TablePowerElectronicsWindUnit, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
power_electronics_wind_unit = PowerElectronicsWindUnit(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_power_electronics_unit(power_electronics_wind_unit, table, rs) and self._add_or_throw(power_electronics_wind_unit)
# ************ IEC61970 BASE WIRES ************
def load_ac_line_segment(self, table: TableAcLineSegments, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
ac_line_segment = AcLineSegment(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
ac_line_segment.per_length_sequence_impedance = self._ensure_get(
rs.get_string(table.per_length_sequence_impedance_mrid.query_index, None),
PerLengthSequenceImpedance
)
return self._load_conductor(ac_line_segment, table, rs) and self._add_or_throw(ac_line_segment)
def load_breaker(self, table: TableBreakers, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
breaker = Breaker(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_protected_switch(breaker, table, rs) and self._add_or_throw(breaker)
def load_load_break_switch(self, table: TableLoadBreakSwitches, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
load_break_switch = LoadBreakSwitch(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_protected_switch(load_break_switch, table, rs) and self._add_or_throw(load_break_switch)
def load_busbar_section(self, table: TableBusbarSections, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
busbar_section = BusbarSection(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_connector(busbar_section, table, rs) and self._add_or_throw(busbar_section)
def _load_conductor(self, conductor: Conductor, table: TableConductors, rs: ResultSet) -> bool:
conductor.length = rs.get_double(table.length.query_index, None)
conductor.asset_info = self._ensure_get(rs.get_string(table.wire_info_mrid.query_index, None), WireInfo)
return self._load_conducting_equipment(conductor, table, rs)
def _load_connector(self, connector: Connector, table: TableConnectors, rs: ResultSet) -> bool:
return self._load_conducting_equipment(connector, table, rs)
def load_disconnector(self, table: TableDisconnectors, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
disconnector = Disconnector(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_switch(disconnector, table, rs) and self._add_or_throw(disconnector)
def _load_energy_connection(self, energy_connection: EnergyConnection, table: TableEnergyConnections, rs: ResultSet) -> bool:
return self._load_conducting_equipment(energy_connection, table, rs)
def load_energy_consumer(self, table: TableEnergyConsumers, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
energy_consumer = EnergyConsumer(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
energy_consumer.customer_count = rs.get_int(table.customer_count.query_index, None)
energy_consumer.grounded = rs.get_boolean(table.grounded.query_index)
energy_consumer.p = rs.get_double(table.p.query_index, None)
energy_consumer.q = rs.get_double(table.q.query_index, None)
energy_consumer.p_fixed = rs.get_double(table.p_fixed.query_index, None)
energy_consumer.q_fixed = rs.get_double(table.q_fixed.query_index, None)
energy_consumer.phase_connection = PhaseShuntConnectionKind[rs.get_string(table.phase_connection.query_index)]
return self._load_energy_connection(energy_consumer, table, rs) and self._add_or_throw(energy_consumer)
def load_energy_consumer_phase(self, table: TableEnergyConsumerPhases, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
energy_consumer_phase = EnergyConsumerPhase(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
energy_consumer_phase.energy_consumer = self._ensure_get(rs.get_string(table.energy_consumer_mrid.query_index, None), EnergyConsumer)
if energy_consumer_phase.energy_consumer is not None:
energy_consumer_phase.energy_consumer.add_phase(energy_consumer_phase)
energy_consumer_phase.phase = SinglePhaseKind[rs.get_string(table.phase.query_index)]
energy_consumer_phase.p = rs.get_double(table.p.query_index, None)
energy_consumer_phase.q = rs.get_double(table.q.query_index, None)
energy_consumer_phase.p_fixed = rs.get_double(table.p_fixed.query_index, None)
energy_consumer_phase.q_fixed = rs.get_double(table.q_fixed.query_index, None)
return self._load_power_system_resource(energy_consumer_phase, table, rs) and self._add_or_throw(energy_consumer_phase)
def load_energy_source(self, table: TableEnergySources, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
energy_source = EnergySource(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
energy_source.active_power = rs.get_double(table.active_power.query_index, None)
energy_source.reactive_power = rs.get_double(table.reactive_power.query_index, None)
energy_source.voltage_angle = rs.get_double(table.voltage_angle.query_index, None)
energy_source.voltage_magnitude = rs.get_double(table.voltage_magnitude.query_index, None)
energy_source.p_max = rs.get_double(table.p_max.query_index, None)
energy_source.p_min = rs.get_double(table.p_min.query_index, None)
energy_source.r = rs.get_double(table.r.query_index, None)
energy_source.r0 = rs.get_double(table.r0.query_index, None)
energy_source.rn = rs.get_double(table.rn.query_index, None)
energy_source.x = rs.get_double(table.x.query_index, None)
energy_source.x0 = rs.get_double(table.x0.query_index, None)
energy_source.xn = rs.get_double(table.xn.query_index, None)
energy_source.is_external_grid = rs.get_boolean(table.is_external_grid.query_index)
energy_source.r_min = rs.get_double(table.r_min.query_index, None)
energy_source.rn_min = rs.get_double(table.rn_min.query_index, None)
energy_source.r0_min = rs.get_double(table.r0_min.query_index, None)
energy_source.x_min = rs.get_double(table.x_min.query_index, None)
energy_source.xn_min = rs.get_double(table.xn_min.query_index, None)
energy_source.x0_min = rs.get_double(table.x0_min.query_index, None)
energy_source.r_max = rs.get_double(table.r_max.query_index, None)
energy_source.rn_max = rs.get_double(table.rn_max.query_index, None)
energy_source.r0_max = rs.get_double(table.r0_max.query_index, None)
energy_source.x_max = rs.get_double(table.x_max.query_index, None)
energy_source.xn_max = rs.get_double(table.xn_max.query_index, None)
energy_source.x0_max = rs.get_double(table.x0_max.query_index, None)
return self._load_energy_connection(energy_source, table, rs) and self._add_or_throw(energy_source)
def load_energy_source_phase(self, table: TableEnergySourcePhases, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
energy_source_phase = EnergySourcePhase(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
energy_source_phase.energy_source = self._ensure_get(rs.get_string(table.energy_source_mrid.query_index, None), EnergySource)
if energy_source_phase.energy_source is not None:
energy_source_phase.energy_source.add_phase(energy_source_phase)
energy_source_phase.phase = SinglePhaseKind[rs.get_string(table.phase.query_index)]
return self._load_power_system_resource(energy_source_phase, table, rs) and self._add_or_throw(energy_source_phase)
def load_fuse(self, table: TableFuses, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
fuse = Fuse(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_switch(fuse, table, rs) and self._add_or_throw(fuse)
def load_jumper(self, table: TableJumpers, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
jumper = Jumper(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_switch(jumper, table, rs) and self._add_or_throw(jumper)
def load_junction(self, table: TableJunctions, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
junction = Junction(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_connector(junction, table, rs) and self._add_or_throw(junction)
def _load_line(self, line: Line, table: TableLines, rs: ResultSet) -> bool:
return self._load_equipment_container(line, table, rs)
def load_linear_shunt_compensator(self, table: TableLinearShuntCompensators, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
linear_shunt_compensator = LinearShuntCompensator(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
linear_shunt_compensator.b0_per_section = rs.get_double(table.b0_per_section.query_index, None)
linear_shunt_compensator.b_per_section = rs.get_double(table.b_per_section.query_index, None)
linear_shunt_compensator.g0_per_section = rs.get_double(table.g0_per_section.query_index, None)
linear_shunt_compensator.g_per_section = rs.get_double(table.g_per_section.query_index, None)
return self._load_shunt_compensator(linear_shunt_compensator, table, rs) and self._add_or_throw(linear_shunt_compensator)
def _load_per_length_impedance(self, per_length_impedance: PerLengthImpedance, table: TablePerLengthImpedances, rs: ResultSet) -> bool:
return self._load_per_length_line_parameter(per_length_impedance, table, rs)
def _load_per_length_line_parameter(self, per_length_line_parameter: PerLengthLineParameter, table: TablePerLengthLineParameters, rs: ResultSet) -> bool:
return self._load_identified_object(per_length_line_parameter, table, rs)
def load_per_length_sequence_impedance(self, table: TablePerLengthSequenceImpedances, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
per_length_sequence_impedance = PerLengthSequenceImpedance(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
per_length_sequence_impedance.r = rs.get_double(table.r.query_index, None)
per_length_sequence_impedance.x = rs.get_double(table.x.query_index, None)
per_length_sequence_impedance.r0 = rs.get_double(table.r0.query_index, None)
per_length_sequence_impedance.x0 = rs.get_double(table.x0.query_index, None)
per_length_sequence_impedance.bch = rs.get_double(table.bch.query_index, None)
per_length_sequence_impedance.gch = rs.get_double(table.gch.query_index, None)
per_length_sequence_impedance.b0ch = rs.get_double(table.b0ch.query_index, None)
per_length_sequence_impedance.g0ch = rs.get_double(table.g0ch.query_index, None)
return self._load_per_length_impedance(per_length_sequence_impedance, table, rs) and self._add_or_throw(per_length_sequence_impedance)
def load_power_electronics_connection(self, table: TablePowerElectronicsConnection, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
power_electronics_connection = PowerElectronicsConnection(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
power_electronics_connection.max_i_fault = rs.get_int(table.max_i_fault.query_index, None)
power_electronics_connection.max_q = rs.get_double(table.max_q.query_index, None)
power_electronics_connection.min_q = rs.get_double(table.min_q.query_index, None)
power_electronics_connection.p = rs.get_double(table.p.query_index, None)
power_electronics_connection.q = rs.get_double(table.q.query_index, None)
power_electronics_connection.rated_s = rs.get_int(table.rated_s.query_index, None)
power_electronics_connection.rated_u = rs.get_int(table.rated_u.query_index, None)
return self._load_regulating_cond_eq(power_electronics_connection, table, rs) and self._add_or_throw(power_electronics_connection)
def load_power_electronics_connection_phase(self, table: TablePowerElectronicsConnectionPhases, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
power_electronics_connection_phase = PowerElectronicsConnectionPhase(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
power_electronics_connection_phase.power_electronics_connection = self._ensure_get(
rs.get_string(table.power_electronics_connection_mrid.query_index, None),
PowerElectronicsConnection
)
if power_electronics_connection_phase.power_electronics_connection is not None:
power_electronics_connection_phase.power_electronics_connection.add_phase(power_electronics_connection_phase)
power_electronics_connection_phase.phase = SinglePhaseKind[rs.get_string(table.phase.query_index)]
power_electronics_connection_phase.p = rs.get_double(table.p.query_index, None)
power_electronics_connection_phase.phase = SinglePhaseKind[rs.get_string(table.phase.query_index)]
power_electronics_connection_phase.q = rs.get_double(table.q.query_index, None)
return self._load_power_system_resource(power_electronics_connection_phase, table, rs) and self._add_or_throw(power_electronics_connection_phase)
def load_power_transformer(self, table: TablePowerTransformers, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
power_transformer = PowerTransformer(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
power_transformer.vector_group = VectorGroup[rs.get_string(table.vector_group.query_index)]
power_transformer.transformer_utilisation = rs.get_double(table.transformer_utilisation.query_index, None)
power_transformer.construction_kind = TransformerConstructionKind[rs.get_string(table.construction_kind.query_index)]
power_transformer.function = TransformerFunctionKind[rs.get_string(table.function.query_index)]
power_transformer.asset_info = self._ensure_get(rs.get_string(table.power_transformer_info_mrid.query_index, None), PowerTransformerInfo)
return self._load_conducting_equipment(power_transformer, table, rs) and self._add_or_throw(power_transformer)
def load_power_transformer_end(self, table: TablePowerTransformerEnds, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
power_transformer_end = PowerTransformerEnd(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
power_transformer_end.end_number = rs.get_int(table.end_number.query_index)
power_transformer_end.power_transformer = self._ensure_get(rs.get_string(table.power_transformer_mrid.query_index, None), PowerTransformer)
if power_transformer_end.power_transformer is not None:
power_transformer_end.power_transformer.add_end(power_transformer_end)
power_transformer_end.connection_kind = WindingConnection[rs.get_string(table.connection_kind.query_index)]
power_transformer_end.phase_angle_clock = rs.get_int(table.phase_angle_clock.query_index, None)
power_transformer_end.b = rs.get_double(table.b.query_index, None)
power_transformer_end.b0 = rs.get_double(table.b0.query_index, None)
power_transformer_end.g = rs.get_double(table.g.query_index, None)
power_transformer_end.g0 = rs.get_double(table.g0.query_index, None)
power_transformer_end.r = rs.get_double(table.r.query_index, None)
power_transformer_end.r0 = rs.get_double(table.r0.query_index, None)
power_transformer_end.rated_s = rs.get_int(table.rated_s.query_index, None)
power_transformer_end.rated_u = rs.get_int(table.rated_u.query_index, None)
power_transformer_end.x = rs.get_double(table.x.query_index, None)
power_transformer_end.x0 = rs.get_double(table.x0.query_index, None)
return self._load_transformer_end(power_transformer_end, table, rs) and self._add_or_throw(power_transformer_end)
def _load_protected_switch(self, protected_switch: ProtectedSwitch, table: TableProtectedSwitches, rs: ResultSet) -> bool:
return self._load_switch(protected_switch, table, rs)
def load_ratio_tap_changer(self, table: TableRatioTapChangers, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
ratio_tap_changer = RatioTapChanger(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
ratio_tap_changer.transformer_end = self._ensure_get(rs.get_string(table.transformer_end_mrid.query_index, None), TransformerEnd)
if ratio_tap_changer.transformer_end is not None:
ratio_tap_changer.transformer_end.ratio_tap_changer = ratio_tap_changer
ratio_tap_changer.step_voltage_increment = rs.get_double(table.step_voltage_increment.query_index, None)
return self._load_tap_changer(ratio_tap_changer, table, rs) and self._add_or_throw(ratio_tap_changer)
def load_recloser(self, table: TableReclosers, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
recloser = Recloser(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_protected_switch(recloser, table, rs) and self._add_or_throw(recloser)
def _load_regulating_cond_eq(self, regulating_cond_eq: RegulatingCondEq, table: TableRegulatingCondEq, rs: ResultSet) -> bool:
regulating_cond_eq.control_enabled = rs.get_boolean(table.control_enabled.query_index)
return self._load_energy_connection(regulating_cond_eq, table, rs)
def _load_shunt_compensator(self, shunt_compensator: ShuntCompensator, table: TableShuntCompensators, rs: ResultSet) -> bool:
shunt_compensator.asset_info = self._ensure_get(rs.get_string(table.shunt_compensator_info_mrid.query_index, None), ShuntCompensatorInfo)
shunt_compensator.grounded = rs.get_boolean(table.grounded.query_index)
shunt_compensator.nom_u = rs.get_int(table.nom_u.query_index, None)
shunt_compensator.phase_connection = PhaseShuntConnectionKind[rs.get_string(table.phase_connection.query_index)]
shunt_compensator.sections = rs.get_double(table.sections.query_index, None)
return self._load_regulating_cond_eq(shunt_compensator, table, rs)
def _load_switch(self, switch: Switch, table: TableSwitches, rs: ResultSet) -> bool:
switch.set_normally_open(bool(rs.get_int(table.normal_open.query_index)))
switch.set_open(bool(rs.get_int(table.open.query_index)))
return self._load_conducting_equipment(switch, table, rs)
def _load_tap_changer(self, tap_changer: TapChanger, table: TableTapChangers, rs: ResultSet) -> bool:
tap_changer.control_enabled = rs.get_boolean(table.control_enabled.query_index)
tap_changer.high_step = rs.get_int(table.high_step.query_index, None)
tap_changer.low_step = rs.get_int(table.low_step.query_index, None)
tap_changer.neutral_step = rs.get_int(table.neutral_step.query_index, None)
tap_changer.neutral_u = rs.get_int(table.neutral_u.query_index, None)
tap_changer.normal_step = rs.get_int(table.normal_step.query_index, None)
tap_changer.step = rs.get_double(table.step.query_index, None)
return self._load_power_system_resource(tap_changer, table, rs)
def _load_transformer_end(self, transformer_end: TransformerEnd, table: TableTransformerEnds, rs: ResultSet) -> bool:
transformer_end.terminal = self._ensure_get(rs.get_string(table.terminal_mrid.query_index, None), Terminal)
transformer_end.base_voltage = self._ensure_get(rs.get_string(table.base_voltage_mrid.query_index, None), BaseVoltage)
transformer_end.grounded = rs.get_boolean(table.grounded.query_index)
transformer_end.r_ground = rs.get_double(table.r_ground.query_index, None)
transformer_end.x_ground = rs.get_double(table.x_ground.query_index, None)
transformer_end.star_impedance = self._ensure_get(rs.get_string(table.star_impedance_mrid.query_index, None), TransformerStarImpedance)
return self._load_identified_object(transformer_end, table, rs)
def load_transformer_star_impedance(self, table: TableTransformerStarImpedance, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
transformer_star_impedance = TransformerStarImpedance(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
transformer_star_impedance.r = rs.get_double(table.r.query_index, None)
transformer_star_impedance.r0 = rs.get_double(table.r0.query_index, None)
transformer_star_impedance.x = rs.get_double(table.x.query_index, None)
transformer_star_impedance.x0 = rs.get_double(table.x0.query_index, None)
transformer_star_impedance.transformer_end_info = self._ensure_get(rs.get_string(table.transformer_end_info_mrid.query_index, None), TransformerEndInfo)
if transformer_star_impedance.transformer_end_info is not None:
transformer_star_impedance.transformer_end_info.transformer_star_impedance = transformer_star_impedance
return self._load_identified_object(transformer_star_impedance, table, rs) and self._add_or_throw(transformer_star_impedance)
# ************ IEC61970 InfIEC61970 ************
def load_circuit(self, table: TableCircuits, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
circuit = Circuit(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
circuit.loop = self._ensure_get(rs.get_string(table.loop_mrid.query_index, None), Loop)
if circuit.loop is not None:
circuit.loop.add_circuit(circuit)
return self._load_line(circuit, table, rs) and self._add_or_throw(circuit)
def load_loop(self, table: TableLoops, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
loop = Loop(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
return self._load_identified_object(loop, table, rs) and self._add_or_throw(loop)
# ************ ASSOCIATIONS ************
def load_asset_organisation_role_asset(self, table: TableAssetOrganisationRolesAssets, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
asset_organisation_role_mrid = set_last_mrid(rs.get_string(table.asset_organisation_role_mrid.query_index))
set_last_mrid(f"{asset_organisation_role_mrid}-to-UNKNOWN")
asset_mrid = rs.get_string(table.asset_mrid.query_index)
set_last_mrid(f"{asset_organisation_role_mrid}-to-{asset_mrid}")
asset_organisation_role = self._base_service.get(asset_organisation_role_mrid, AssetOrganisationRole)
asset = self._base_service.get(asset_mrid, Asset)
asset.add_organisation_role(asset_organisation_role)
return True
def load_equipment_equipment_container(self, table: TableEquipmentEquipmentContainers, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
equipment_mrid = set_last_mrid(rs.get_string(table.equipment_mrid.query_index))
set_last_mrid(f"{equipment_mrid}-to-UNKNOWN")
equipment_container_mrid = rs.get_string(table.equipment_container_mrid.query_index)
set_last_mrid(f"{equipment_mrid}-to-{equipment_container_mrid}")
equipment = self._base_service.get(equipment_mrid, Equipment)
equipment_container = self._base_service.get(equipment_container_mrid, EquipmentContainer)
equipment_container.add_equipment(equipment)
equipment.add_container(equipment_container)
return True
def load_equipment_operational_restriction(self, table: TableEquipmentOperationalRestrictions, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
equipment_mrid = set_last_mrid(rs.get_string(table.equipment_mrid.query_index))
set_last_mrid(f"{equipment_mrid}-to-UNKNOWN")
operational_restriction_mrid = rs.get_string(table.operational_restriction_mrid.query_index)
set_last_mrid(f"{equipment_mrid}-to-{operational_restriction_mrid}")
equipment = self._base_service.get(equipment_mrid, Equipment)
operational_restriction = self._base_service.get(operational_restriction_mrid, OperationalRestriction)
operational_restriction.add_equipment(equipment)
equipment.add_operational_restriction(operational_restriction)
return True
def load_equipment_usage_point(self, table: TableEquipmentUsagePoints, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
equipment_mrid = set_last_mrid(rs.get_string(table.equipment_mrid.query_index))
set_last_mrid(f"{equipment_mrid}-to-UNKNOWN")
usage_point_mrid = rs.get_string(table.usage_point_mrid.query_index)
set_last_mrid(f"{equipment_mrid}-to-{usage_point_mrid}")
equipment = self._base_service.get(equipment_mrid, Equipment)
usage_point = self._base_service.get(usage_point_mrid, UsagePoint)
usage_point.add_equipment(equipment)
equipment.add_usage_point(usage_point)
return True
def load_usage_point_end_device(self, table: TableUsagePointsEndDevices, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
usage_point_mrid = set_last_mrid(rs.get_string(table.usage_point_mrid.query_index))
set_last_mrid(f"{usage_point_mrid}-to-UNKNOWN")
end_device_mrid = rs.get_string(table.end_device_mrid.query_index)
set_last_mrid(f"{usage_point_mrid}-to-{end_device_mrid}")
usage_point = self._base_service.get(usage_point_mrid, UsagePoint)
end_device = self._base_service.get(end_device_mrid, EndDevice)
end_device.add_usage_point(usage_point)
usage_point.add_end_device(end_device)
return True
def load_circuit_substation(self, table: TableCircuitsSubstations, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
circuit_mrid = set_last_mrid(rs.get_string(table.circuit_mrid.query_index))
set_last_mrid(f"{circuit_mrid}-to-UNKNOWN")
substation_mrid = rs.get_string(table.substation_mrid.query_index)
set_last_mrid(f"{circuit_mrid}-to-{substation_mrid}")
circuit = self._base_service.get(circuit_mrid, Circuit)
substation = self._base_service.get(substation_mrid, Substation)
substation.add_circuit(circuit)
circuit.add_end_substation(substation)
return True
def load_circuit_terminal(self, table: TableCircuitsTerminals, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
circuit_mrid = set_last_mrid(rs.get_string(table.circuit_mrid.query_index))
set_last_mrid(f"{circuit_mrid}-to-UNKNOWN")
terminal_mrid = rs.get_string(table.terminal_mrid.query_index)
set_last_mrid(f"{circuit_mrid}-to-{terminal_mrid}")
circuit = self._base_service.get(circuit_mrid, Circuit)
terminal = self._base_service.get(terminal_mrid, Terminal)
circuit.add_end_terminal(terminal)
return True
def load_loop_substation(self, table: TableLoopsSubstations, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
asset_organisation_role_mrid = set_last_mrid(rs.get_string(table.loop_mrid.query_index))
set_last_mrid(f"{asset_organisation_role_mrid}-to-UNKNOWN")
asset_mrid = rs.get_string(table.substation_mrid.query_index)
set_last_mrid(f"{asset_organisation_role_mrid}-to-{asset_mrid}")
loop = self._base_service.get(asset_organisation_role_mrid, Loop)
substation = self._base_service.get(asset_mrid, Substation)
relationship = LoopSubstationRelationship[rs.get_string(table.relationship.query_index)]
if relationship == LoopSubstationRelationship.LOOP_ENERGIZES_SUBSTATION:
substation.add_loop(loop)
loop.add_substation(substation)
elif relationship == LoopSubstationRelationship.SUBSTATION_ENERGIZES_LOOP:
substation.add_energized_loop(loop)
loop.add_energizing_substation(substation)
return True | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/database/sqlite/readers/network_cim_reader.py | network_cim_reader.py |
from zepben.evolve import NetworkService, DiagramService, Diagram, DiagramStyle, BaseVoltage, PositionPoint, Location, Feeder, EnergySource, \
PowerTransformerInfo, DiagramObject, AcLineSegment, ConductingEquipment, Junction, EnergyConsumer, PowerTransformer, DiagramObjectPoint, ConnectivityNode
__all__ = ["SimpleNodeBreakerFeeder"]
class SimpleNodeBreakerFeeder:
def __init__(self, breaker_is_open=False):
self.breaker_is_open = breaker_is_open
self.network_service: NetworkService = NetworkService()
self.diagram_service: DiagramService = DiagramService()
self.diagram: Diagram = Diagram(diagram_style=DiagramStyle.GEOGRAPHIC)
self._create_network_service()
self._create_diagram_service()
def _create_network_service(self):
# Create BaseVoltages
# noinspection PyArgumentList
bv_hv: BaseVoltage = BaseVoltage(mrid="20kV", nominal_voltage=20000, name="20kV")
# noinspection PyArgumentList
bv_lv: BaseVoltage = BaseVoltage(mrid="415V", nominal_voltage=3000, name="415V")
self.network_service.add(bv_hv)
self.network_service.add(bv_lv)
# Create Locations for buses
# noinspection PyArgumentList
point1 = PositionPoint(x_position=149.12791965570293, y_position=-35.277592101000934)
# noinspection PyArgumentList
point2 = PositionPoint(x_position=149.12779472660375, y_position=-35.278183862759285)
loc1 = Location().add_point(point1)
loc2 = Location().add_point(point2)
# Create connectivity_nodes
cn1 = ConnectivityNode(name="cn1")
cn2 = ConnectivityNode(name="cn2")
cn3 = ConnectivityNode(name="cn3")
cn4 = ConnectivityNode(name="cn4")
# Create EnergySource
# noinspection PyUnresolvedReferences
energy_source: EnergySource = self.network_service.create_energy_source(cn=cn1, base_voltage=bv_hv,
voltage_magnitude=1.02 * bv_hv.nominal_voltage,
name="Grid Connection", location=loc1)
# TODO: Replace createEnergySource with creation of EquivalentInjection
# Create Feeder
fdr = Feeder(normal_head_terminal=energy_source.get_terminal_by_sn(1))
self.network_service.add(fdr)
# Create Transformer
# noinspection PyUnresolvedReferences
self.network_service.create_two_winding_power_transformer(cn1=cn1, cn2=cn2, name="Trafo", location=loc1,
asset_info=PowerTransformerInfo())
# TODO: Associate the PowerTransformerInfo() to th PowerTransformer instance
# TODO: Add ptInfo= self.network_service.getAvailablePowerTransformerInfo("0.4 MVA 20/0.4 kV")
# Create Breaker
# noinspection PyUnresolvedReferences
breaker = self.network_service.create_breaker(cn1=cn2, cn2=cn3, base_voltage=bv_lv)
breaker.set_open(self.breaker_is_open)
# Create location for the Line
line_location = Location().add_point(point1).add_point(point2)
self.network_service.add(line_location)
# Create Line
# noinspection PyUnresolvedReferences
self.network_service.create_ac_line_segment(cn1=cn3, cn2=cn4, name="Line",
length=100., base_voltage=bv_lv,
location=line_location)
# Create EnergyConsumer
# noinspection PyUnresolvedReferences
self.network_service.create_energy_consumer(cn=cn3, p=100000., q=50000., name="Load",
location=loc2,
base_voltage=bv_lv)
def _create_diagram_service(self):
self.diagram_service.add(self.diagram)
self._add_diagram_objects()
# TODO: In ?voltages geo view the acls does not appear.
def _add_diagram_objects(self):
# Add DiagramObject for ConductingEquipments
ce_list = self.network_service.objects(ConductingEquipment)
for ce in ce_list:
# diagram_object_mapping = defaultdict(
# lambda: DiagramObject(identified_object_mrid=ce.mrid, style="JUNCTION",
# diagram=self.diagram))
if isinstance(ce, Junction):
diagram_object = DiagramObject(identified_object_mrid=ce.mrid,
style="JUNCTION",
diagram=self.diagram)
elif isinstance(ce, EnergySource):
diagram_object = DiagramObject(identified_object_mrid=ce.mrid,
style="ENERGY_SOURCE",
diagram=self.diagram)
elif isinstance(ce, EnergyConsumer):
diagram_object = DiagramObject(identified_object_mrid=ce.mrid,
style="USAGE_POINT",
diagram=self.diagram)
elif isinstance(ce, PowerTransformer):
diagram_object = DiagramObject(identified_object_mrid=ce.mrid,
style="DIST_TRANSFORMER",
diagram=self.diagram)
elif isinstance(ce, AcLineSegment):
diagram_object = self._add_diagram_objects_to_ac_line_segment(ce)
else:
diagram_object = DiagramObject(identified_object_mrid=ce.mrid,
style="JUNCTION",
diagram=self.diagram)
self.diagram.add_diagram_object(diagram_object)
self.diagram_service.add(diagram_object)
def _add_diagram_objects_to_ac_line_segment(self, ac_line_segment: AcLineSegment):
# Create DiagramObject for AcLineSegments
diagram_object = DiagramObject(diagram=self.diagram)
diagram_object.mrid = ac_line_segment.mrid + "-do"
diagram_object.style = "CONDUCTOR_LV"
diagram_object.diagram = self.diagram
for position_point in ac_line_segment.location.points:
# noinspection PyArgumentList
diagram_point = DiagramObjectPoint(x_position=position_point.x_position,
y_position=position_point.y_position)
diagram_object.add_point(diagram_point)
return diagram_object | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/examples/simple_node_breaker_feeder.py | simple_node_breaker_feeder.py |
from __future__ import annotations
from asyncio import get_event_loop
from typing import Optional, Iterable, AsyncGenerator, List, Callable, Tuple
from zepben.evolve import CustomerService, IdentifiedObject, Organisation, Customer, CustomerAgreement, PricingStructure, Tariff
from zepben.evolve.streaming.get.consumer import CimConsumerClient, MultiObjectResult
from zepben.evolve.streaming.grpc.grpc import GrpcResult
from zepben.protobuf.cc.cc_pb2_grpc import CustomerConsumerStub
from zepben.protobuf.cc.cc_requests_pb2 import GetIdentifiedObjectsRequest
__all__ = ["CustomerConsumerClient", "SyncCustomerConsumerClient"]
class CustomerConsumerClient(CimConsumerClient[CustomerService]):
"""
Consumer client for a :class:`CustomerService`.
## WARNING ##
The :class:`MultiObjectResult` operations below are not atomic upon a :class:`CustomerService`, and thus if processing fails partway through, any
previously successful additions will have been processed by the service, and thus you may have an incomplete service. Also note that adding to the
service may not occur for an object if another object with the same mRID is already present in service. `MultiObjectResult.failed` can be used to
check for mRIDs that were not found or retrieved but not added to service (this should not be the case unless you are processing things concurrently).
"""
__service: CustomerService
@property
def service(self) -> CustomerService:
return self.__service
_stub: CustomerConsumerStub = None
def __init__(self, channel=None, stub: CustomerConsumerStub = None, error_handlers: List[Callable[[Exception], bool]] = None, timeout: int = 60):
super().__init__(error_handlers=error_handlers, timeout=timeout)
if channel is None and stub is None:
raise ValueError("Must provide either a channel or a stub")
if stub is not None:
self._stub = stub
else:
self._stub = CustomerConsumerStub(channel)
self.__service = CustomerService()
async def _process_identified_objects(self, mrids: Iterable[str]) -> AsyncGenerator[Tuple[Optional[IdentifiedObject], str], None]:
if not mrids:
return
responses = self._stub.getIdentifiedObjects(self._batch_send(GetIdentifiedObjectsRequest(), mrids), timeout=self.timeout)
for response in responses:
for cio in response.identifiedObjects:
yield self._extract_identified_object("customer", cio, _cio_type_to_cim)
class SyncCustomerConsumerClient(CustomerConsumerClient):
def get_identified_object(self, mrid: str) -> GrpcResult[Optional[IdentifiedObject]]:
return get_event_loop().run_until_complete(super()._get_identified_objects(mrid))
def get_identified_objects(self, mrids: Iterable[str]) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(super()._get_identified_objects(mrids))
_cio_type_to_cim = {
"organisation": Organisation,
"customer": Customer,
"customerAgreement": CustomerAgreement,
"pricingStructure": PricingStructure,
"tariff": Tariff
} | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/streaming/get/customer_consumer.py | customer_consumer.py |
from __future__ import annotations
import warnings
from asyncio import get_event_loop
from itertools import chain
from typing import Iterable, Dict, Optional, AsyncGenerator, Union, List, Callable, Set, Tuple, Generic, TypeVar, Awaitable
from dataclassy import dataclass
from zepben.protobuf.nc.nc_pb2_grpc import NetworkConsumerStub
from zepben.protobuf.nc.nc_requests_pb2 import GetIdentifiedObjectsRequest, GetNetworkHierarchyRequest, GetEquipmentForContainersRequest, \
GetCurrentEquipmentForFeederRequest, GetEquipmentForRestrictionRequest, GetTerminalsForNodeRequest
from zepben.evolve import NetworkService, Feeder, IdentifiedObject, CableInfo, OverheadWireInfo, AssetOwner, \
Organisation, Location, Meter, UsagePoint, OperationalRestriction, FaultIndicator, BaseVoltage, ConnectivityNode, GeographicalRegion, Site, \
SubGeographicalRegion, Substation, Terminal, AcLineSegment, Breaker, Disconnector, EnergyConsumer, EnergyConsumerPhase, EnergySource, EnergySourcePhase, \
Fuse, Jumper, Junction, LinearShuntCompensator, PerLengthSequenceImpedance, PowerTransformer, PowerTransformerEnd, RatioTapChanger, Recloser, Circuit, \
Loop, Pole, Streetlight, Accumulator, Analog, Discrete, Control, RemoteControl, RemoteSource, PowerTransformerInfo, PowerElectronicsConnection, \
PowerElectronicsConnectionPhase, BatteryUnit, PhotoVoltaicUnit, PowerElectronicsWindUnit, BusbarSection, LoadBreakSwitch, TransformerTankInfo, \
TransformerEndInfo, TransformerStarImpedance, EquipmentContainer, NetworkHierarchy, MultiObjectResult, CimConsumerClient, NoLoadTest, OpenCircuitTest, \
ShortCircuitTest, EquivalentBranch, ShuntCompensatorInfo
from zepben.evolve.streaming.grpc.grpc import GrpcResult
__all__ = ["NetworkConsumerClient", "SyncNetworkConsumerClient"]
MAX_64_BIT_INTEGER = 9223372036854775807
@dataclass(slots=True)
class NetworkResult(object):
network_service: Optional[NetworkService]
failed: Set[str] = set()
class NetworkConsumerClient(CimConsumerClient[NetworkService]):
"""
Consumer client for a :class:`NetworkService`.
## WARNING ##
The :class:`MultiObjectResult` operations below are not atomic upon a :class:`NetworkService`, and thus if processing fails partway through, any
previously successful additions will have been processed by the service, and thus you may have an incomplete service. Also note that adding to the
service may not occur for an object if another object with the same mRID is already present in service. `MultiObjectResult.failed` can be used to
check for mRIDs that were not found or retrieved but not added to service (this should not be the case unless you are processing things concurrently).
"""
CIM_IO = TypeVar('CIM_IO', bound=IdentifiedObject)
PB_IO = TypeVar('PB_IO')
__service: NetworkService
__network_hierarchy: Optional[NetworkHierarchy]
@property
def service(self) -> NetworkService:
return self.__service
_stub: NetworkConsumerStub = None
def __init__(self, channel=None, stub: NetworkConsumerStub = None, error_handlers: List[Callable[[Exception], bool]] = None, timeout: int = 60):
"""
:param channel: a gRPC channel used to create a stub if no stub is provided.
:param stub: the gRPC stub to use for this consumer client.
:param error_handlers: a collection of handlers to be processed for any errors that occur.
"""
super().__init__(error_handlers=error_handlers, timeout=timeout)
if channel is None and stub is None:
raise ValueError("Must provide either a channel or a stub")
if stub is not None:
self._stub = stub
else:
self._stub = NetworkConsumerStub(channel)
self.__service = NetworkService()
self.__network_hierarchy = None
async def get_equipment_for_container(self, container: Union[str, EquipmentContainer]) -> GrpcResult[MultiObjectResult]:
"""
Retrieve the :class:`Equipment` for the :class:`EquipmentContainer` represented by `container`
Exceptions that occur during retrieval will be caught and passed to all error handlers that have been registered against this client.
Parameters
- `service` - The :class:`NetworkService` to store fetched objects in.
- `container` - The :class:`EquipmentContainer` (or its mRID) to fetch equipment for.
Returns a :class:`GrpcResult` with a result of one of the following:
- When `GrpcResult.wasSuccessful`, a map containing the retrieved objects keyed by mRID, accessible via `GrpcResult.value`. If an item was not
found, or couldn't be added to `service`, it will be excluded from the map and its mRID will be present in `MultiObjectResult.failed` (see
`BaseService.add`).
- When `GrpcResult.wasFailure`, the error that occurred retrieving or processing the the object, accessible via `GrpcResult.thrown`.
Note the :class:`NetworkConsumerClient` warning in this case.
"""
return await self._get_equipment_for_container(container)
async def get_current_equipment_for_feeder(self, feeder: [str, Feeder]) -> GrpcResult[MultiObjectResult]:
"""
Retrieve the current :class:`Equipment` for the :class:`Feeder` represented by `feeder`
Exceptions that occur during retrieval will be caught and passed to all error handlers that have been registered against this client.
Parameters
- `service` - The :class:`NetworkService` to store fetched objects in.
- `feeder` - The :class:`Feeder` (or its mRID) to fetch the current equipment for.
Returns a :class:`GrpcResult` with a result of one of the following:
- When `GrpcResult.wasSuccessful`, a map containing the retrieved objects keyed by mRID, accessible via `GrpcResult.value`. If an item was not
found, or couldn't be added to `service`, it will be excluded from the map and its mRID will be present in `MultiObjectResult.failed` (see
`BaseService.add`).
- When `GrpcResult.wasFailure`, the error that occurred retrieving or processing the the object, accessible via `GrpcResult.thrown`.
Note the :class:`NetworkConsumerClient` warning in this case.
"""
return await self._get_current_equipment_for_feeder(feeder)
async def get_equipment_for_restriction(self, restriction: [str, OperationalRestriction]) -> GrpcResult[MultiObjectResult]:
"""
Retrieve the :class:`Equipment` for the :class:`OperationalRestriction` represented by `restriction`
Exceptions that occur during retrieval will be caught and passed to all error handlers that have been registered against this client.
Parameters
- `service` - The :class:`NetworkService` to store fetched objects in.
- `restriction` - The :class:`OperationalRestriction` (or its mRID) to fetch equipment for.
Returns a :class:`GrpcResult` with a result of one of the following:
- When `GrpcResult.wasSuccessful`, a map containing the retrieved objects keyed by mRID, accessible via `GrpcResult.value`. If an item was not
found, or couldn't be added to `service`, it will be excluded from the map and its mRID will be present in `MultiObjectResult.failed` (see
`BaseService.add`).
- When `GrpcResult.wasFailure`, the error that occurred retrieving or processing the the object, accessible via `GrpcResult.thrown`.
Note the :class:`NetworkConsumerClient` warning in this case.
"""
return await self._get_equipment_for_restriction(restriction)
async def get_terminals_for_connectivity_node(self, node: [str, ConnectivityNode]) -> GrpcResult[MultiObjectResult]:
"""
Retrieve the :class:`Terminal`s for the :class:`ConnectivityNode` represented by `node`
Exceptions that occur during retrieval will be caught and passed to all error handlers that have been registered against this client.
Parameters
- `service` - The :class:`NetworkService` to store fetched objects in.
- `node` - The :class:`ConnectivityNode` (or its mRID) to fetch terminals for.
Returns a :class:`GrpcResult` with a result of one of the following:
- When `GrpcResult.wasSuccessful`, a map containing the retrieved objects keyed by mRID, accessible via `GrpcResult.value`. If an item was not
found, or couldn't be added to `service`, it will be excluded from the map and its mRID will be present in `MultiObjectResult.failed` (see
`BaseService.add`).
- When `GrpcResult.wasFailure`, the error that occurred retrieving or processing the the object, accessible via `GrpcResult.thrown`.
Note the :class:`NetworkConsumerClient` warning in this case.
"""
return await self._get_terminals_for_connectivity_node(node)
async def get_network_hierarchy(self) -> GrpcResult[NetworkHierarchy]:
"""
Retrieve the network hierarchy
Parameters
- `service` - The :class:`NetworkService` to store fetched objects in.
Returns a simplified version of the network hierarchy that can be used to make further in-depth requests.
"""
return await self._get_network_hierarchy()
async def get_feeder(self, mrid: str) -> GrpcResult[MultiObjectResult]:
"""
Retrieve the feeder network for the specified `mrid` and store the results in the `service`.
This is a convenience method that will fetch the feeder object and all of the equipment referenced by the feeder (normal state), along with
all references. This should entail a complete connectivity model for the feeder, however not the connectivity between multiple feeders.
Parameters
- `service` - The :class:`NetworkService` to store fetched objects in.
- `mrid` - The mRID of the :class:`Feeder` to fetch equipment for.
Returns a :class:`GrpcResult` of a :class:`MultiObjectResult`. If successful, containing a map keyed by mRID of all the objects retrieved. If an item
couldn't be added to `service`, its mRID will be present in `MultiObjectResult.failed`.
In addition to normal gRPC errors, you may also receive an unsuccessful :class:`GrpcResult` with the following errors:
* - :class:`ValueError` if the requested object was not found or was not a :class:`Feeder`.
"""
warnings.warn('`get_feeder` is deprecated, prefer the more generic `get_equipment_container`', DeprecationWarning)
return await self._get_equipment_container(mrid, Feeder)
async def get_equipment_container(self, mrid: str, expected_class: type = EquipmentContainer) -> GrpcResult[MultiObjectResult]:
"""
/***
* Retrieve the equipment container network for the specified `mrid` and store the results in the `service`.
*
* This is a convenience method that will fetch the container object and all of the equipment contained, along with all subsequent
* references. This should entail a complete connectivity model for the container, however not the connectivity between multiple containers.
*
Parameters
- `service` - The :class:`NetworkService` to store fetched objects in.
- `mrid` - The mRID of the :class:`EquipmentContainer` to fetch.
* @param expected_class The expected type of the fetched container.
*
* Returns a :class:`GrpcResult` of a :class:`MultiObjectResult`. If successful, containing a map keyed by mRID of all the objects retrieved. If an
item couldn't be added to `service`, its mRID will be present in `MultiObjectResult.failed`.
*
* In addition to normal gRPC errors, you may also receive an unsuccessful :class:`GrpcResult` with the following errors:
* - :class:`ValueError` if the requested object was not found or was of the wrong type.
*/
"""
return await self._get_equipment_container(mrid, expected_class)
async def get_equipment_for_loop(self, loop: Union[str, Loop]) -> GrpcResult[MultiObjectResult]:
"""
Retrieve the :class:`Equipment` for the :class:`Loop` represented by `mRID`
Exceptions that occur during retrieval will be caught and passed to all error handlers that have been registered against this client.
Parameters
- `service` - The :class:`NetworkService` to store fetched objects in.
- `restriction` - The :class:`Loop` (or its mRID) to fetch equipment for.
Returns a :class:`GrpcResult` with a result of one of the following:
- When `GrpcResult.wasSuccessful`, a map containing the retrieved objects keyed by mRID, accessible via `GrpcResult.value`. If an item was not
found, or couldn't be added to `service`, it will be excluded from the map and its mRID will be present in `MultiObjectResult.failed` (see
`BaseService.add`).
- When `GrpcResult.wasFailure`, the error that occurred retrieving or processing the the object, accessible via `GrpcResult.thrown`.
Note the :class:`NetworkConsumerClient` warning in this case.
"""
return await self._get_equipment_for_loop(loop)
async def get_all_loops(self) -> GrpcResult[MultiObjectResult]:
"""
Retrieve the :class:`Equipment` for all :class:`Loop` instances in `service`.
Exceptions that occur during retrieval will be caught and passed to all error handlers that have been registered against this client.
Parameters
- `service` - The :class:`NetworkService` to store fetched objects in.
Returns a :class:`GrpcResult` with a result of one of the following:
- When `GrpcResult.wasSuccessful`, a map containing the retrieved objects keyed by mRID, accessible via `GrpcResult.value`. If an item was not
found, or couldn't be added to `service`, it will be excluded from the map and its mRID will be present in `MultiObjectResult.failed` (see
`BaseService.add`).
- When `GrpcResult.wasFailure`, the error that occurred retrieving or processing the the object, accessible via `GrpcResult.thrown`.
Note the :class:`NetworkConsumerClient` warning in this case.
"""
return await self._get_all_loops()
async def retrieve_network(self) -> GrpcResult[NetworkResult]:
"""
Retrieve the entire network.
Returns a GrpcResult containing the complete `zepben.evolve.network.network.NetworkService` from the server.
"""
return await self._retrieve_network()
async def _get_equipment_for_container(self, container: Union[str, EquipmentContainer]) -> GrpcResult[MultiObjectResult]:
return await self._handle_multi_object_rpc(lambda: self._process_equipment_for_container(container))
async def _get_equipment_for_containers(self, containers: Iterable[str]) -> GrpcResult[MultiObjectResult]:
return await self._handle_multi_object_rpc(lambda: self._process_equipment_for_containers(containers))
async def _get_current_equipment_for_feeder(self, feeder: [str, Feeder]) -> GrpcResult[MultiObjectResult]:
return await self._handle_multi_object_rpc(lambda: self._process_current_equipment_for_feeder(feeder))
async def _get_equipment_for_restriction(self, restriction: [str, OperationalRestriction]) -> GrpcResult[MultiObjectResult]:
return await self._handle_multi_object_rpc(lambda: self._process_equipment_for_restriction(restriction))
async def _get_terminals_for_connectivity_node(self, node: [str, ConnectivityNode]) -> GrpcResult[MultiObjectResult]:
return await self._handle_multi_object_rpc(lambda: self._process_terminals_for_connectivity_node(node))
async def _get_network_hierarchy(self) -> GrpcResult[NetworkHierarchy]:
if self.__network_hierarchy:
# noinspection PyArgumentList
return GrpcResult(self.__network_hierarchy)
return await self.try_rpc(lambda: self._handle_network_hierarchy())
async def _get_equipment_container(self, mrid: str, expected_class: type = EquipmentContainer) -> GrpcResult[MultiObjectResult]:
async def get_additional(it: EquipmentContainer, mor: MultiObjectResult) -> Optional[GrpcResult[MultiObjectResult]]:
result = await self._get_equipment_for_container(it)
if result.was_failure:
# noinspection PyArgumentList
return GrpcResult(result.thrown, result.was_error_handled)
mor.objects.update(result.value.objects)
return None
return await self._get_with_references(mrid, expected_class, get_additional)
async def _get_equipment_for_loop(self, loop: Union[str, Loop]) -> GrpcResult[MultiObjectResult]:
mrid = loop.mrid if isinstance(loop, Loop) else loop
async def get_additional(it: Loop, mor: MultiObjectResult) -> Optional[GrpcResult[MultiObjectResult]]:
mor.objects.update({cir.mrid: cir for cir in it.circuits})
mor.objects.update({sub.mrid: sub for sub in it.substations})
mor.objects.update({sub.mrid: sub for sub in it.energizing_substations})
containers: Set[str] = set(map(lambda ec: ec.mrid, chain(it.circuits, it.substations, it.energizing_substations)))
result = await self._get_equipment_for_containers(containers)
if result.was_failure:
# noinspection PyArgumentList
return GrpcResult(result.thrown, result.was_error_handled)
mor.objects.update(result.value.objects)
return None
return await self._get_with_references(mrid, Loop, get_additional)
async def _get_all_loops(self) -> GrpcResult[MultiObjectResult]:
response = await self._get_network_hierarchy()
if response.was_failure:
# noinspection PyArgumentList
return GrpcResult(response.thrown, response.was_error_handled)
hierarchy = response.value
mor = MultiObjectResult()
mor.objects.update(hierarchy.geographical_regions)
mor.objects.update(hierarchy.sub_geographical_regions)
mor.objects.update(hierarchy.substations)
mor.objects.update(hierarchy.feeders)
mor.objects.update(hierarchy.circuits)
mor.objects.update(hierarchy.loops)
containers: Set[EquipmentContainer] = set()
for loop in hierarchy.loops.values():
containers.update(chain(loop.circuits, loop.substations, loop.energizing_substations))
result = await self._get_equipment_for_containers(map(lambda it: it.mrid, containers))
if result.was_failure:
# noinspection PyArgumentList
return GrpcResult(result.thrown, result.was_error_handled)
mor.objects.update(result.value.objects)
error = await self._resolve_references(mor)
if error:
return error
# noinspection PyArgumentList
return GrpcResult(mor)
async def _retrieve_network(self) -> GrpcResult[NetworkResult]:
result = (await self._get_network_hierarchy()).throw_on_error()
hierarchy: NetworkHierarchy = result.result
failed = set()
for mrid in chain(hierarchy.substations, hierarchy.feeders, hierarchy.circuits):
result = await self._get_equipment_container(mrid)
if result.was_successful:
failed.update(result.result.failed)
# noinspection PyArgumentList
return GrpcResult(NetworkResult(self.service, failed))
async def _process_equipment_for_container(self, it: Union[str, EquipmentContainer]) -> AsyncGenerator[IdentifiedObject, None]:
mrid = it.mrid if isinstance(it, EquipmentContainer) else it
responses = self._stub.getEquipmentForContainers(self._batch_send(GetEquipmentForContainersRequest(), [mrid]), timeout=self.timeout)
async for response in responses:
for nio in response.identifiedObjects:
yield self._extract_identified_object("network", nio, _nio_type_to_cim)
async def _process_equipment_for_containers(self, mrids: Iterable[str]) -> AsyncGenerator[IdentifiedObject, None]:
responses = self._stub.getEquipmentForContainers(self._batch_send(GetEquipmentForContainersRequest(), mrids), timeout=self.timeout)
async for response in responses:
for nio in response.identifiedObjects:
yield self._extract_identified_object("network", nio, _nio_type_to_cim)
async def _process_current_equipment_for_feeder(self, it: Union[str, Feeder]) -> AsyncGenerator[IdentifiedObject, None]:
mrid = it.mrid if isinstance(it, Feeder) else it
responses = self._stub.getCurrentEquipmentForFeeder(GetCurrentEquipmentForFeederRequest(mrid=mrid), timeout=self.timeout)
async for response in responses:
for nio in response.identifiedObjects:
yield self._extract_identified_object("network", nio, _nio_type_to_cim)
async def _process_equipment_for_restriction(self,
it: Union[str, OperationalRestriction]) -> AsyncGenerator[IdentifiedObject, None]:
mrid = it.mrid if isinstance(it, OperationalRestriction) else it
responses = self._stub.getEquipmentForRestriction(GetEquipmentForRestrictionRequest(mrid=mrid), timeout=self.timeout)
async for response in responses:
for nio in response.identifiedObjects:
yield self._extract_identified_object("network", nio, _nio_type_to_cim)
async def _process_terminals_for_connectivity_node(self,
it: Union[str, ConnectivityNode]) -> AsyncGenerator[IdentifiedObject, None]:
mrid = it.mrid if isinstance(it, ConnectivityNode) else it
responses = self._stub.getTerminalsForNode(GetTerminalsForNodeRequest(mrid=mrid), timeout=self.timeout)
async for response in responses:
# noinspection PyUnresolvedReferences
yield self.service.get(response.terminal.mrid(), Terminal, default=None) or self.service.add_from_pb(response.terminal), response.terminal.mrid()
async def _process_identified_objects(self, mrids: Iterable[str]) -> AsyncGenerator[Tuple[Optional[IdentifiedObject], str], None]:
if not mrids:
return
responses = self._stub.getIdentifiedObjects(self._batch_send(GetIdentifiedObjectsRequest(), mrids), timeout=self.timeout)
async for response in responses:
for nio in response.identifiedObjects:
yield self._extract_identified_object("network", nio, _nio_type_to_cim)
async def _handle_network_hierarchy(self):
response = await self._stub.getNetworkHierarchy(GetNetworkHierarchyRequest(), timeout=self.timeout)
# noinspection PyArgumentList
self.__network_hierarchy = NetworkHierarchy(
self._to_map(response.geographicalRegions, GeographicalRegion),
self._to_map(response.subGeographicalRegions, SubGeographicalRegion),
self._to_map(response.substations, Substation),
self._to_map(response.feeders, Feeder),
self._to_map(response.circuits, Circuit),
self._to_map(response.loops, Loop)
)
return self.__network_hierarchy
async def _handle_multi_object_rpc(self, processor: Callable[[], AsyncGenerator[IdentifiedObject, None]]) -> GrpcResult[MultiObjectResult]:
result = MultiObjectResult()
async def rpc():
async for io, _mrid in processor():
if io:
result.objects[io.mrid] = io
else:
result.failed.add(_mrid)
return result
return await self.try_rpc(rpc)
async def _get_with_references(self,
mrid: str,
expected_class: type(Generic[CIM_IO]),
get_additional: Callable[[Generic[CIM_IO], MultiObjectResult], Awaitable[Optional[GrpcResult[MultiObjectResult]]]]
) -> GrpcResult[MultiObjectResult]:
if not self.__network_hierarchy:
response = await self._get_network_hierarchy()
if response.was_failure:
# noinspection PyArgumentList
return GrpcResult(response.thrown, response.was_error_handled)
io = self.service.get(mrid, default=None)
if not io:
response = await self._get_identified_object(mrid)
if response.was_failure:
# noinspection PyArgumentList
return GrpcResult(response.thrown, response.was_error_handled)
io = response.value
if not isinstance(io, expected_class):
e = ValueError(f"Requested mrid {mrid} was not a {expected_class.__name__}, was {type(io).__name__}")
# noinspection PyArgumentList
return GrpcResult(e, self.try_handle_error(e))
mor = MultiObjectResult()
mor.objects[io.mrid] = io
error = await get_additional(io, mor)
if error:
return error
error = await self._resolve_references(mor)
if error:
return error
# noinspection PyArgumentList
return GrpcResult(mor)
async def _resolve_references(self, mor: MultiObjectResult) -> Optional[GrpcResult[MultiObjectResult]]:
res = mor
keep_processing = True
while keep_processing:
to_resolve = set()
for obj in res.objects:
for ref in self.service.get_unresolved_references_from(obj):
to_resolve.add(ref.to_mrid)
response = await self._get_identified_objects(to_resolve)
if response.was_failure:
# noinspection PyArgumentList
return GrpcResult(response.thrown, response.was_error_handled)
res = response.value
mor.objects.update(res.objects)
mor.failed.update(res.failed)
keep_processing = bool(res.objects)
return None
def _to_map(self, objects: Iterable[Generic[PB_IO]], class_: type(Generic[CIM_IO])) -> Dict[str, CIM_IO]:
result = {}
for pb in objects:
# noinspection PyUnresolvedReferences
cim = self.service.get(pb.mrid(), class_, None) or self.service.add_from_pb(pb)
result[cim.mrid] = cim
return result
class SyncNetworkConsumerClient(NetworkConsumerClient):
"""Synchronised wrapper for :class:`NetworkConsumerClient`"""
def get_identified_object(self, mrid: str) -> GrpcResult[IdentifiedObject]:
return get_event_loop().run_until_complete(super().get_identified_object(mrid))
def get_identified_objects(self, mrids: Iterable[str]) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(super().get_identified_objects(mrids))
def get_equipment_for_container(self, mrid: str) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(super().get_equipment_for_container(mrid))
def get_current_equipment_for_feeder(self, mrid: str) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(super().get_current_equipment_for_feeder(mrid))
def get_equipment_for_restriction(self, mrid: str) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(super().get_equipment_for_restriction(mrid))
def get_terminals_for_connectivity_node(self, mrid: str) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(super().get_terminals_for_connectivity_node(mrid))
def get_network_hierarchy(self):
return get_event_loop().run_until_complete(super().get_network_hierarchy())
def get_feeder(self, mrid: str) -> GrpcResult[MultiObjectResult]:
warnings.warn('`get_feeder` is deprecated, prefer the more generic `get_equipment_container`', DeprecationWarning)
return get_event_loop().run_until_complete(super().get_equipment_container(mrid, Feeder))
def get_equipment_container(self, mrid: str, expected_class: type = EquipmentContainer) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(super().get_equipment_container(mrid, expected_class))
def get_equipment_for_loop(self, loop: Union[str, Loop]) -> GrpcResult[MultiObjectResult]:
# noinspection PyArgumentList
return get_event_loop().run_until_complete(super().get_equipment_for_loop(self, loop))
def get_all_loops(self) -> GrpcResult[MultiObjectResult]:
# noinspection PyArgumentList
return get_event_loop().run_until_complete(super().get_all_loops(self))
def retrieve_network(self) -> GrpcResult[Union[NetworkResult, Exception]]:
return get_event_loop().run_until_complete(super().retrieve_network())
_nio_type_to_cim = {
# IEC61968 ASSET INFO #
"cableInfo": CableInfo,
"noLoadTest": NoLoadTest,
"openCircuitTest": OpenCircuitTest,
"overheadWireInfo": OverheadWireInfo,
"powerTransformerInfo": PowerTransformerInfo,
"shortCircuitTest": ShortCircuitTest,
"shuntCompensatorInfo": ShuntCompensatorInfo,
"transformerEndInfo": TransformerEndInfo,
"transformerTankInfo": TransformerTankInfo,
# IEC61968 ASSETS #
"assetOwner": AssetOwner,
# IEC61968 COMMON #
"organisation": Organisation,
"location": Location,
"pole": Pole,
"streetlight": Streetlight,
# IEC61968 METERING #
"meter": Meter,
"usagePoint": UsagePoint,
# IEC61968 OPERATIONS #
"operationalRestriction": OperationalRestriction,
# IEC61970 BASE AUXILIARY EQUIPMENT #
"faultIndicator": FaultIndicator,
# IEC61970 BASE CORE #
"baseVoltage": BaseVoltage,
"connectivityNode": ConnectivityNode,
"feeder": Feeder,
"geographicalRegion": GeographicalRegion,
"site": Site,
"subGeographicalRegion": SubGeographicalRegion,
"substation": Substation,
"terminal": Terminal,
# IEC61970 BASE EQUIVALENTS #
"equivalentBranch": EquivalentBranch,
# IEC61970 BASE MEAS #
"accumulator": Accumulator,
"analog": Analog,
"control": Control,
"discrete": Discrete,
# IEC61970 BASE SCADA #
"remoteControl": RemoteControl,
"remoteSource": RemoteSource,
# IEC61970 BASE WIRES GENERATION PRODUCTION #
"batteryUnit": BatteryUnit,
"photoVoltaicUnit": PhotoVoltaicUnit,
"powerElectronicsWindUnit": PowerElectronicsWindUnit,
# IEC61970 BASE WIRES #
"acLineSegment": AcLineSegment,
"breaker": Breaker,
"busbarSection": BusbarSection,
"disconnector": Disconnector,
"energyConsumer": EnergyConsumer,
"energyConsumerPhase": EnergyConsumerPhase,
"energySource": EnergySource,
"energySourcePhase": EnergySourcePhase,
"fuse": Fuse,
"jumper": Jumper,
"junction": Junction,
"linearShuntCompensator": LinearShuntCompensator,
"loadBreakSwitch": LoadBreakSwitch,
"perLengthSequenceImpedance": PerLengthSequenceImpedance,
"powerElectronicsConnection": PowerElectronicsConnection,
"powerElectronicsConnectionPhase": PowerElectronicsConnectionPhase,
"powerTransformer": PowerTransformer,
"powerTransformerEnd": PowerTransformerEnd,
"ratioTapChanger": RatioTapChanger,
"recloser": Recloser,
"transformerStarImpedance": TransformerStarImpedance,
# IEC61970 InfIEC61970 FEEDER #
"circuit": Circuit,
"loop": Loop
} | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/streaming/get/network_consumer.py | network_consumer.py |
from __future__ import annotations
from abc import abstractmethod
from typing import Iterable, Dict, Set, TypeVar, Generic, Tuple, Optional, AsyncGenerator, Type, Generator
from dataclassy import dataclass
from zepben.evolve import BaseService, IdentifiedObject, UnsupportedOperationException
from zepben.evolve.streaming.grpc.grpc import GrpcClient, GrpcResult
__all__ = ["CimConsumerClient", "MultiObjectResult"]
@dataclass()
class MultiObjectResult(object):
objects: Dict[str, IdentifiedObject] = dict()
failed: Set[str] = set()
ServiceType = TypeVar('ServiceType', bound=BaseService)
PBIdentifiedObject = TypeVar('PBIdentifiedObject')
GrpcRequest = TypeVar('GrpcRequest')
class CimConsumerClient(GrpcClient, Generic[ServiceType]):
"""
Base class that defines some helpful functions when producer clients are sending to the server.
## WARNING ##
The :class:`MultiObjectResult` operations below are not atomic upon a :class:`BaseService`, and thus if processing fails partway through, any
previously successful additions will have been processed by the service, and thus you may have an incomplete service. Also note that adding to the
service may not occur for an object if another object with the same mRID is already present in service. `MultiObjectResult.failed` can be used to
check for mRIDs that were not found or retrieved but not added to service (this should not be the case unless you are processing things concurrently).
Parameters
T: The base service to send objects from.
"""
@property
@abstractmethod
def service(self) -> ServiceType:
"""
The service to store all retrieved objects in.
"""
raise NotImplementedError()
async def get_identified_object(self, mrid: str) -> GrpcResult[IdentifiedObject]:
"""
Retrieve the object with the given `mRID` and store the result in the `service`.
Exceptions that occur during sending will be caught and passed to all error handlers that have been registered by `addErrorHandler`.
Returns a :class:`GrpcResult` with a result of one of the following:
- When `GrpcResult.wasSuccessful`, the item found, accessible via `GrpcResult.value`.
- When `GrpcResult.wasFailure`, the error that occurred retrieving or processing the the object, accessible via `GrpcResult.thrown`. One of:
- :class:`NoSuchElementException` if the object could not be found.
- The gRPC error that occurred while retrieving the object
"""
return await self._get_identified_object(mrid)
async def get_identified_objects(self, mrids: Iterable[str]) -> GrpcResult[MultiObjectResult]:
"""
Retrieve the objects with the given `mRIDs` and store the results in the `service`.
Exceptions that occur during processing will be caught and passed to all error handlers that have been registered by `addErrorHandler`.
@return A :class:`GrpcResult` with a result of one of the following:
- When `GrpcResult.wasSuccessful`, a map containing the retrieved objects keyed by mRID, accessible via `GrpcResult.value`. If an item was not
found, or couldn't be added to `service`, it will be excluded from the map and its mRID will be present in `MultiObjectResult.failed`
(see `BaseService.add`).
- When `GrpcResult.wasFailure`, the error that occurred retrieving or processing the object, accessible via `GrpcResult.thrown`.
Note the :class:`CimConsumerClient` warning in this case.
"""
return await self._get_identified_objects(mrids)
async def _get_identified_object(self, mrid: str) -> GrpcResult[Optional[IdentifiedObject]]:
async def rpc():
async for io, _ in self._process_identified_objects([mrid]):
return io
else:
raise ValueError(f"No object with mRID {mrid} could be found.")
return await self.try_rpc(rpc)
async def _get_identified_objects(self, mrids: Iterable[str]) -> GrpcResult[MultiObjectResult]:
async def rpc():
return await self._process_extract_results(mrids, self._process_identified_objects(set(mrids)))
return await self.try_rpc(rpc)
@abstractmethod
async def _process_identified_objects(self, mrids: Iterable[str]) -> AsyncGenerator[Tuple[Optional[IdentifiedObject], str], None]:
#
# NOTE: this is a stupid test that is meant to fail to make sure we never yield, but we need to have the yield to make it return the generator.
#
if self is None:
yield
raise NotImplementedError()
CIM_TYPE = TypeVar("CIM_TYPE", bound=IdentifiedObject)
def _extract_identified_object(self,
desc: str,
pb_io: PBIdentifiedObject,
pb_type_to_cim: Dict[str, Type[CIM_TYPE]],
check_presence: bool = True) -> Tuple[Optional[IdentifiedObject], str]:
"""
Add a :class:`CustomerIdentifiedObject` to the service. Will convert from protobuf to CIM type.
Parameters
- `pb_io` - The wrapped identified object returned by the server.
- `pb_type_to_cim` - The mapping of wrapped identified object types to CIM objects.
- `check_presence` - Whether to check if `cio` already exists in the service and skip if it does.
Raises :class:`UnsupportedOperationException` if `pb_io` was invalid/unset.
"""
io_type = pb_io.WhichOneof("identifiedObject")
if io_type:
cim_type = pb_type_to_cim.get(io_type, None)
if cim_type is None:
raise UnsupportedOperationException(f"Identified object type '{io_type}' is not supported by the {desc} service")
pb = getattr(pb_io, io_type)
if check_presence:
cim = self.service.get(pb.mrid(), cim_type, default=None)
if cim is not None:
return cim, cim.mrid
# noinspection PyUnresolvedReferences
return self.service.add_from_pb(pb), pb.mrid()
else:
raise UnsupportedOperationException(f"Received a {desc} identified object where no field was set")
@staticmethod
async def _process_extract_results(mrids: Iterable[str], extracted: AsyncGenerator[Tuple[Optional[IdentifiedObject], str], None]) -> MultiObjectResult:
results = {}
failed = set(mrids)
async for result in extracted:
if result[0] is not None:
results[result[0].mrid] = result[0]
failed.remove(result[0].mrid)
return MultiObjectResult(results, failed)
@staticmethod
def _batch_send(request: GrpcRequest, mrids: Iterable[str]) -> Generator[GrpcRequest, None, None]:
count = 0
for mrid in mrids:
count += 1
if count % 1000 == 0:
yield request
del request.mrids[:]
request.mrids.append(mrid)
if request.mrids:
yield request | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/streaming/get/consumer.py | consumer.py |
from __future__ import annotations
from asyncio import get_event_loop
from typing import Optional, Iterable, AsyncGenerator, List, Callable, Tuple
from zepben.evolve import DiagramService, IdentifiedObject, Diagram, DiagramObject
from zepben.evolve.streaming.get.consumer import CimConsumerClient, MultiObjectResult
from zepben.evolve.streaming.grpc.grpc import GrpcResult
from zepben.protobuf.dc.dc_pb2_grpc import DiagramConsumerStub
from zepben.protobuf.dc.dc_requests_pb2 import GetIdentifiedObjectsRequest
__all__ = ["DiagramConsumerClient", "SyncDiagramConsumerClient"]
class DiagramConsumerClient(CimConsumerClient[DiagramService]):
"""
Consumer client for a :class:`DiagramService`.
## WARNING ##
The :class:`MultiObjectResult` operations below are not atomic upon a :class:`DiagramService`, and thus if processing fails partway through, any
previously successful additions will have been processed by the service, and thus you may have an incomplete service. Also note that adding to the
service may not occur for an object if another object with the same mRID is already present in service. `MultiObjectResult.failed` can be used to
check for mRIDs that were not found or retrieved but not added to service (this should not be the case unless you are processing things concurrently).
"""
__service: DiagramService
@property
def service(self) -> DiagramService:
return self.__service
_stub: DiagramConsumerStub = None
def __init__(self, channel=None, stub: DiagramConsumerStub = None, error_handlers: List[Callable[[Exception], bool]] = None, timeout: int = 60):
super().__init__(error_handlers=error_handlers, timeout=timeout)
if channel is None and stub is None:
raise ValueError("Must provide either a channel or a stub")
if stub is not None:
self._stub = stub
else:
self._stub = DiagramConsumerStub(channel)
self.__service = DiagramService()
async def _process_identified_objects(self, mrids: Iterable[str]) -> AsyncGenerator[Tuple[Optional[IdentifiedObject], str], None]:
if not mrids:
return
responses = self._stub.getIdentifiedObjects(self._batch_send(GetIdentifiedObjectsRequest(), mrids), timeout=self.timeout)
for response in responses:
for dio in response.identifiedObjects:
yield self._extract_identified_object("diagram", dio, _dio_type_to_cim)
class SyncDiagramConsumerClient(DiagramConsumerClient):
def get_identified_object(self, mrid: str) -> GrpcResult[Optional[IdentifiedObject]]:
return get_event_loop().run_until_complete(super()._get_identified_objects(mrid))
def get_identified_objects(self, mrids: Iterable[str]) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(super()._get_identified_objects(mrids))
_dio_type_to_cim = {
"diagram": Diagram,
"diagramObject": DiagramObject
} | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/streaming/get/diagram_consumer.py | diagram_consumer.py |
from __future__ import annotations
from typing import TypeVar, Generic, Callable, List, Union, Coroutine
from dataclassy import dataclass
__all__ = ["GrpcResult", "GrpcClient"]
T = TypeVar("T")
@dataclass(slots=True)
class GrpcResult(Generic[T]):
result: Union[T, Exception]
was_error_handled: bool = False
@property
def value(self) -> T:
if self.result is not None and isinstance(self.result, Exception):
raise TypeError("You can only call value on a successful result.")
return self.result
@property
def thrown(self) -> Exception:
if self.result is None or not isinstance(self.result, Exception):
raise TypeError("You can only call thrown on an unsuccessful result.")
return self.result
@property
def was_successful(self):
return not self.was_failure
@property
def was_failure(self):
return isinstance(self.result, Exception)
@property
def was_error_unhandled(self):
return not self.was_error_handled
def on_success(self, handler: Callable[[T], None]) -> GrpcResult[T]:
"""Calls `handler` with the `result` if this `was_successful`"""
if self.was_successful:
handler(self.result)
return self
def on_error(self, handler: Callable[[Exception, bool], GrpcResult[T]]) -> GrpcResult[T]:
"""Calls `handler` with the `thrown` exception and `self.was_error_handled` if `self.was_failure`."""
if self.was_failure and self.was_error_handled:
return handler(self.result, self.was_error_handled)
return self
def on_handled_error(self, handler: Callable[[Exception], None]) -> GrpcResult[T]:
"""Calls `handler` with the `thrown` exception if `self.was_failure` only if `self.was_error_handled`."""
if self.was_failure and self.was_error_handled:
handler(self.result)
return self
def on_unhandled_error(self, handler: Callable[[Exception], None]) -> GrpcResult[T]:
"""Calls `handler` with the `thrown` exception if `self.was_failure` only if not `self.was_error_handled`."""
if self.was_failure and not self.was_error_handled:
handler(self.result)
return self
def throw_on_error(self) -> GrpcResult[T]:
"""Throws `self.result` if `self.was_failure`"""
if self.was_failure:
raise self.result
return self
def throw_on_unhandled_error(self) -> GrpcResult[T]:
"""Throws `self.result` only if `self.was_failure` and not `self.was_error_handled`"""
if self.was_failure and not self.was_error_handled:
raise self.result
return self
@dataclass(init=False, slots=True)
class GrpcClient(object):
error_handlers: List[Callable[[Exception], bool]] = []
timeout: int = 0
'''Timeout for client gRPC requests'''
def __init__(self, error_handlers: List[Callable[[Exception], bool]] = None, timeout: int = 60):
if error_handlers:
self.error_handlers = error_handlers.copy()
else:
self.error_handlers = list()
self.timeout = timeout
def try_handle_error(self, e: Exception) -> bool:
for handler in self.error_handlers:
if handler(e):
return True
return False
async def try_rpc(self, rpc: Callable[[], Coroutine[None, None, T]]) -> GrpcResult[T]:
try:
return GrpcResult(await rpc())
except Exception as e:
return GrpcResult(e, self.try_handle_error(e)) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/streaming/grpc/grpc.py | grpc.py |
import contextlib
import warnings
from typing import Optional, BinaryIO
from urllib.parse import urlparse
import grpc
from zepben.auth.client import ZepbenTokenFetcher, AuthMethod, create_token_fetcher
from zepben.evolve import GrpcChannelBuilder
__all__ = ["connect", "connect_async", "connect_tls", "connect_insecure", "connect_with_password", "connect_with_secret"]
from zepben.evolve.streaming.grpc.channel_builder import AuthTokenPlugin
GRPC_READY_TIMEOUT = 20 # seconds
def _secure_grpc_channel_builder(host: str = "localhost", rpc_port: int = 50051, ca=None) -> GrpcChannelBuilder:
return GrpcChannelBuilder() \
.socket_address(host, rpc_port) \
.make_secure(root_certificates=ca)
def _insecure_grpc_channel_builder(host: str = "localhost", rpc_port: int = 50051) -> GrpcChannelBuilder:
return GrpcChannelBuilder() \
.socket_address(host, rpc_port)
def _grpc_channel_builder_from_secret(host: str, rpc_port: int, client_id: str, client_secret: str, token_fetcher: ZepbenTokenFetcher,
ca=None) -> GrpcChannelBuilder:
token_fetcher.token_request_data.update({
'client_id': client_id,
'client_secret': client_secret,
'grant_type': 'client_credentials'
})
return _secure_grpc_channel_builder(host, rpc_port, ca).token_fetcher(token_fetcher)
def _grpc_channel_builder_from_password(client_id: str, username: str, password: str, host: str, rpc_port: int, token_fetcher: ZepbenTokenFetcher,
ca=None) -> GrpcChannelBuilder:
token_fetcher.token_request_data.update({
'client_id': client_id,
'username': username,
'password': password,
'grant_type': 'password',
'scope': 'offline_access'
})
return _secure_grpc_channel_builder(host, rpc_port, ca).token_fetcher(token_fetcher)
def connect_tls(host: str = "localhost", rpc_port: int = 50051, ca: BinaryIO = None) -> grpc.aio.Channel:
"""
Connect to a Zepben gRPC service using TLS.
`host` The host to connect to.
`rpc_port` The gRPC port for host.
`ca` The CA to use for certificate verification of the server.
Returns a gRPC channel
"""
return _secure_grpc_channel_builder(host, rpc_port, ca).build()
def connect_insecure(host: str = "localhost", rpc_port: int = 50051) -> grpc.aio.Channel:
"""
Connect to a Zepben gRPC service without auth and without HTTPS.
`host` The host to connect to.
`rpc_port` The gRPC port for host.
Returns a gRPC channel
"""
return _insecure_grpc_channel_builder(host, rpc_port).build()
def connect_with_secret(client_id: str, client_secret: str, host: str = "localhost", rpc_port: int = 50051, conf_path: str = None,
ca: BinaryIO = None, **kwargs) -> grpc.aio.Channel:
"""
Connect to a Zepben gRPC service using a client id and secret.
`client_id` Your client id for your OAuth Auth provider.
`client_secret` Corresponding client secret if required.
`host` The host to connect to.
`rpc_port` The gRPC port for host.
`conf_path` The path for the auth configuration endpoint. This is used when a `token_fetcher` is not provided. Defaults to checking /auth and /ewb/auth
`ca` The CA to use for certificate verification of the server.
`**kwargs` Keyword Arguments to be passed to ZepbenTokenFetcher initialiser if `conf_path` is None, or can include `port` for the config server if
`conf_path` is set.
Raises ValueError if the token_fetcher could not be configured
Returns a gRPC channel
"""
token_fetcher = None
errors = None
if conf_path:
# TODO EWB-1417 pass through CA (extract from kwargs) for auth conf verification
token_fetcher = create_token_fetcher(host, port=kwargs.get("port", 443), path=conf_path)
else:
try:
token_fetcher = create_token_fetcher(host)
except Exception as e:
errors = e
if {"audience", "issuer_domain", "auth_method"} <= kwargs.keys():
# noinspection PyArgumentList
token_fetcher = ZepbenTokenFetcher(**kwargs)
if not token_fetcher:
if errors:
raise ValueError(f"Failed to connect to {host}:{rpc_port}, did you pass a correct conf_path?")
else:
raise ValueError("token_fetcher could not be created, this is likely a bug.")
return _grpc_channel_builder_from_secret(host, rpc_port, client_id, client_secret, token_fetcher, ca).build()
def connect_with_password(client_id: str, username: str, password: str, host: str = "localhost", rpc_port: int = 50051, conf_path: Optional[str] = None,
ca: BinaryIO = None, **kwargs) -> grpc.aio.Channel:
"""
Connect to a Zepben gRPC service using credentials.
`client_id` Your client id for your OAuth Auth provider.
`username` The username to use for an OAuth password grant.
`password` Corresponding password.
`host` The host to connect to.
`rpc_port` The gRPC port for host.
`conf_path` The path for the auth configuration endpoint. This is used when a `token_fetcher` is not provided. Defaults to checking /auth and /ewb/auth
`ca` The CA to use for certificate verification of the server.
`**kwargs` Keyword Arguments to be passed to ZepbenTokenFetcher initialiser if `conf_path` is None, or can include `port` for the config server if
`conf_path` is set.
Raises ValueError if the token_fetcher could not be configured
Returns a gRPC channel
"""
token_fetcher = None
errors = None
if conf_path:
# TODO EWB-1417 pass through CA (extract from kwargs) for auth conf verification
token_fetcher = create_token_fetcher(host, port=kwargs.get("port", 443), path=conf_path)
else:
try:
token_fetcher = create_token_fetcher(host)
except Exception as e:
errors = e
if {"audience", "issuer_domain", "auth_method"} <= kwargs.keys():
# noinspection PyArgumentList
token_fetcher = ZepbenTokenFetcher(**kwargs)
if not token_fetcher:
if errors:
raise ValueError(f"Failed to connect to {host}:{rpc_port}, did you pass a correct conf_path?")
else:
raise ValueError("token_fetcher could not be created, this is likely a bug.")
return _grpc_channel_builder_from_password(client_id, username, password, host, rpc_port, token_fetcher, ca).build()
def _conn(host: str = "localhost", rpc_port: int = 50051, conf_address: str = None, client_id: Optional[str] = None,
username: Optional[str] = None, password: Optional[str] = None, client_secret: Optional[str] = None, pkey=None, cert=None, ca=None,
token_fetcher: Optional[ZepbenTokenFetcher] = None, secure: bool = False, verify_auth_certificates=False, conf_ca=None, auth_ca=None):
"""
Connect to a Zepben gRPC service.
`host` The host to connect to.
`rpc_port` The gRPC port for host.
`conf_address` The complete address for the auth configuration endpoint. This is used when an `token_fetcher` is not provided.
Defaults to http://<host>/auth
`secure` True if SSL is required, False otherwise (default). Must be True for authentication settings to be utilised.
One of the following sets of arguments must be provided when authentication is configured on the server:
`client_id` and `client_secret` for client credentials based authentication (usually M2M tokens), or
`client_id`, `username`, and `password` for user credentials authentication. Note this is not recommended for untrusted and insecure servers as
user credentials will be sent to the server in the clear. Or,
`authenticator`, for custom connection options.
`client_id` Your client id for your OAuth Auth provider.
`client_secret` Corresponding client secret if required.
`username` The username to use for an OAuth password grant.
`password` Corresponding password. If both `username` and `password` are provided, it takes precedence over the above client credentials.
`token_fetcher` A token fetcher that can provide OAuth2 tokens the `host` can validate. If this is provided, it takes precedence over the above credentials.
`pkey` Private key for client authentication if client authentication is required.
`cert` Corresponding signed certificate if client authentication is required. CN must reflect your hosts FQDN, and must be signed by the servers CA.
`ca` CA trust for the server, or None to use OS default certificate bundle.
`verify_auth_certificate` Whether to authenticate the certificate from the authentication provider.
`auth_ca` Filename of CA bundle for the authentication provider, or None to use OS default certificate bundle.
Raises `ConnectionError` if unable to make a connection to the server.
Returns a gRPC channel
"""
if secure:
if conf_address is None:
conf_address = f"http://{host}/auth"
# Channel credential will be valid for the entire channel
channel_credentials = grpc.ssl_channel_credentials(ca, pkey, cert)
# parsing the conf_address to host port and path
parsed_url = urlparse(
conf_address
)
host = parsed_url.hostname
port = parsed_url.port
path = parsed_url.path
if token_fetcher:
call_credentials = grpc.metadata_call_credentials(AuthTokenPlugin(token_fetcher=token_fetcher))
# Combining channel credentials and call credentials together
composite_credentials = grpc.composite_channel_credentials(
channel_credentials,
call_credentials,
) if channel_credentials else call_credentials
channel = grpc.aio.secure_channel(f"{host}:{rpc_port}", composite_credentials)
elif client_id and username and password:
# Create a basic ClientCredentials authenticator
token_fetcher = create_token_fetcher(host, port, path, verify_auth_certificates, conf_ca_filename=conf_ca, auth_ca_filename=auth_ca)
token_fetcher.token_request_data.update({
'client_id': client_id,
'username': username,
'password': password,
'grant_type': 'password',
'scope': 'offline_access'
})
call_credentials = grpc.metadata_call_credentials(AuthTokenPlugin(token_fetcher))
# Combining channel credentials and call credentials together
composite_credentials = grpc.composite_channel_credentials(
channel_credentials,
call_credentials,
) if channel_credentials else call_credentials
channel = grpc.aio.secure_channel(f"{host}:{rpc_port}", composite_credentials)
elif client_id and client_secret:
# Create a basic ClientCredentials authenticator
token_fetcher = create_token_fetcher(host, port, path, verify_auth_certificates, conf_ca_filename=conf_ca, auth_ca_filename=auth_ca)
token_fetcher.token_request_data.update({'client_id': client_id, 'client_secret': client_secret, 'grant_type': 'client_credentials'})
call_credentials = grpc.metadata_call_credentials(AuthTokenPlugin(token_fetcher))
# Combining channel credentials and call credentials together
composite_credentials = grpc.composite_channel_credentials(
channel_credentials,
call_credentials,
) if channel_credentials else call_credentials
channel = grpc.aio.secure_channel(f"{host}:{rpc_port}", composite_credentials)
else:
channel = grpc.aio.secure_channel(f"{host}:{rpc_port}", channel_credentials)
else:
if client_id or client_secret or username or password or pkey or cert:
warnings.warn("An insecure connection is being used but some credentials were specified for connecting, did you forget to set secure=True?")
channel = grpc.aio.insecure_channel(f"{host}:{rpc_port}")
return channel
@contextlib.contextmanager
def connect(host: str = "localhost",
rpc_port: int = 50051,
conf_address: str = None,
client_id: Optional[str] = None,
client_secret: Optional[str] = None,
username: Optional[str] = None,
password: Optional[str] = None,
pkey=None,
cert=None,
ca=None,
token_fetcher: Optional[ZepbenTokenFetcher] = None,
secure=False,
verify_auth_certificates=False,
conf_ca=None,
auth_ca=None):
"""
Connect to a Zepben gRPC service.
`host` The host to connect to.
`rpc_port` The gRPC port for host.
`conf_address` The complete address for the auth configuration endpoint. This is used when an `token_fetcher` is not provided.
Defaults to http://<host>/auth
`secure` True if SSL is required, False otherwise (default). Must be True for authentication settings to be utilised.
One of the following sets of arguments must be provided when authentication is configured on the server:
`client_id` and `client_secret` for client credentials based authentication (usually M2M tokens), or
`client_id`, `username`, and `password` for user credentials authentication. Note this is not recommended for untrusted and insecure servers as
user credentials will be sent to the server in the clear. Or,
`authenticator`, for custom connection options.
`client_id` Your client id for your OAuth Auth provider.
`client_secret` Corresponding client secret if required.
`username` The username to use for an OAuth password grant.
`password` Corresponding password. If both `username` and `password` are provided, it takes precedence over the above client credentials.
`token_fetcher` A token fetcher that can provide OAuth2 tokens the `host` can validate. If this is provided, it takes precedence over the above credentials.
`pkey` Private key for client authentication if client authentication is required.
`cert` Corresponding signed certificate if client authentication is required. CN must reflect your hosts FQDN, and must be signed by the servers CA.
`ca` CA trust for the server, or None to use OS default certificate bundle.
`verify_auth_certificate` Whether to authenticate the certificate from the authentication provider.
`auth_ca` Filename of CA bundle for the authentication provider, or None to use OS default certificate bundle.
Raises `ConnectionError` if unable to make a connection to the server.
Returns a gRPC channel
"""
warnings.warn('The connect function is deprecated. It will be replaced with other functions like connect_secure.', DeprecationWarning, stacklevel=2)
yield _conn(host, rpc_port, conf_address, client_id, username, password, client_secret, pkey, cert, ca, token_fetcher, secure, verify_auth_certificates,
conf_ca, auth_ca)
@contextlib.asynccontextmanager
async def connect_async(host: str = "localhost",
rpc_port: int = 50051,
conf_address: str = None,
client_id: Optional[str] = None,
client_secret: Optional[str] = None,
username: Optional[str] = None,
password: Optional[str] = None,
pkey=None,
cert=None,
ca=None,
token_fetcher: Optional[ZepbenTokenFetcher] = None,
secure=False,
verify_auth_certificates=False,
conf_ca=None,
auth_ca=None):
"""
Connect to a Zepben gRPC service.
`host` The host to connect to.
`rpc_port` The gRPC port for host.
`conf_address` The complete address for the auth configuration endpoint. This is used when an `token_fetcher` is not provided.
Defaults to http://<host>/auth
`secure` True if SSL is required, False otherwise (default). Must be True for authentication settings to be utilised.
One of the following sets of arguments must be provided when authentication is configured on the server:
`client_id` and `client_secret` for client credentials based authentication (usually M2M tokens), or
`client_id`, `username`, and `password` for user credentials authentication. Note this is not recommended for untrusted and insecure servers as
user credentials will be sent to the server in the clear. Or,
`authenticator`, for custom connection options.
`client_id` Your client id for your OAuth Auth provider.
`client_secret` Corresponding client secret if required.
`username` The username to use for an OAuth password grant.
`password` Corresponding password. If both `username` and `password` are provided, it takes precedence over the above client credentials.
`token_fetcher` A token fetcher that can provide OAuth2 tokens the `host` can validate. If this is provided, it takes precedence over the above credentials.
`pkey` Private key for client authentication if client authentication is required.
`cert` Corresponding signed certificate if client authentication is required. CN must reflect your hosts FQDN, and must be signed by the servers CA.
`ca` CA trust for the server, or None to use OS default certificate bundle.
`verify_auth_certificate` Whether to authenticate the certificate from the authentication provider.
`auth_ca` Filename of CA bundle for the authentication provider, or None to use OS default certificate bundle.
Raises `ConnectionError` if unable to make a connection to the server.
Returns a gRPC channel
"""
warnings.warn('The connect_async function is deprecated. It will be replaced with other functions like connect_secure_async.',
DeprecationWarning, stacklevel=2)
yield _conn(host, rpc_port, conf_address, client_id, username, password, client_secret, pkey, cert, ca, token_fetcher, secure, verify_auth_certificates,
conf_ca, auth_ca) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/streaming/grpc/connect.py | connect.py |
from abc import ABC
from typing import Optional
import grpc
from zepben.auth.client import ZepbenTokenFetcher
__all__ = ["GrpcChannelBuilder", "AuthTokenPlugin"]
_AUTH_HEADER_KEY = 'authorization'
class AuthTokenPlugin(grpc.AuthMetadataPlugin):
def __init__(self, token_fetcher: ZepbenTokenFetcher):
self.token_fetcher = token_fetcher
def __call__(self, context, callback):
token = self.token_fetcher.fetch_token()
if token:
callback(((_AUTH_HEADER_KEY, token),), None)
else:
callback()
class GrpcChannelBuilder(ABC):
def __init__(self):
self._socket_address: str = "localhost:50051"
self._channel_credentials: Optional[grpc.ChannelCredentials] = None
def build(self) -> grpc.aio.Channel:
if self._channel_credentials:
return grpc.aio.secure_channel(self._socket_address, self._channel_credentials)
return grpc.aio.insecure_channel(self._socket_address)
def socket_address(self, host: str, port: int) -> 'GrpcChannelBuilder':
self._socket_address = f"{host}:{port}"
return self
def make_secure(
self,
root_certificates: Optional[bytes] = None,
private_key: Optional[bytes] = None,
certificate_chain: Optional[bytes] = None
) -> 'GrpcChannelBuilder':
"""
Secures channel with SSL credentials.
"""
self._channel_credentials = grpc.ssl_channel_credentials(root_certificates, private_key, certificate_chain)
return self
def token_fetcher(self, token_fetcher: ZepbenTokenFetcher) -> 'GrpcChannelBuilder':
if self._channel_credentials is None:
raise Exception("Attempted to set call credentials before channel credentials.")
self._channel_credentials = grpc.composite_channel_credentials(
self._channel_credentials,
grpc.metadata_call_credentials(AuthTokenPlugin(token_fetcher=token_fetcher))
)
return self | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/streaming/grpc/channel_builder.py | channel_builder.py |
from __future__ import annotations
import itertools
import logging
from enum import Enum
from typing import TYPE_CHECKING, Dict, List, Union, Iterable
from zepben.evolve.model.cim.iec61970.base.core.phase_code import PhaseCode
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node import ConnectivityNode
from zepben.evolve.services.common.base_service import BaseService
from zepben.evolve.services.network.tracing.connectivity.terminal_connectivity_connected import TerminalConnectivityConnected
from pathlib import Path
if TYPE_CHECKING:
from zepben.evolve import Terminal, SinglePhaseKind, ConnectivityResult, Measurement, ConductingEquipment
__all__ = ["connect", "connected_terminals", "connected_equipment", "NetworkService"]
logger = logging.getLogger(__name__)
TRACED_NETWORK_FILE = str(Path.home().joinpath(Path("traced.json")))
class ProcessStatus(Enum):
PROCESSED = 0
INVALID = 1
SKIPPED = 2
def connect(terminal: Terminal, connectivity_node: ConnectivityNode):
"""
Connect a `zepben.evolve.iec61970.base.core.terminal.Terminal`` to a `ConnectivityNode`
`terminal` The `zepben.evolve.iec61970.base.core.terminal.Terminal` to connect.
`connectivity_node` The `ConnectivityNode` to connect ``zepben.evolve.iec61970.base.core.terminal.Terminal` to.
"""
terminal.connect(connectivity_node)
connectivity_node.add_terminal(terminal)
def connected_terminals(terminal: Terminal, phases: Union[None, PhaseCode, Iterable[SinglePhaseKind]] = None) -> List[ConnectivityResult]:
"""
Find the connected `Terminal`s for the specified `terminal` using only the phases of the specified `phaseCode`.
@param terminal: The `Terminal` to process.
@param phases: Which phases should be used for the connectivity check. If omitted, the phases of `terminal` will be used.
@return: A list of `ConnectivityResult` specifying the connections between `terminal` and the connected `Terminal`s
"""
phases = phases or terminal.phases
if isinstance(phases, PhaseCode):
phases = phases.single_phases
return TerminalConnectivityConnected().connected_terminals(terminal, phases)
def connected_equipment(conducting_equipment: ConductingEquipment,
phases: Union[None, PhaseCode, Iterable[SinglePhaseKind]] = None) -> List[ConnectivityResult]:
"""
Find the connected `ConductingEquipment` for each `Terminal` of `conductingEquipment` using only the specified `phases`.
@param conducting_equipment: The `ConductingEquipment` to process.
@param phases: Which phases should be used for the connectivity check. If omitted,
all valid phases will be used.
@return: A list of `ConnectivityResult` specifying the connections between `conductingEquipment` and the connected `ConductingEquipment`
"""
if isinstance(phases, PhaseCode):
phases = phases.single_phases
return list(itertools.chain(*(connected_terminals(term, phases) for term in conducting_equipment.terminals)))
def _attempt_to_reuse_connection(terminal1: Terminal, terminal2: Terminal) -> ProcessStatus:
"""
Attempt to connect two `zepben.evolve.iec61970.base.core.terminal.Terminal`s.
Returns `ProcessStatus` reflecting whether the connection was reused. PROCESSED if a connection was
established, INVALID if it couldn't be, and SKIPPED if neither terminal had an existing `ConnectivityNode`.
"""
cn1 = terminal1.connectivity_node
cn2 = terminal2.connectivity_node
if cn1 is not None:
if cn2 is not None:
if cn1 is cn2:
return ProcessStatus.PROCESSED
elif connect(terminal2, cn1):
return ProcessStatus.PROCESSED
return ProcessStatus.INVALID
elif cn2 is not None:
return ProcessStatus.PROCESSED if connect(terminal1, cn2) else ProcessStatus.INVALID
return ProcessStatus.SKIPPED
class NetworkService(BaseService):
"""
A full representation of the power network.
Contains a map of equipment (string ID's -> Equipment/Nodes/etc)
**All** `IdentifiedObject's` submitted to this Network **MUST** have unique mRID's!
Attributes -
metrics_store : Storage for meter measurement data associated with this network.
"""
name: str = "network"
_connectivity_nodes: Dict[str, ConnectivityNode] = dict()
_auto_cn_index: int = 0
_measurements: Dict[str, List[Measurement]] = []
def __init__(self):
self._objects_by_type[ConnectivityNode] = self._connectivity_nodes
def get_measurements(self, mrid: str, t: type) -> List[Measurement]:
"""
Get all measurements of type `t` associated with the given `mrid`.
The `mrid` should be either a `zepben.evolve.iec61970.base.core.power_system_resource.PowerSystemResource` or a
`zepben.evolve.iec61970.base.core.terminal.Terminal` MRID that is assigned to the corresponding fields on the measurements.
Returns all `Measurement`s indexed by `mrid` in this service.
Raises `KeyError` if `mrid` isn't present in this service.
"""
# noinspection PyTypeChecker
return [meas for meas in self._measurements[mrid] if isinstance(meas, t)]
def add_measurement(self, measurement: Measurement) -> bool:
"""
Add a `zepben.evolve.cim.iec61970.base.meas.measurement.Measurement` to this `NetworkService`
`measurement` The `Measurement` to add.
Returns `True` if `measurement` was added, `False` otherwise
"""
return self._index_measurement(measurement, measurement.mrid) and self.add(measurement)
def remove_measurement(self, measurement) -> bool:
"""
Remove a `zepben.evolve.cim.iec61970.base.meas.measurement.Measurement` from this `NetworkService`
`measurement` The `Measurement` to remove.
Returns `True` if `measurement` was removed, `False` otherwise
"""
self._remove_measurement_index(measurement)
return self.remove(measurement)
def connect_by_mrid(self, terminal: Terminal, connectivity_node_mrid: str) -> bool:
"""
Connect a `zepben.evolve.iec61970.base.core.terminal.Terminal` to the `ConnectivityNode` with mRID `connectivity_node_mrid`
`terminal` The `zepben.evolve.iec61970.base.core.terminal.Terminal` to connect.
`connectivity_node_mrid` The mRID of the `ConnectivityNode`. Will be created in the `Network` if it
doesn't already exist.
Returns True if the connection was made or already existed, False if `zepben.evolve.iec61970.base.core.terminal.Terminal` was already connected to a
different `ConnectivityNode`
"""
if not connectivity_node_mrid:
return False
if terminal.connectivity_node:
return connectivity_node_mrid == terminal.connectivity_node.mrid
cn = self.add_connectivity_node(connectivity_node_mrid)
connect(terminal, cn)
return True
def connect_terminals(self, terminal1: Terminal, terminal2: Terminal) -> bool:
"""
Connect two `zepben.evolve.iec61970.base.core.terminal.Terminal`s
Returns True if the `zepben.evolve.iec61970.base.core.terminal.Terminal`s could be connected, False otherwise.
"""
status = _attempt_to_reuse_connection(terminal1, terminal2)
if status == ProcessStatus.PROCESSED:
return True
elif status == ProcessStatus.INVALID:
return False
cn = self.add_connectivity_node(self._generate_cn_mrid())
connect(terminal2, cn)
connect(terminal1, cn)
return True
def _generate_cn_mrid(self):
mrid = f"generated_cn_{self._auto_cn_index}"
while mrid in self._connectivity_nodes:
self._auto_cn_index += 1
mrid = f"generated_cn_{self._auto_cn_index}"
return mrid
def disconnect(self, terminal: Terminal):
"""
Disconnect a `zepben.evolve.iec61970.base.core.terminal.Terminal`` from its `ConnectivityNode`. Will also remove the `ConnectivityNode` from this
`Network` if it no longer has any terminals.
`terminal` The `zepben.evolve.iec61970.base.core.terminal.Terminal` to disconnect.
"""
cn = terminal.connectivity_node
if cn is None:
return
cn.remove_terminal(terminal)
terminal.disconnect()
if cn.num_terminals() == 0:
del self._connectivity_nodes[cn.mrid]
def disconnect_by_mrid(self, connectivity_node_mrid: str):
"""
Disconnect a `ConnectivityNode` from this `Network`. Will disconnect all ``zepben.evolve.iec61970.base.core.terminal.Terminal`s from the
`ConnectivityNode`
`connectivity_node_mrid` The mRID of the `ConnectivityNode` to disconnect.
Raises `KeyError` if there is no `ConnectivityNode` for `connectivity_node_mrid`
"""
cn = self._connectivity_nodes[connectivity_node_mrid]
if cn is not None:
for term in cn.terminals:
term.disconnect()
cn.clear_terminals()
del self._connectivity_nodes[connectivity_node_mrid]
def get_primary_sources(self):
"""
Get the primary source for this network. All directions are applied relative to this EnergySource
Returns The primary EnergySource
"""
# noinspection PyUnresolvedReferences
return [source for source in self._objects_by_type[EnergySource].values() if source.is_external_grid]
def add_connectivity_node(self, mrid: str):
"""
Add a connectivity node to the network.
`mrid` mRID of the ConnectivityNode
Returns A new ConnectivityNode with `mrid` if it doesn't already exist, otherwise the existing
ConnectivityNode represented by `mrid`
"""
if mrid not in self._connectivity_nodes:
self._connectivity_nodes[mrid] = ConnectivityNode(mrid=mrid)
return self._connectivity_nodes[mrid]
else:
return self._connectivity_nodes[mrid]
def _index_measurement(self, measurement: Measurement, mrid: str) -> bool:
if not mrid:
return False
if mrid in self._measurements:
for meas in self._measurements[mrid]:
if meas.mrid == measurement.mrid:
return False
else:
self._measurements[mrid].append(measurement)
return True
else:
self._measurements[mrid] = [measurement]
return True
def _remove_measurement_index(self, measurement: Measurement):
try:
self._measurements[measurement.terminal_mrid].remove(measurement)
except KeyError:
pass
try:
self._measurements[measurement.power_system_resource_mrid].remove(measurement)
except KeyError:
pass | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/network_service.py | network_service.py |
from dataclasses import dataclass
from typing import Callable, Optional, Any
from zepben.evolve import AcLineSegment, CableInfo, NoLoadTest, OpenCircuitTest, OverheadWireInfo, PowerTransformerInfo, ShortCircuitTest, TransformerEndInfo, \
TransformerTankInfo, TransformerTest, WireInfo, AssetOwner, Pole, Asset, Streetlight, Location, EndDevice, Meter, UsagePoint, OperationalRestriction, \
AuxiliaryEquipment, FaultIndicator, BaseVoltage, ConductingEquipment, ConnectivityNode, Equipment, EquipmentContainer, Feeder, GeographicalRegion, \
PowerSystemResource, Site, SubGeographicalRegion, Substation, Terminal, PowerElectronicsUnit, BatteryUnit, PhotoVoltaicUnit, PowerElectronicsWindUnit, \
Breaker, LoadBreakSwitch, BusbarSection, Conductor, Disconnector, EnergyConsumer, EnergyConsumerPhase, EnergySource, EnergySourcePhase, Fuse, Jumper, \
Junction, LinearShuntCompensator, PerLengthSequenceImpedance, PowerElectronicsConnection, PowerElectronicsConnectionPhase, PowerTransformer, \
PowerTransformerEnd, RatioTapChanger, Recloser, RegulatingCondEq, ShuntCompensator, TapChanger, TransformerEnd, TransformerStarImpedance, Circuit, \
Loop, SinglePhaseKind, ValueDifference, PhaseCode, Control, Measurement, Analog, Accumulator, Discrete, RemoteControl, RemoteSource, EquivalentBranch, \
Switch, ShuntCompensatorInfo
from zepben.evolve.services.common.base_service_comparator import BaseServiceComparator
from zepben.evolve.services.common.translator.service_differences import ObjectDifference
@dataclass
class NetworkServiceComparatorOptions:
compare_terminals: bool = True
compare_traced_phases: bool = True
compare_feeder_equipment: bool = True
compare_equipment_containers: bool = True
compare_lv_simplification: bool = True
#
# NOTE: The functions below are accessed by reflection rather than directly. Make sure you check the code coverage
# to ensure they are covered correctly.
#
class NetworkServiceComparator(BaseServiceComparator):
"""
Compare the objects supported by the network service.
"""
def __init__(self, options: NetworkServiceComparatorOptions = NetworkServiceComparatorOptions()):
"""
:param options: Indicates which optional checks to perform.
"""
super().__init__()
self._options = options
#######################
# IEC61968 ASSET INFO #
#######################
def _compare_cable_info(self, source: CableInfo, target: CableInfo) -> ObjectDifference:
return self._compare_wire_info(ObjectDifference(source, target))
def _compare_no_load_test(self, source: NoLoadTest, target: NoLoadTest) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, NoLoadTest.energised_end_voltage, NoLoadTest.loss, NoLoadTest.loss_zero)
self._compare_floats(diff, NoLoadTest.exciting_current, NoLoadTest.exciting_current_zero)
return self._compare_transformer_test(diff)
def _compare_open_circuit_test(self, source: OpenCircuitTest, target: OpenCircuitTest) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(
diff,
OpenCircuitTest.energised_end_step,
OpenCircuitTest.energised_end_voltage,
OpenCircuitTest.open_end_step,
OpenCircuitTest.open_end_voltage
)
self._compare_floats(diff, OpenCircuitTest.phase_shift)
return self._compare_transformer_test(diff)
def _compare_overhead_wire_info(self, source: OverheadWireInfo, target: OverheadWireInfo) -> ObjectDifference:
return self._compare_wire_info(ObjectDifference(source, target))
def _compare_power_transformer_info(self, source: PowerTransformerInfo, target: PowerTransformerInfo) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_reference_collections(diff, PowerTransformerInfo.transformer_tank_infos)
return self._compare_asset_info(diff)
def _compare_short_circuit_test(self, source: ShortCircuitTest, target: ShortCircuitTest) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(
diff,
ShortCircuitTest.energised_end_step,
ShortCircuitTest.grounded_end_step,
ShortCircuitTest.loss,
ShortCircuitTest.loss_zero,
ShortCircuitTest.power
)
self._compare_floats(
diff,
ShortCircuitTest.current,
ShortCircuitTest.leakage_impedance,
ShortCircuitTest.leakage_impedance_zero,
ShortCircuitTest.voltage,
ShortCircuitTest.voltage_ohmic_part
)
return self._compare_transformer_test(diff)
def _compare_shunt_compensator_info(self, source: ShuntCompensatorInfo, target: ShuntCompensatorInfo) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(
diff,
ShuntCompensatorInfo.max_power_loss,
ShuntCompensatorInfo.rated_current,
ShuntCompensatorInfo.rated_reactive_power,
ShuntCompensatorInfo.rated_voltage,
)
return self._compare_asset_info(diff)
def _compare_transformer_end_info(self, source: TransformerEndInfo, target: TransformerEndInfo) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(
diff,
TransformerEndInfo.transformer_star_impedance,
TransformerEndInfo.energised_end_no_load_tests,
TransformerEndInfo.energised_end_short_circuit_tests,
TransformerEndInfo.grounded_end_short_circuit_tests,
TransformerEndInfo.open_end_open_circuit_tests,
TransformerEndInfo.energised_end_open_circuit_tests
)
self._compare_values(
diff,
TransformerEndInfo.connection_kind,
TransformerEndInfo.emergency_s,
TransformerEndInfo.end_number,
TransformerEndInfo.insulation_u,
TransformerEndInfo.phase_angle_clock,
TransformerEndInfo.rated_s,
TransformerEndInfo.rated_u,
TransformerEndInfo.short_term_s
)
self._compare_floats(diff, TransformerEndInfo.r)
return self._compare_asset_info(diff)
def _compare_transformer_tank_info(self, source: TransformerTankInfo, target: TransformerTankInfo) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_reference_collections(diff, TransformerTankInfo.transformer_end_infos)
return self._compare_asset_info(diff)
def _compare_transformer_test(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(diff, TransformerTest.base_power)
self._compare_floats(diff, TransformerTest.temperature)
return self._compare_identified_object(diff)
def _compare_wire_info(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(diff, WireInfo.rated_current, WireInfo.material)
return self._compare_asset_info(diff)
###################
# IEC61968 ASSETS #
###################
def _compare_asset(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_id_references(diff, Asset.location)
self._compare_id_reference_collections(diff, Asset.organisation_roles)
return self._compare_identified_object(diff)
def _compare_asset_container(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_asset(diff)
def _compare_asset_info(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_identified_object(diff)
def _compare_asset_organisation_role(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_organisation_role(diff)
def _compare_asset_owner(self, source: AssetOwner, target: AssetOwner) -> ObjectDifference:
return self._compare_asset_organisation_role(ObjectDifference(source, target))
def _compare_pole(self, source: Pole, target: Pole) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, Pole.classification)
self._compare_id_reference_collections(diff, Pole.streetlights)
return self._compare_structure(diff)
def _compare_streetlight(self, source: Streetlight, target: Streetlight) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, Streetlight.light_rating, Streetlight.lamp_kind)
self._compare_id_references(diff, Streetlight.pole)
return self._compare_asset(diff)
def _compare_structure(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_asset_container(diff)
###################
# IEC61968 COMMON #
###################
def _compare_location(self, source: Location, target: Location) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, Location.main_address)
self._compare_indexed_value_collections(diff, Location.points)
return self._compare_identified_object(diff)
#####################
# IEC61968 METERING #
#####################
def _compare_end_device(self, diff: ObjectDifference) -> ObjectDifference:
if self._options.compare_lv_simplification:
self._compare_id_reference_collections(diff, EndDevice.usage_points)
self._compare_values(diff, EndDevice.customer_mrid)
self._compare_id_references(diff, EndDevice.service_location)
return self._compare_asset_container(diff)
def _compare_meter(self, source: Meter, target: Meter) -> ObjectDifference:
return self._compare_end_device(ObjectDifference(source, target))
def _compare_usage_point(self, source: UsagePoint, target: UsagePoint) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, UsagePoint.usage_point_location)
self._compare_values(diff, UsagePoint.is_virtual, UsagePoint.connection_category)
if self._options.compare_lv_simplification:
self._compare_id_reference_collections(diff, UsagePoint.equipment)
self._compare_id_reference_collections(diff, UsagePoint.end_devices)
return self._compare_identified_object(diff)
#######################
# IEC61968 OPERATIONS #
#######################
def _compare_operational_restriction(self, source: OperationalRestriction, target: OperationalRestriction) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_reference_collections(diff, OperationalRestriction.equipment)
return self._compare_document(diff)
#####################################
# IEC61970 BASE AUXILIARY EQUIPMENT #
#####################################
def _compare_auxiliary_equipment(self, diff: ObjectDifference) -> ObjectDifference:
if self._options.compare_terminals:
self._compare_id_references(diff, AuxiliaryEquipment.terminal)
return self._compare_equipment(diff)
def _compare_fault_indicator(self, source: FaultIndicator, target: FaultIndicator) -> ObjectDifference:
return self._compare_auxiliary_equipment(ObjectDifference(source, target))
######################
# IEC61970 BASE CORE #
######################
def _compare_ac_dc_terminal(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_identified_object(diff)
def _compare_base_voltage(self, source: BaseVoltage, target: BaseVoltage) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, BaseVoltage.nominal_voltage)
return self._compare_identified_object(diff)
def _compare_conducting_equipment(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_id_references(diff, ConductingEquipment.base_voltage)
if self._options.compare_terminals:
self._compare_indexed_id_reference_collections(diff, ConductingEquipment.terminals)
return self._compare_equipment(diff)
def _compare_connectivity_node(self, source: ConnectivityNode, target: ConnectivityNode) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_reference_collections(diff, ConnectivityNode.terminals)
return self._compare_identified_object(diff)
def _compare_connectivity_node_container(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_power_system_resource(diff)
def _compare_equipment(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(diff, Equipment.in_service, Equipment.normally_in_service)
if self._options.compare_equipment_containers:
self._compare_id_reference_collections(diff, Equipment.containers, Equipment.current_feeders)
if self._options.compare_lv_simplification:
self._compare_id_reference_collections(diff, Equipment.usage_points)
self._compare_id_reference_collections(diff, Equipment.operational_restrictions)
return self._compare_power_system_resource(diff)
def _compare_equipment_container(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_id_reference_collections(diff, EquipmentContainer.equipment)
return self._compare_connectivity_node_container(diff)
def _compare_feeder(self, source: Feeder, target: Feeder) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, Feeder.normal_head_terminal, Feeder.normal_energizing_substation)
if self._options.compare_feeder_equipment:
self._compare_id_reference_collections(diff, Feeder.current_equipment)
return self._compare_equipment_container(diff)
def _compare_geographical_region(self, source: GeographicalRegion, target: GeographicalRegion) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_reference_collections(diff, GeographicalRegion.sub_geographical_regions)
return self._compare_identified_object(diff)
def _compare_power_system_resource(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_id_references(diff, PowerSystemResource.asset_info, PowerSystemResource.location)
return self._compare_identified_object(diff)
def _compare_site(self, source: Site, target: Site) -> ObjectDifference:
return self._compare_equipment_container(ObjectDifference(source, target))
def _compare_sub_geographical_region(self, source: SubGeographicalRegion, target: SubGeographicalRegion) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, SubGeographicalRegion.geographical_region)
self._compare_id_reference_collections(diff, SubGeographicalRegion.substations)
return self._compare_identified_object(diff)
def _compare_substation(self, source: Substation, target: Substation) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, Substation.sub_geographical_region)
self._compare_id_reference_collections(diff, Substation.feeders)
return self._compare_equipment_container(diff)
def _compare_terminal(self, source: Terminal, target: Terminal) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, Terminal.conducting_equipment, Terminal.connectivity_node)
self._compare_values(
diff,
Terminal.phases,
Terminal.sequence_number,
Terminal.normal_feeder_direction,
Terminal.current_feeder_direction,
Terminal.traced_phases
)
return self._compare_ac_dc_terminal(diff)
#############################
# IEC61970 BASE EQUIVALENTS #
#############################
def _compare_equivalent_branch(self, source: EquivalentBranch, target: EquivalentBranch) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_floats(
diff,
EquivalentBranch.negative_r12,
EquivalentBranch.negative_r21,
EquivalentBranch.negative_x12,
EquivalentBranch.negative_x21,
EquivalentBranch.positive_r12,
EquivalentBranch.positive_r21,
EquivalentBranch.positive_x12,
EquivalentBranch.positive_x21,
EquivalentBranch.r,
EquivalentBranch.r21,
EquivalentBranch.x,
EquivalentBranch.x21,
EquivalentBranch.zero_r12,
EquivalentBranch.zero_r21,
EquivalentBranch.zero_x12,
EquivalentBranch.zero_x21
)
return self._compare_equivalent_equipment(diff)
def _compare_equivalent_equipment(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_conducting_equipment(diff)
######################
# IEC61970 BASE MEAS #
######################
def _compare_accumulator(self, source: Accumulator, target: Accumulator) -> ObjectDifference:
return self._compare_measurement(ObjectDifference(source, target))
def _compare_analog(self, source: Analog, target: Analog) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, Analog.positive_flow_in)
return self._compare_measurement(diff)
def _compare_control(self, source: Control, target: Control) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, Control.power_system_resource_mrid)
self._compare_id_references(diff, Control.remote_control)
return self._compare_io_point(diff)
def _compare_discrete(self, source: Discrete, target: Discrete) -> ObjectDifference:
return self._compare_measurement(ObjectDifference(source, target))
def _compare_io_point(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_identified_object(diff)
def _compare_measurement(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(diff, Measurement.power_system_resource_mrid, Measurement.unit_symbol, Measurement.phases, Measurement.terminal_mrid)
self._compare_id_references(diff, Measurement.remote_source)
return self._compare_identified_object(diff)
#######################
# IEC61970 BASE SCADA #
#######################
def _compare_remote_control(self, source: RemoteControl, target: RemoteControl) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, RemoteControl.control)
return self._compare_remote_point(diff)
def _compare_remote_point(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_identified_object(diff)
def _compare_remote_source(self, source: RemoteSource, target: RemoteSource) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, RemoteSource.measurement)
return self._compare_remote_point(diff)
#############################################
# IEC61970 BASE WIRES GENERATION PRODUCTION #
#############################################
def _compare_battery_unit(self, source: BatteryUnit, target: BatteryUnit) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, BatteryUnit.battery_state, BatteryUnit.rated_e, BatteryUnit.stored_e)
return self._compare_power_electronics_unit(diff)
def _compare_photo_voltaic_unit(self, source: PhotoVoltaicUnit, target: PhotoVoltaicUnit) -> ObjectDifference:
return self._compare_power_electronics_unit(ObjectDifference(source, target))
def _compare_power_electronics_unit(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_id_references(diff, PowerElectronicsUnit.power_electronics_connection)
self._compare_values(diff, PowerElectronicsUnit.max_p, PowerElectronicsUnit.min_p)
return self._compare_equipment(diff)
def _compare_power_electronics_wind_unit(self, source: PowerElectronicsWindUnit, target: PowerElectronicsWindUnit) -> ObjectDifference:
return self._compare_power_electronics_unit(ObjectDifference(source, target))
#######################
# IEC61970 BASE WIRES #
#######################
def _compare_ac_line_segment(self, source: AcLineSegment, target: AcLineSegment) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, AcLineSegment.per_length_sequence_impedance)
return self._compare_conductor(diff)
def _compare_breaker(self, source: Breaker, target: Breaker) -> ObjectDifference:
return self._compare_protected_switch(ObjectDifference(source, target))
def _compare_busbar_section(self, source: BusbarSection, target: BusbarSection) -> ObjectDifference:
return self._compare_connector(ObjectDifference(source, target))
def _compare_conductor(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_floats(diff, Conductor.length)
return self._compare_conducting_equipment(diff)
def _compare_connector(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_conducting_equipment(diff)
def _compare_disconnector(self, source: Disconnector, target: Disconnector) -> ObjectDifference:
return self._compare_switch(ObjectDifference(source, target))
def _compare_energy_connection(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_conducting_equipment(diff)
def _compare_energy_consumer(self, source: EnergyConsumer, target: EnergyConsumer) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_reference_collections(diff, EnergyConsumer.phases)
self._compare_values(diff, EnergyConsumer.customer_count, EnergyConsumer.grounded, EnergyConsumer.phase_connection)
self._compare_floats(diff, EnergyConsumer.p, EnergyConsumer.p_fixed, EnergyConsumer.q, EnergyConsumer.q_fixed)
return self._compare_energy_connection(diff)
def _compare_energy_consumer_phase(self, source: EnergyConsumerPhase, target: EnergyConsumerPhase) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, EnergyConsumerPhase.energy_consumer)
self._compare_values(diff, EnergyConsumerPhase.phase)
self._compare_floats(diff, EnergyConsumerPhase.p, EnergyConsumerPhase.p_fixed, EnergyConsumerPhase.q, EnergyConsumerPhase.q_fixed)
return self._compare_power_system_resource(diff)
def _compare_energy_source(self, source: EnergySource, target: EnergySource) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_reference_collections(diff, EnergySource.phases)
self._compare_floats(
diff,
EnergySource.active_power,
EnergySource.reactive_power,
EnergySource.voltage_angle,
EnergySource.voltage_magnitude,
EnergySource.p_max,
EnergySource.p_min,
EnergySource.r,
EnergySource.r0,
EnergySource.rn,
EnergySource.x,
EnergySource.x0,
EnergySource.xn,
EnergySource.r_min,
EnergySource.rn_min,
EnergySource.r0_min,
EnergySource.x_min,
EnergySource.xn_min,
EnergySource.x0_min,
EnergySource.r_max,
EnergySource.rn_max,
EnergySource.r0_max,
EnergySource.x_max,
EnergySource.xn_max,
EnergySource.x0_max
)
self._compare_values(
diff,
EnergySource.is_external_grid
)
return self._compare_energy_connection(diff)
def _compare_energy_source_phase(self, source: EnergySourcePhase, target: EnergySourcePhase) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, EnergySourcePhase.energy_source)
self._compare_values(diff, EnergySourcePhase.phase)
return self._compare_power_system_resource(diff)
def _compare_fuse(self, source: Fuse, target: Fuse) -> ObjectDifference:
return self._compare_switch(ObjectDifference(source, target))
def _compare_jumper(self, source: Jumper, target: Jumper) -> ObjectDifference:
return self._compare_switch(ObjectDifference(source, target))
def _compare_junction(self, source: Junction, target: Junction) -> ObjectDifference:
return self._compare_connector(ObjectDifference(source, target))
def _compare_line(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_equipment_container(diff)
def _compare_linear_shunt_compensator(self, source: LinearShuntCompensator, target: LinearShuntCompensator) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_floats(
diff,
LinearShuntCompensator.b0_per_section,
LinearShuntCompensator.b_per_section,
LinearShuntCompensator.g0_per_section,
LinearShuntCompensator.g_per_section
)
return self._compare_shunt_compensator(diff)
def _compare_load_break_switch(self, source: LoadBreakSwitch, target: LoadBreakSwitch) -> ObjectDifference:
return self._compare_protected_switch(ObjectDifference(source, target))
def _compare_per_length_impedance(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_per_length_line_parameter(diff)
def _compare_per_length_line_parameter(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_identified_object(diff)
def _compare_per_length_sequence_impedance(self, source: PerLengthSequenceImpedance, target: PerLengthSequenceImpedance) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_floats(
diff,
PerLengthSequenceImpedance.r,
PerLengthSequenceImpedance.x,
PerLengthSequenceImpedance.bch,
PerLengthSequenceImpedance.gch,
PerLengthSequenceImpedance.r0,
PerLengthSequenceImpedance.x0,
PerLengthSequenceImpedance.b0ch,
PerLengthSequenceImpedance.g0ch
)
return self._compare_per_length_impedance(diff)
def _compare_power_electronics_connection(self, source: PowerElectronicsConnection, target: PowerElectronicsConnection) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_reference_collections(diff, PowerElectronicsConnection.units, PowerElectronicsConnection.phases)
self._compare_values(diff, PowerElectronicsConnection.max_i_fault, PowerElectronicsConnection.rated_s, PowerElectronicsConnection.rated_u)
self._compare_floats(diff, PowerElectronicsConnection.max_q, PowerElectronicsConnection.min_q, PowerElectronicsConnection.p,
PowerElectronicsConnection.q)
return self._compare_regulating_cond_eq(diff)
def _compare_power_electronics_connection_phase(self, source: PowerElectronicsConnectionPhase, target: PowerElectronicsConnectionPhase) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, PowerElectronicsConnectionPhase.power_electronics_connection)
self._compare_values(diff, PowerElectronicsConnectionPhase.phase)
self._compare_floats(diff, PowerElectronicsConnectionPhase.p, PowerElectronicsConnectionPhase.q)
return self._compare_power_system_resource(diff)
def _compare_power_transformer(self, source: PowerTransformer, target: PowerTransformer) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, PowerTransformer.asset_info)
self._compare_indexed_id_reference_collections(diff, PowerTransformer.ends)
self._compare_values(diff, PowerTransformer.vector_group, PowerTransformer.construction_kind, PowerTransformer.function)
self._compare_floats(diff, PowerTransformer.transformer_utilisation)
return self._compare_conducting_equipment(diff)
def _compare_power_transformer_end(self, source: PowerTransformerEnd, target: PowerTransformerEnd) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, PowerTransformerEnd.power_transformer)
self._compare_values(
diff,
PowerTransformerEnd.connection_kind,
PowerTransformerEnd.phase_angle_clock,
PowerTransformerEnd.rated_s,
PowerTransformerEnd.rated_u
)
self._compare_floats(
diff,
PowerTransformerEnd.b,
PowerTransformerEnd.b0,
PowerTransformerEnd.g,
PowerTransformerEnd.g0,
PowerTransformerEnd.r,
PowerTransformerEnd.r0,
PowerTransformerEnd.x,
PowerTransformerEnd.x0
)
return self._compare_transformer_end(diff)
def _compare_protected_switch(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_switch(diff)
def _compare_ratio_tap_changer(self, source: RatioTapChanger, target: RatioTapChanger) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, RatioTapChanger.transformer_end)
self._compare_floats(diff, RatioTapChanger.step_voltage_increment)
return self._compare_tap_changer(diff)
def _compare_recloser(self, source: Recloser, target: Recloser) -> ObjectDifference:
return self._compare_protected_switch(ObjectDifference(source, target))
def _compare_regulating_cond_eq(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(diff, RegulatingCondEq.control_enabled)
return self._compare_energy_connection(diff)
def _compare_shunt_compensator(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(diff, ShuntCompensator.grounded, ShuntCompensator.nom_u, ShuntCompensator.phase_connection)
self._compare_floats(diff, ShuntCompensator.sections)
return self._compare_regulating_cond_eq(diff)
def _compare_switch(self, diff: ObjectDifference) -> ObjectDifference:
self._add_if_different(diff, "isNormallyOpen", self._compare_open_status(diff, Switch.is_normally_open))
self._add_if_different(diff, "isOpen", self._compare_open_status(diff, Switch.is_open))
return self._compare_conducting_equipment(diff)
def _compare_tap_changer(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(
diff,
TapChanger.control_enabled,
TapChanger.neutral_u,
TapChanger.high_step,
TapChanger.low_step,
TapChanger.neutral_step,
TapChanger.normal_step
)
self._compare_floats(diff, TapChanger.step)
return self._compare_power_system_resource(diff)
def _compare_transformer_end(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(diff, TransformerEnd.grounded, TransformerEnd.end_number)
self._compare_floats(diff, TransformerEnd.r_ground, TransformerEnd.x_ground)
self._compare_id_references(diff, TransformerEnd.base_voltage, TransformerEnd.ratio_tap_changer, TransformerEnd.terminal, TransformerEnd.star_impedance)
return self._compare_identified_object(diff)
def _compare_transformer_star_impedance(self, source: TransformerStarImpedance, target: TransformerStarImpedance) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_floats(diff, TransformerStarImpedance.r, TransformerStarImpedance.r0, TransformerStarImpedance.x, TransformerStarImpedance.x0)
self._compare_id_references(diff, TransformerStarImpedance.transformer_end_info)
return self._compare_identified_object(diff)
#########################
# IEC61970 INF IEC61970 #
#########################
def _compare_circuit(self, source: Circuit, target: Circuit) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, Circuit.loop)
self._compare_id_reference_collections(diff, Circuit.end_terminals, Circuit.end_substations)
return self._compare_line(diff)
def _compare_loop(self, source: Loop, target: Loop) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_reference_collections(diff, Loop.circuits, Loop.substations, Loop.energizing_substations)
return self._compare_identified_object(diff)
@staticmethod
# NOTE: Should be Callable[[Switch, SinglePhaseKind], bool], but type inference does not work correctly.
def _compare_open_status(diff: ObjectDifference, open_test: Callable[[Any, SinglePhaseKind], bool]) -> Optional[ValueDifference]:
source_status = {phase: open_test(diff.source, phase) for phase in PhaseCode.ABCN.single_phases}
target_status = {phase: open_test(diff.target, phase) for phase in PhaseCode.ABCN.single_phases}
return ValueDifference(source_status, target_status) if source_status != target_status else None | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/network_service_comparator.py | network_service_comparator.py |
from zepben.evolve.services.network.network_service import NetworkService
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.model.cim.iec61970.base.core.phase_code import PhaseCode
from zepben.evolve.model.cim.iec61970.base.wires.connectors import Junction
from zepben.evolve.model.cim.iec61970.base.wires.energy_source import EnergySource
from zepben.evolve.model.cim.iec61970.base.wires.power_transformer import PowerTransformer, PowerTransformerEnd
from zepben.evolve.model.cim.iec61970.base.wires.aclinesegment import AcLineSegment
from zepben.evolve.model.cim.iec61970.base.wires.energy_consumer import EnergyConsumer
from zepben.evolve.model.cim.iec61970.base.wires.switch import Breaker
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node import ConnectivityNode
from zepben.evolve.util import CopyableUUID
__all__ = ["create_ac_line_segment", "create_two_winding_power_transformer", "create_energy_consumer",
"create_energy_source", "create_bus", "create_breaker"]
# !! WARNING !! #
# THIS CODE IS IN ACTIVE DEVELOPMENT, UNSTABLE, AND LIKELY TO HAVE ISSUES. FOR EXPERIMENTATION ONLY.
def create_ac_line_segment(network_service: NetworkService, cn1: ConnectivityNode, cn2: ConnectivityNode,
**kwargs) -> AcLineSegment:
acls = AcLineSegment(**kwargs)
_create_two_terminal_conducting_equipment(network_service=network_service, ce=acls)
_connect_two_terminal_conducting_equipment(network_service=network_service, ce=acls, cn1=cn1, cn2=cn2)
return acls
def create_two_winding_power_transformer(network_service: NetworkService, cn1: ConnectivityNode, cn2: ConnectivityNode,
**kwargs) -> PowerTransformer:
power_transformer = PowerTransformer(**kwargs)
_create_two_terminal_conducting_equipment(network_service=network_service, ce=power_transformer, **kwargs)
_connect_two_terminal_conducting_equipment(network_service=network_service, ce=power_transformer, cn1=cn1, cn2=cn2)
# TODO: How to associated PowerTransformerEndInfo to a PowerTransformerInfo
for i in range(1, 2):
end = PowerTransformerEnd(power_transformer=power_transformer)
power_transformer.add_end(end)
end.terminal = power_transformer.get_terminal_by_sn(i)
return power_transformer
def create_energy_consumer(net: NetworkService, cn: ConnectivityNode, **kwargs) -> EnergyConsumer:
ec = EnergyConsumer(**kwargs)
_create_single_terminal_conducting_equipment(network_service=net, ce=ec, **kwargs)
_connect_single_terminal_conducting_equipment(network_service=net, ce=ec, cn=cn)
return ec
def create_energy_source(net: NetworkService, cn: ConnectivityNode, **kwargs) -> EnergySource:
es = EnergySource(**kwargs)
_create_single_terminal_conducting_equipment(network_service=net, ce=es, cn=cn, **kwargs)
_connect_single_terminal_conducting_equipment(network_service=net, ce=es, cn=cn)
return es
def create_breaker(network_service: NetworkService, cn1: ConnectivityNode, cn2: ConnectivityNode, **kwargs) -> Breaker:
ce = Breaker(**kwargs)
_create_two_terminal_conducting_equipment(network_service=network_service, ce=ce, **kwargs)
_connect_two_terminal_conducting_equipment(network_service=network_service, ce=ce, cn1=cn1, cn2=cn2)
return ce
def create_bus(network_service: NetworkService, **kwargs) -> Junction:
bus = Junction(**kwargs)
if 'mrid' not in kwargs:
bus.mrid = str(CopyableUUID())
network_service.add(bus)
_create_terminals(ce=bus, network=network_service)
# TODO: Figure out how to add Voltage to Buses - Looks like we need to add topologicalNode to support the
# relationship to BaseVoltage. Meanwhile using Junction.
return bus
def _create_two_terminal_conducting_equipment(network_service: NetworkService, ce: ConductingEquipment, **kwargs):
if 'mrid' not in kwargs:
ce.mrid = str(CopyableUUID())
network_service.add(ce)
_create_terminals(ce=ce, num_terms=2, network=network_service)
def _connect_two_terminal_conducting_equipment(network_service: NetworkService, ce: ConductingEquipment,
cn1: ConnectivityNode, cn2: ConnectivityNode):
network_service.connect_by_mrid(ce.get_terminal_by_sn(1), cn1.mrid)
network_service.connect_by_mrid(ce.get_terminal_by_sn(2), cn2.mrid)
def _create_single_terminal_conducting_equipment(network_service: NetworkService, ce: ConductingEquipment, **kwargs):
if 'mrid' not in kwargs:
ce.mrid = str(CopyableUUID())
network_service.add(ce)
_create_terminals(ce=ce, network=network_service)
def _connect_single_terminal_conducting_equipment(network_service: NetworkService, ce: ConductingEquipment,
cn: ConnectivityNode):
network_service.connect_by_mrid(ce.get_terminal_by_sn(1), cn.mrid)
def _create_terminals(network: NetworkService, ce: ConductingEquipment, num_terms: int = 1,
phases: PhaseCode = PhaseCode.ABC):
for i in range(1, num_terms + 1):
terminal: Terminal = Terminal(mrid=f"{ce.mrid}_t{i}", conducting_equipment=ce, phases=phases, sequence_number=i)
ce.add_terminal(terminal)
network.add(terminal)
terminal.conducting_equipment = ce
NetworkService.create_bus = create_bus
NetworkService.create_energy_source = create_energy_source
NetworkService.create_two_winding_power_transformer = create_two_winding_power_transformer
NetworkService.create_ac_line_segment = create_ac_line_segment
NetworkService.create_energy_consumer = create_energy_consumer
NetworkService.create_breaker = create_breaker | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/network_extensions.py | network_extensions.py |
from zepben.protobuf.cim.iec61968.assetinfo.CableInfo_pb2 import CableInfo as PBCableInfo
from zepben.protobuf.cim.iec61968.assetinfo.NoLoadTest_pb2 import NoLoadTest as PBNoLoadTest
from zepben.protobuf.cim.iec61968.assetinfo.OpenCircuitTest_pb2 import OpenCircuitTest as PBOpenCircuitTest
from zepben.protobuf.cim.iec61968.assetinfo.OverheadWireInfo_pb2 import OverheadWireInfo as PBOverheadWireInfo
from zepben.protobuf.cim.iec61968.assetinfo.PowerTransformerInfo_pb2 import PowerTransformerInfo as PBPowerTransformerInfo
from zepben.protobuf.cim.iec61968.assetinfo.ShortCircuitTest_pb2 import ShortCircuitTest as PBShortCircuitTest
from zepben.protobuf.cim.iec61968.assetinfo.ShuntCompensatorInfo_pb2 import ShuntCompensatorInfo as PBShuntCompensatorInfo
from zepben.protobuf.cim.iec61968.assetinfo.TransformerEndInfo_pb2 import TransformerEndInfo as PBTransformerEndInfo
from zepben.protobuf.cim.iec61968.assetinfo.TransformerTankInfo_pb2 import TransformerTankInfo as PBTransformerTankInfo
from zepben.protobuf.cim.iec61968.assetinfo.TransformerTest_pb2 import TransformerTest as PBTransformerTest
from zepben.protobuf.cim.iec61968.assetinfo.WireInfo_pb2 import WireInfo as PBWireInfo
from zepben.protobuf.cim.iec61968.assetinfo.WireMaterialKind_pb2 import WireMaterialKind as PBWireMaterialKind
from zepben.protobuf.cim.iec61968.assets.AssetContainer_pb2 import AssetContainer as PBAssetContainer
from zepben.protobuf.cim.iec61968.assets.AssetInfo_pb2 import AssetInfo as PBAssetInfo
from zepben.protobuf.cim.iec61968.assets.AssetOrganisationRole_pb2 import AssetOrganisationRole as PBAssetOrganisationRole
from zepben.protobuf.cim.iec61968.assets.AssetOwner_pb2 import AssetOwner as PBAssetOwner
from zepben.protobuf.cim.iec61968.assets.Asset_pb2 import Asset as PBAsset
from zepben.protobuf.cim.iec61968.assets.Pole_pb2 import Pole as PBPole
from zepben.protobuf.cim.iec61968.assets.StreetlightLampKind_pb2 import StreetlightLampKind as PBStreetlightLampKind
from zepben.protobuf.cim.iec61968.assets.Streetlight_pb2 import Streetlight as PBStreetlight
from zepben.protobuf.cim.iec61968.assets.Structure_pb2 import Structure as PBStructure
from zepben.protobuf.cim.iec61968.common.Location_pb2 import Location as PBLocation
from zepben.protobuf.cim.iec61968.common.PositionPoint_pb2 import PositionPoint as PBPositionPoint
from zepben.protobuf.cim.iec61968.common.StreetAddress_pb2 import StreetAddress as PBStreetAddress
from zepben.protobuf.cim.iec61968.common.StreetDetail_pb2 import StreetDetail as PBStreetDetail
from zepben.protobuf.cim.iec61968.common.TownDetail_pb2 import TownDetail as PBTownDetail
from zepben.protobuf.cim.iec61968.infiec61968.infassetinfo.TransformerConstructionKind_pb2 import TransformerConstructionKind as PBTransformerConstructionKind
from zepben.protobuf.cim.iec61968.infiec61968.infassetinfo.TransformerFunctionKind_pb2 import TransformerFunctionKind as PBTransformerFunctionKind
from zepben.protobuf.cim.iec61968.metering.EndDevice_pb2 import EndDevice as PBEndDevice
from zepben.protobuf.cim.iec61968.metering.Meter_pb2 import Meter as PBMeter
from zepben.protobuf.cim.iec61968.metering.UsagePoint_pb2 import UsagePoint as PBUsagePoint
from zepben.protobuf.cim.iec61968.operations.OperationalRestriction_pb2 import OperationalRestriction as PBOperationalRestriction
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.AuxiliaryEquipment_pb2 import AuxiliaryEquipment as PBAuxiliaryEquipment
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.FaultIndicator_pb2 import FaultIndicator as PBFaultIndicator
from zepben.protobuf.cim.iec61970.base.core.AcDcTerminal_pb2 import AcDcTerminal as PBAcDcTerminal
from zepben.protobuf.cim.iec61970.base.core.BaseVoltage_pb2 import BaseVoltage as PBBaseVoltage
from zepben.protobuf.cim.iec61970.base.core.ConductingEquipment_pb2 import ConductingEquipment as PBConductingEquipment
from zepben.protobuf.cim.iec61970.base.core.ConnectivityNodeContainer_pb2 import ConnectivityNodeContainer as PBConnectivityNodeContainer
from zepben.protobuf.cim.iec61970.base.core.ConnectivityNode_pb2 import ConnectivityNode as PBConnectivityNode
from zepben.protobuf.cim.iec61970.base.core.EquipmentContainer_pb2 import EquipmentContainer as PBEquipmentContainer
from zepben.protobuf.cim.iec61970.base.core.Equipment_pb2 import Equipment as PBEquipment
from zepben.protobuf.cim.iec61970.base.core.Feeder_pb2 import Feeder as PBFeeder
from zepben.protobuf.cim.iec61970.base.core.GeographicalRegion_pb2 import GeographicalRegion as PBGeographicalRegion
from zepben.protobuf.cim.iec61970.base.core.PhaseCode_pb2 import PhaseCode as PBPhaseCode
from zepben.protobuf.cim.iec61970.base.core.PowerSystemResource_pb2 import PowerSystemResource as PBPowerSystemResource
from zepben.protobuf.cim.iec61970.base.core.Site_pb2 import Site as PBSite
from zepben.protobuf.cim.iec61970.base.core.SubGeographicalRegion_pb2 import SubGeographicalRegion as PBSubGeographicalRegion
from zepben.protobuf.cim.iec61970.base.core.Substation_pb2 import Substation as PBSubstation
from zepben.protobuf.cim.iec61970.base.core.Terminal_pb2 import Terminal as PBTerminal
from zepben.protobuf.cim.iec61970.base.domain.UnitSymbol_pb2 import UnitSymbol as PBUnitSymbol
from zepben.protobuf.cim.iec61970.base.equivalents.EquivalentBranch_pb2 import EquivalentBranch as PBEquivalentBranch
from zepben.protobuf.cim.iec61970.base.equivalents.EquivalentEquipment_pb2 import EquivalentEquipment as PBEquivalentEquipment
from zepben.protobuf.cim.iec61970.base.meas.Accumulator_pb2 import Accumulator as PBAccumulator
from zepben.protobuf.cim.iec61970.base.meas.Analog_pb2 import Analog as PBAnalog
from zepben.protobuf.cim.iec61970.base.meas.Control_pb2 import Control as PBControl
from zepben.protobuf.cim.iec61970.base.meas.Discrete_pb2 import Discrete as PBDiscrete
from zepben.protobuf.cim.iec61970.base.meas.IoPoint_pb2 import IoPoint as PBIoPoint
from zepben.protobuf.cim.iec61970.base.meas.Measurement_pb2 import Measurement as PBMeasurement
from zepben.protobuf.cim.iec61970.base.scada.RemoteControl_pb2 import RemoteControl as PBRemoteControl
from zepben.protobuf.cim.iec61970.base.scada.RemotePoint_pb2 import RemotePoint as PBRemotePoint
from zepben.protobuf.cim.iec61970.base.scada.RemoteSource_pb2 import RemoteSource as PBRemoteSource
from zepben.protobuf.cim.iec61970.base.wires.AcLineSegment_pb2 import AcLineSegment as PBAcLineSegment
from zepben.protobuf.cim.iec61970.base.wires.Breaker_pb2 import Breaker as PBBreaker
from zepben.protobuf.cim.iec61970.base.wires.BusbarSection_pb2 import BusbarSection as PBBusbarSection
from zepben.protobuf.cim.iec61970.base.wires.Conductor_pb2 import Conductor as PBConductor
from zepben.protobuf.cim.iec61970.base.wires.Connector_pb2 import Connector as PBConnector
from zepben.protobuf.cim.iec61970.base.wires.Disconnector_pb2 import Disconnector as PBDisconnector
from zepben.protobuf.cim.iec61970.base.wires.EnergyConnection_pb2 import EnergyConnection as PBEnergyConnection
from zepben.protobuf.cim.iec61970.base.wires.EnergyConsumerPhase_pb2 import EnergyConsumerPhase as PBEnergyConsumerPhase
from zepben.protobuf.cim.iec61970.base.wires.EnergyConsumer_pb2 import EnergyConsumer as PBEnergyConsumer
from zepben.protobuf.cim.iec61970.base.wires.EnergySourcePhase_pb2 import EnergySourcePhase as PBEnergySourcePhase
from zepben.protobuf.cim.iec61970.base.wires.EnergySource_pb2 import EnergySource as PBEnergySource
from zepben.protobuf.cim.iec61970.base.wires.Fuse_pb2 import Fuse as PBFuse
from zepben.protobuf.cim.iec61970.base.wires.Jumper_pb2 import Jumper as PBJumper
from zepben.protobuf.cim.iec61970.base.wires.Junction_pb2 import Junction as PBJunction
from zepben.protobuf.cim.iec61970.base.wires.Line_pb2 import Line as PBLine
from zepben.protobuf.cim.iec61970.base.wires.LinearShuntCompensator_pb2 import LinearShuntCompensator as PBLinearShuntCompensator
from zepben.protobuf.cim.iec61970.base.wires.LoadBreakSwitch_pb2 import LoadBreakSwitch as PBLoadBreakSwitch
from zepben.protobuf.cim.iec61970.base.wires.PerLengthImpedance_pb2 import PerLengthImpedance as PBPerLengthImpedance
from zepben.protobuf.cim.iec61970.base.wires.PerLengthLineParameter_pb2 import PerLengthLineParameter as PBPerLengthLineParameter
from zepben.protobuf.cim.iec61970.base.wires.PerLengthSequenceImpedance_pb2 import PerLengthSequenceImpedance as PBPerLengthSequenceImpedance
from zepben.protobuf.cim.iec61970.base.wires.PhaseShuntConnectionKind_pb2 import PhaseShuntConnectionKind as PBPhaseShuntConnectionKind
from zepben.protobuf.cim.iec61970.base.wires.PowerElectronicsConnectionPhase_pb2 import PowerElectronicsConnectionPhase as PBPowerElectronicsConnectionPhase
from zepben.protobuf.cim.iec61970.base.wires.PowerElectronicsConnection_pb2 import PowerElectronicsConnection as PBPowerElectronicsConnection
from zepben.protobuf.cim.iec61970.base.wires.PowerTransformerEnd_pb2 import PowerTransformerEnd as PBPowerTransformerEnd
from zepben.protobuf.cim.iec61970.base.wires.PowerTransformer_pb2 import PowerTransformer as PBPowerTransformer
from zepben.protobuf.cim.iec61970.base.wires.ProtectedSwitch_pb2 import ProtectedSwitch as PBProtectedSwitch
from zepben.protobuf.cim.iec61970.base.wires.RatioTapChanger_pb2 import RatioTapChanger as PBRatioTapChanger
from zepben.protobuf.cim.iec61970.base.wires.Recloser_pb2 import Recloser as PBRecloser
from zepben.protobuf.cim.iec61970.base.wires.RegulatingCondEq_pb2 import RegulatingCondEq as PBRegulatingCondEq
from zepben.protobuf.cim.iec61970.base.wires.ShuntCompensator_pb2 import ShuntCompensator as PBShuntCompensator
from zepben.protobuf.cim.iec61970.base.wires.SinglePhaseKind_pb2 import SinglePhaseKind as PBSinglePhaseKind
from zepben.protobuf.cim.iec61970.base.wires.Switch_pb2 import Switch as PBSwitch
from zepben.protobuf.cim.iec61970.base.wires.TapChanger_pb2 import TapChanger as PBTapChanger
from zepben.protobuf.cim.iec61970.base.wires.TransformerEnd_pb2 import TransformerEnd as PBTransformerEnd
from zepben.protobuf.cim.iec61970.base.wires.TransformerStarImpedance_pb2 import TransformerStarImpedance as PBTransformerStarImpedance
from zepben.protobuf.cim.iec61970.base.wires.VectorGroup_pb2 import VectorGroup as PBVectorGroup
from zepben.protobuf.cim.iec61970.base.wires.WindingConnection_pb2 import WindingConnection as PBWindingConnection
from zepben.protobuf.cim.iec61970.base.wires.generation.production.BatteryStateKind_pb2 import BatteryStateKind as PBBatteryStateKind
from zepben.protobuf.cim.iec61970.base.wires.generation.production.BatteryUnit_pb2 import BatteryUnit as PBBatteryUnit
from zepben.protobuf.cim.iec61970.base.wires.generation.production.PhotoVoltaicUnit_pb2 import PhotoVoltaicUnit as PBPhotoVoltaicUnit
from zepben.protobuf.cim.iec61970.base.wires.generation.production.PowerElectronicsUnit_pb2 import PowerElectronicsUnit as PBPowerElectronicsUnit
from zepben.protobuf.cim.iec61970.base.wires.generation.production.PowerElectronicsWindUnit_pb2 import PowerElectronicsWindUnit as PBPowerElectronicsWindUnit
from zepben.protobuf.cim.iec61970.infiec61970.feeder.Circuit_pb2 import Circuit as PBCircuit
from zepben.protobuf.cim.iec61970.infiec61970.feeder.Loop_pb2 import Loop as PBLoop
from zepben.protobuf.network.model.FeederDirection_pb2 import FeederDirection as PBFeederDirection
from zepben.evolve import TransformerTankInfo, TransformerEndInfo, TransformerStarImpedance, NoLoadTest, OpenCircuitTest, ShortCircuitTest, TransformerTest, \
ShuntCompensatorInfo
from zepben.evolve.model.cim.iec61968.assetinfo.power_transformer_info import *
from zepben.evolve.model.cim.iec61968.assetinfo.wire_info import *
from zepben.evolve.model.cim.iec61968.assets.asset import *
from zepben.evolve.model.cim.iec61968.assets.asset_info import *
from zepben.evolve.model.cim.iec61968.assets.asset_organisation_role import *
from zepben.evolve.model.cim.iec61968.assets.pole import *
from zepben.evolve.model.cim.iec61968.assets.streetlight import *
from zepben.evolve.model.cim.iec61968.assets.structure import *
from zepben.evolve.model.cim.iec61968.common.location import *
from zepben.evolve.model.cim.iec61968.metering.metering import *
from zepben.evolve.model.cim.iec61968.operations.operational_restriction import *
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.auxiliary_equipment import *
from zepben.evolve.model.cim.iec61970.base.core.base_voltage import *
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import *
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node import *
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node_container import *
from zepben.evolve.model.cim.iec61970.base.core.equipment import *
from zepben.evolve.model.cim.iec61970.base.core.equipment_container import *
from zepben.evolve.model.cim.iec61970.base.core.power_system_resource import *
from zepben.evolve.model.cim.iec61970.base.core.regions import *
from zepben.evolve.model.cim.iec61970.base.core.substation import *
from zepben.evolve.model.cim.iec61970.base.core.terminal import *
from zepben.evolve.model.cim.iec61970.base.equivalents.equivalent_branch import *
from zepben.evolve.model.cim.iec61970.base.equivalents.equivalent_equipment import *
from zepben.evolve.model.cim.iec61970.base.meas.control import *
from zepben.evolve.model.cim.iec61970.base.meas.iopoint import *
from zepben.evolve.model.cim.iec61970.base.meas.measurement import *
from zepben.evolve.model.cim.iec61970.base.scada.remote_control import *
from zepben.evolve.model.cim.iec61970.base.scada.remote_point import *
from zepben.evolve.model.cim.iec61970.base.scada.remote_source import *
from zepben.evolve.model.cim.iec61970.base.wires.aclinesegment import *
from zepben.evolve.model.cim.iec61970.base.wires.connectors import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_connection import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_consumer import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_source import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_source_phase import *
from zepben.evolve.model.cim.iec61970.base.wires.generation.production.power_electronics_unit import *
from zepben.evolve.model.cim.iec61970.base.wires.line import *
from zepben.evolve.model.cim.iec61970.base.wires.per_length import *
from zepben.evolve.model.cim.iec61970.base.wires.power_electronics_connection import *
from zepben.evolve.model.cim.iec61970.base.wires.power_transformer import *
from zepben.evolve.model.cim.iec61970.base.wires.shunt_compensator import *
from zepben.evolve.model.cim.iec61970.base.wires.switch import *
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.circuit import *
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.loop import *
from zepben.evolve.services.common.translator.base_cim2proto import identified_object_to_pb, organisation_role_to_pb, document_to_pb
from zepben.evolve.services.common.translator.util import mrid_or_empty, from_nullable_int, from_nullable_float, from_nullable_long, from_nullable_uint
__all__ = [
"CimTranslationException", "cable_info_to_pb", "no_load_test_to_pb", "open_circuit_test_to_pb", "overhead_wire_info_to_pb", "power_transformer_info_to_pb",
"short_circuit_test_to_pb", "shunt_compensator_info_to_pb", "transformer_end_info_to_pb", "transformer_tank_info_to_pb", "transformer_test_to_pb",
"wire_info_to_pb", "asset_to_pb", "asset_container_to_pb", "asset_info_to_pb", "asset_organisation_role_to_pb", "asset_owner_to_pb", "pole_to_pb",
"streetlight_to_pb", "structure_to_pb", "location_to_pb", "position_point_to_pb", "street_address_to_pb", "town_detail_to_pb", "end_device_to_pb",
"meter_to_pb", "usage_point_to_pb", "operational_restriction_to_pb", "auxiliary_equipment_to_pb", "fault_indicator_to_pb", "ac_dc_terminal_to_pb",
"base_voltage_to_pb", "conducting_equipment_to_pb", "connectivity_node_to_pb", "connectivity_node_container_to_pb", "equipment_to_pb",
"equipment_container_to_pb", "feeder_to_pb", "geographical_region_to_pb", "power_system_resource_to_pb", "site_to_pb", "sub_geographical_region_to_pb",
"substation_to_pb", "terminal_to_pb", "equivalent_branch_to_pb", "equivalent_equipment_to_pb", "control_to_pb", "io_point_to_pb", "accumulator_to_pb",
"analog_to_pb", "discrete_to_pb", "measurement_to_pb", "remote_control_to_pb", "remote_point_to_pb", "remote_source_to_pb", "battery_unit_to_pb",
"photo_voltaic_unit_to_pb", "power_electronics_unit_to_pb", "power_electronics_wind_unit_to_pb", "ac_line_segment_to_pb", "breaker_to_pb",
"conductor_to_pb", "connector_to_pb", "disconnector_to_pb", "energy_connection_to_pb", "energy_consumer_to_pb", "energy_consumer_phase_to_pb",
"energy_source_to_pb", "energy_source_phase_to_pb", "fuse_to_pb", "jumper_to_pb", "junction_to_pb", "busbar_section_to_pb", "line_to_pb",
"linear_shunt_compensator_to_pb", "load_break_switch_to_pb", "per_length_line_parameter_to_pb", "per_length_impedance_to_pb",
"per_length_sequence_impedance_to_pb", "power_electronics_connection_to_pb", "power_electronics_connection_phase_to_pb", "power_transformer_to_pb",
"power_transformer_end_to_pb", "protected_switch_to_pb", "ratio_tap_changer_to_pb", "recloser_to_pb", "regulating_cond_eq_to_pb", "shunt_compensator_to_pb",
"switch_to_pb", "tap_changer_to_pb", "transformer_end_to_pb", "circuit_to_pb", "loop_to_pb", "transformer_star_impedance_to_pb",
]
def _get_or_none(getter, obj) -> object:
return getter(obj) if obj else None
class CimTranslationException(Exception):
pass
#######################
# IEC61968 ASSET INFO #
#######################
def cable_info_to_pb(cim: CableInfo) -> PBCableInfo:
return PBCableInfo(wi=wire_info_to_pb(cim))
def no_load_test_to_pb(cim: NoLoadTest) -> PBNoLoadTest:
return PBNoLoadTest(
tt=transformer_test_to_pb(cim),
energisedEndVoltage=from_nullable_int(cim.energised_end_voltage),
excitingCurrent=from_nullable_float(cim.exciting_current),
excitingCurrentZero=from_nullable_float(cim.exciting_current_zero),
loss=from_nullable_int(cim.loss),
lossZero=from_nullable_int(cim.loss_zero),
)
def open_circuit_test_to_pb(cim: OpenCircuitTest) -> PBOpenCircuitTest:
return PBOpenCircuitTest(
tt=transformer_test_to_pb(cim),
energisedEndStep=from_nullable_int(cim.energised_end_step),
energisedEndVoltage=from_nullable_int(cim.energised_end_voltage),
openEndStep=from_nullable_int(cim.open_end_step),
openEndVoltage=from_nullable_int(cim.open_end_voltage),
phaseShift=from_nullable_float(cim.phase_shift),
)
def overhead_wire_info_to_pb(cim: OverheadWireInfo) -> PBOverheadWireInfo:
return PBOverheadWireInfo(wi=wire_info_to_pb(cim))
def power_transformer_info_to_pb(cim: PowerTransformerInfo) -> PBPowerTransformerInfo:
return PBPowerTransformerInfo(
ai=asset_info_to_pb(cim),
transformerTankInfoMRIDs=[tti.mrid for tti in cim.transformer_tank_infos]
)
def short_circuit_test_to_pb(cim: ShortCircuitTest) -> PBShortCircuitTest:
return PBShortCircuitTest(
tt=transformer_test_to_pb(cim),
current=from_nullable_float(cim.current),
energisedEndStep=from_nullable_int(cim.energised_end_step),
groundedEndStep=from_nullable_int(cim.grounded_end_step),
leakageImpedance=from_nullable_float(cim.leakage_impedance),
leakageImpedanceZero=from_nullable_float(cim.leakage_impedance_zero),
loss=from_nullable_int(cim.loss),
lossZero=from_nullable_int(cim.loss_zero),
power=from_nullable_int(cim.power),
voltage=from_nullable_float(cim.voltage),
voltageOhmicPart=from_nullable_float(cim.voltage_ohmic_part),
)
def shunt_compensator_info_to_pb(cim: ShuntCompensatorInfo) -> PBShuntCompensatorInfo:
return PBShuntCompensatorInfo(
ai=asset_info_to_pb(cim),
maxPowerLoss=from_nullable_int(cim.max_power_loss),
ratedCurrent=from_nullable_int(cim.rated_current),
ratedReactivePower=from_nullable_int(cim.rated_reactive_power),
ratedVoltage=from_nullable_int(cim.rated_voltage),
)
def transformer_end_info_to_pb(cim: TransformerEndInfo) -> PBTransformerEndInfo:
return PBTransformerEndInfo(
ai=asset_info_to_pb(cim),
connectionKind=PBWindingConnection.Value(cim.connection_kind.short_name),
emergencyS=from_nullable_int(cim.emergency_s),
endNumber=from_nullable_int(cim.end_number),
insulationU=from_nullable_int(cim.insulation_u),
phaseAngleClock=from_nullable_int(cim.phase_angle_clock),
r=from_nullable_float(cim.r),
ratedS=from_nullable_int(cim.rated_s),
ratedU=from_nullable_int(cim.rated_u),
shortTermS=from_nullable_int(cim.short_term_s),
transformerTankInfoMRID=mrid_or_empty(cim.transformer_tank_info),
transformerStarImpedanceMRID=mrid_or_empty(cim.transformer_star_impedance),
energisedEndNoLoadTestsMRID=mrid_or_empty(cim.energised_end_no_load_tests),
energisedEndShortCircuitTestsMRID=mrid_or_empty(cim.energised_end_short_circuit_tests),
groundedEndShortCircuitTestsMRID=mrid_or_empty(cim.grounded_end_short_circuit_tests),
openEndOpenCircuitTestsMRID=mrid_or_empty(cim.open_end_open_circuit_tests),
energisedEndOpenCircuitTestsMRID=mrid_or_empty(cim.energised_end_open_circuit_tests),
)
def transformer_tank_info_to_pb(cim: TransformerTankInfo) -> PBTransformerTankInfo:
return PBTransformerTankInfo(
ai=asset_info_to_pb(cim),
transformerEndInfoMRIDs=[str(tei.mrid) for tei in cim.transformer_end_infos]
)
def transformer_test_to_pb(cim: TransformerTest) -> PBTransformerTest:
return PBTransformerTest(
io=identified_object_to_pb(cim),
basePower=from_nullable_int(cim.base_power),
temperature=from_nullable_float(cim.temperature),
)
def wire_info_to_pb(cim: WireInfo) -> PBWireInfo:
return PBWireInfo(
ai=asset_info_to_pb(cim),
ratedCurrent=from_nullable_int(cim.rated_current),
material=PBWireMaterialKind.Value(cim.material.short_name)
)
CableInfo.to_pb = cable_info_to_pb
NoLoadTest.to_pb = no_load_test_to_pb
OpenCircuitTest.to_pb = open_circuit_test_to_pb
OverheadWireInfo.to_pb = overhead_wire_info_to_pb
PowerTransformerInfo.to_pb = power_transformer_info_to_pb
ShortCircuitTest.to_pb = short_circuit_test_to_pb
ShuntCompensatorInfo.to_pb = shunt_compensator_info_to_pb
TransformerEndInfo.to_pb = transformer_end_info_to_pb
TransformerTankInfo.to_pb = transformer_tank_info_to_pb
TransformerTest.to_pb = transformer_test_to_pb
WireInfo.to_pb = wire_info_to_pb
###################
# IEC61968 ASSETS #
###################
def asset_to_pb(cim: Asset) -> PBAsset:
return PBAsset(
io=identified_object_to_pb(cim),
locationMRID=cim.location.mrid if cim.location else None,
organisationRoleMRIDs=[str(io.mrid) for io in cim.organisation_roles]
)
def asset_container_to_pb(cim: AssetContainer) -> PBAssetContainer:
return PBAssetContainer(at=asset_to_pb(cim))
def asset_info_to_pb(cim: AssetInfo) -> PBAssetInfo:
return PBAssetInfo(io=identified_object_to_pb(cim))
def asset_organisation_role_to_pb(cim: AssetOrganisationRole) -> PBAssetOrganisationRole:
pb = PBAssetOrganisationRole()
getattr(pb, "or").CopyFrom(organisation_role_to_pb(cim))
return pb
def asset_owner_to_pb(cim: AssetOwner) -> PBAssetOwner:
return PBAssetOwner(aor=asset_organisation_role_to_pb(cim))
def pole_to_pb(cim: Pole) -> PBPole:
return PBPole(
st=structure_to_pb(cim),
streetlightMRIDs=[str(io.mrid) for io in cim.streetlights],
classification=cim.classification
)
def streetlight_to_pb(cim: Streetlight) -> PBStreetlight:
return PBStreetlight(
at=asset_to_pb(cim),
poleMRID=mrid_or_empty(cim.pole),
lightRating=from_nullable_uint(cim.light_rating),
lampKind=PBStreetlightLampKind.Value(cim.lamp_kind.short_name)
)
def structure_to_pb(cim: Structure) -> PBStructure:
return PBStructure(ac=asset_container_to_pb(cim))
Asset.to_pb = asset_to_pb
AssetContainer.to_pb = asset_container_to_pb
AssetInfo.to_pb = asset_info_to_pb
AssetOrganisationRole.to_pb = asset_organisation_role_to_pb
AssetOwner.to_pb = asset_owner_to_pb
Pole.to_pb = pole_to_pb
Streetlight.to_pb = streetlight_to_pb
Structure.to_pb = structure_to_pb
###################
# IEC61968 COMMON #
###################
def location_to_pb(cim: Location) -> PBLocation:
return PBLocation(
io=identified_object_to_pb(cim),
mainAddress=_get_or_none(street_address_to_pb, cim.main_address),
positionPoints=[position_point_to_pb(point) for point in cim.points]
)
def position_point_to_pb(cim: PositionPoint) -> PBPositionPoint:
return PBPositionPoint(xPosition=cim.x_position, yPosition=cim.y_position)
def street_address_to_pb(cim: StreetAddress) -> PBStreetAddress:
return PBStreetAddress(
postalCode=cim.postal_code,
townDetail=_get_or_none(town_detail_to_pb, cim.town_detail),
poBox=cim.po_box,
streetDetail=_get_or_none(street_detail_to_pb, cim.street_detail)
)
def street_detail_to_pb(cim: StreetDetail) -> PBStreetDetail:
return PBStreetDetail(
buildingName=cim.building_name,
floorIdentification=cim.floor_identification,
name=cim.name,
number=cim.number,
suiteNumber=cim.suite_number,
type=cim.type,
displayAddress=cim.display_address
)
def town_detail_to_pb(cim: TownDetail) -> PBTownDetail:
return PBTownDetail(name=cim.name, stateOrProvince=cim.state_or_province)
Location.to_pb = location_to_pb
PositionPoint.to_pb = position_point_to_pb
StreetAddress.to_pb = street_address_to_pb
TownDetail.to_pb = town_detail_to_pb
#####################
# IEC61968 METERING #
#####################
def end_device_to_pb(cim: EndDevice) -> PBEndDevice:
return PBEndDevice(
ac=asset_container_to_pb(cim),
usagePointMRIDs=[str(io.mrid) for io in cim.usage_points],
customerMRID=cim.customer_mrid,
serviceLocationMRID=mrid_or_empty(cim.service_location)
)
def meter_to_pb(cim: Meter) -> PBMeter:
return PBMeter(ed=end_device_to_pb(cim))
def usage_point_to_pb(cim: UsagePoint) -> PBUsagePoint:
return PBUsagePoint(
io=identified_object_to_pb(cim),
usagePointLocationMRID=mrid_or_empty(cim.usage_point_location),
equipmentMRIDs=[str(io.mrid) for io in cim.equipment],
endDeviceMRIDs=[str(io.mrid) for io in cim.end_devices],
isVirtual=cim.is_virtual,
connectionCategory=cim.connection_category
)
EndDevice.to_pb = end_device_to_pb
Meter.to_pb = meter_to_pb
UsagePoint.to_pb = usage_point_to_pb
#######################
# IEC61968 OPERATIONS #
#######################
def operational_restriction_to_pb(cim: OperationalRestriction) -> PBOperationalRestriction:
return PBOperationalRestriction(doc=document_to_pb(cim))
OperationalRestriction.to_pb = operational_restriction_to_pb
#####################################
# IEC61970 BASE AUXILIARY EQUIPMENT #
#####################################
def auxiliary_equipment_to_pb(cim: AuxiliaryEquipment) -> PBAuxiliaryEquipment:
return PBAuxiliaryEquipment(
eq=equipment_to_pb(cim),
terminalMRID=mrid_or_empty(cim.terminal)
)
def fault_indicator_to_pb(cim: FaultIndicator) -> PBFaultIndicator:
return PBFaultIndicator(ae=auxiliary_equipment_to_pb(cim))
AuxiliaryEquipment.to_pb = auxiliary_equipment_to_pb
FaultIndicator.to_pb = fault_indicator_to_pb
######################
# IEC61970 BASE CORE #
######################
def ac_dc_terminal_to_pb(cim: AcDcTerminal) -> PBAcDcTerminal:
return PBAcDcTerminal(io=identified_object_to_pb(cim))
def base_voltage_to_pb(cim: BaseVoltage) -> PBBaseVoltage:
return PBBaseVoltage(
io=identified_object_to_pb(cim),
nominalVoltage=cim.nominal_voltage
)
def conducting_equipment_to_pb(cim: ConductingEquipment, include_asset_info: bool = False) -> PBConductingEquipment:
return PBConductingEquipment(
eq=equipment_to_pb(cim, include_asset_info),
baseVoltageMRID=mrid_or_empty(cim.base_voltage),
terminalMRIDs=[str(io.mrid) for io in cim.terminals]
)
def connectivity_node_to_pb(cim: ConnectivityNode) -> PBConnectivityNode:
return PBConnectivityNode(io=identified_object_to_pb(cim))
def connectivity_node_container_to_pb(cim: ConnectivityNodeContainer) -> PBConnectivityNodeContainer:
return PBConnectivityNodeContainer(psr=power_system_resource_to_pb(cim))
def equipment_to_pb(cim: Equipment, include_asset_info: bool = False) -> PBEquipment:
return PBEquipment(
psr=power_system_resource_to_pb(cim, include_asset_info),
inService=cim.in_service,
normallyInService=cim.normally_in_service,
equipmentContainerMRIDs=[str(io.mrid) for io in cim.containers],
usagePointMRIDs=[str(io.mrid) for io in cim.usage_points],
operationalRestrictionMRIDs=[str(io.mrid) for io in cim.operational_restrictions],
currentFeederMRIDs=[str(io.mrid) for io in cim.current_feeders]
)
def equipment_container_to_pb(cim: EquipmentContainer) -> PBEquipmentContainer:
return PBEquipmentContainer(cnc=connectivity_node_container_to_pb(cim))
def feeder_to_pb(cim: Feeder) -> PBFeeder:
return PBFeeder(
ec=equipment_container_to_pb(cim),
normalHeadTerminalMRID=mrid_or_empty(cim.normal_head_terminal),
normalEnergizingSubstationMRID=mrid_or_empty(cim.normal_energizing_substation)
)
def geographical_region_to_pb(cim: GeographicalRegion) -> PBGeographicalRegion:
return PBGeographicalRegion(
io=identified_object_to_pb(cim),
subGeographicalRegionMRIDs=[str(io.mrid) for io in cim.sub_geographical_regions]
)
def power_system_resource_to_pb(cim: PowerSystemResource, include_asset_info: bool = False) -> PBPowerSystemResource:
return PBPowerSystemResource(
io=identified_object_to_pb(cim),
assetInfoMRID=mrid_or_empty(cim.asset_info) if include_asset_info else None,
locationMRID=mrid_or_empty(cim.location)
)
def site_to_pb(cim: Site) -> PBSite:
return PBSite(ec=equipment_container_to_pb(cim))
def sub_geographical_region_to_pb(cim: SubGeographicalRegion) -> PBSubGeographicalRegion:
return PBSubGeographicalRegion(
io=identified_object_to_pb(cim),
geographicalRegionMRID=mrid_or_empty(cim.geographical_region),
substationMRIDs=[str(io.mrid) for io in cim.substations]
)
def substation_to_pb(cim: Substation) -> PBSubstation:
return PBSubstation(
ec=equipment_container_to_pb(cim),
subGeographicalRegionMRID=mrid_or_empty(cim.sub_geographical_region),
normalEnergizedFeederMRIDs=[str(io.mrid) for io in cim.feeders],
loopMRIDs=[str(io.mrid) for io in cim.loops],
normalEnergizedLoopMRIDs=[str(io.mrid) for io in cim.energized_loops],
circuitMRIDs=[str(io.mrid) for io in cim.circuits]
)
def terminal_to_pb(cim: Terminal) -> PBTerminal:
# noinspection PyProtectedMember
return PBTerminal(
ad=ac_dc_terminal_to_pb(cim),
conductingEquipmentMRID=mrid_or_empty(cim.conducting_equipment),
connectivityNodeMRID=mrid_or_empty(cim.connectivity_node),
phases=PBPhaseCode.Value(cim.phases.short_name),
sequenceNumber=cim.sequence_number,
normalFeederDirection=PBFeederDirection.Value(cim.normal_feeder_direction.short_name),
currentFeederDirection=PBFeederDirection.Value(cim.current_feeder_direction.short_name),
tracedPhases=cim.traced_phases.phase_status
)
AcDcTerminal.to_pb = ac_dc_terminal_to_pb
BaseVoltage.to_pb = base_voltage_to_pb
ConductingEquipment.to_pb = conducting_equipment_to_pb
ConnectivityNode.to_pb = connectivity_node_to_pb
ConnectivityNodeContainer.to_pb = connectivity_node_container_to_pb
Equipment.to_pb = equipment_to_pb
EquipmentContainer.to_pb = equipment_container_to_pb
Feeder.to_pb = feeder_to_pb
GeographicalRegion.to_pb = geographical_region_to_pb
PowerSystemResource.to_pb = power_system_resource_to_pb
Site.to_pb = site_to_pb
SubGeographicalRegion.to_pb = sub_geographical_region_to_pb
Substation.to_pb = substation_to_pb
Terminal.to_pb = terminal_to_pb
#############################
# IEC61970 BASE EQUIVALENTS #
#############################
def equivalent_branch_to_pb(cim: EquivalentBranch) -> PBEquivalentBranch:
return PBEquivalentBranch(
ee=equivalent_equipment_to_pb(cim),
negativeR12=from_nullable_float(cim.negative_r12),
negativeR21=from_nullable_float(cim.negative_r21),
negativeX12=from_nullable_float(cim.negative_x12),
negativeX21=from_nullable_float(cim.negative_x21),
positiveR12=from_nullable_float(cim.positive_r12),
positiveR21=from_nullable_float(cim.positive_r21),
positiveX12=from_nullable_float(cim.positive_x12),
positiveX21=from_nullable_float(cim.positive_x21),
r=from_nullable_float(cim.r),
r21=from_nullable_float(cim.r21),
x=from_nullable_float(cim.x),
x21=from_nullable_float(cim.x21),
zeroR12=from_nullable_float(cim.zero_r12),
zeroR21=from_nullable_float(cim.zero_r21),
zeroX12=from_nullable_float(cim.zero_x12),
zeroX21=from_nullable_float(cim.zero_x21),
)
def equivalent_equipment_to_pb(cim: EquivalentEquipment) -> PBEquivalentEquipment:
return PBEquivalentEquipment(ce=conducting_equipment_to_pb(cim))
EquivalentBranch.to_pb = equivalent_branch_to_pb
EquivalentEquipment.to_pb = equivalent_equipment_to_pb
######################
# IEC61970 BASE MEAS #
######################
def accumulator_to_pb(cim: Accumulator) -> PBAccumulator:
return PBAccumulator(measurement=measurement_to_pb(cim))
def analog_to_pb(cim: Analog) -> PBAnalog:
return PBAnalog(
measurement=measurement_to_pb(cim),
positiveFlowIn=cim.positive_flow_in
)
def control_to_pb(cim: Control) -> PBControl:
return PBControl(
ip=io_point_to_pb(cim),
remoteControlMRID=mrid_or_empty(cim.remote_control),
powerSystemResourceMRID=cim.power_system_resource_mrid
)
def discrete_to_pb(cim: Discrete) -> PBDiscrete:
return PBDiscrete(measurement=measurement_to_pb(cim))
def io_point_to_pb(cim: IoPoint) -> PBIoPoint:
return PBIoPoint(io=identified_object_to_pb(cim))
def measurement_to_pb(cim: Measurement) -> PBMeasurement:
return PBMeasurement(
io=identified_object_to_pb(cim),
remoteSourceMRID=mrid_or_empty(cim.remote_source),
powerSystemResourceMRID=cim.power_system_resource_mrid,
terminalMRID=cim.terminal_mrid,
phases=PBPhaseCode.Value(cim.phases.short_name),
unitSymbol=PBUnitSymbol.Value(cim.unit_symbol.short_name)
)
Accumulator.to_pb = accumulator_to_pb
Analog.to_pb = analog_to_pb
Control.to_pb = control_to_pb
Discrete.to_pb = discrete_to_pb
IoPoint.to_pb = io_point_to_pb
Measurement.to_pb = measurement_to_pb
#######################
# IEC61970 BASE SCADA #
#######################
def remote_control_to_pb(cim: RemoteControl) -> PBRemoteControl:
return PBRemoteControl(
rp=remote_point_to_pb(cim),
controlMRID=mrid_or_empty(cim.control)
)
def remote_point_to_pb(cim: RemotePoint) -> PBRemotePoint:
return PBRemotePoint(io=identified_object_to_pb(cim))
def remote_source_to_pb(cim: RemoteSource) -> PBRemoteSource:
return PBRemoteSource(
rp=remote_point_to_pb(cim),
measurementMRID=mrid_or_empty(cim.measurement)
)
RemoteControl.to_pb = remote_control_to_pb
RemotePoint.to_pb = remote_point_to_pb
RemoteSource.to_pb = remote_source_to_pb
#############################################
# IEC61970 BASE WIRES GENERATION PRODUCTION #
#############################################
def battery_unit_to_pb(cim: BatteryUnit) -> PBBatteryUnit:
return PBBatteryUnit(
peu=power_electronics_unit_to_pb(cim),
ratedE=from_nullable_long(cim.rated_e),
storedE=from_nullable_long(cim.stored_e),
batteryState=PBBatteryStateKind.Value(cim.battery_state.short_name)
)
def photo_voltaic_unit_to_pb(cim: PhotoVoltaicUnit) -> PBPhotoVoltaicUnit:
return PBPhotoVoltaicUnit(peu=power_electronics_unit_to_pb(cim))
def power_electronics_unit_to_pb(cim: PowerElectronicsUnit) -> PBPowerElectronicsUnit:
return PBPowerElectronicsUnit(
eq=equipment_to_pb(cim),
maxP=from_nullable_int(cim.max_p),
minP=from_nullable_int(cim.min_p),
powerElectronicsConnectionMRID=mrid_or_empty(cim.power_electronics_connection)
)
def power_electronics_wind_unit_to_pb(cim: PowerElectronicsWindUnit) -> PBPowerElectronicsWindUnit:
return PBPowerElectronicsWindUnit(peu=power_electronics_unit_to_pb(cim))
BatteryUnit.to_pb = battery_unit_to_pb
PhotoVoltaicUnit.to_pb = photo_voltaic_unit_to_pb
PowerElectronicsUnit.to_pb = power_electronics_unit_to_pb
PowerElectronicsWindUnit.to_pb = power_electronics_wind_unit_to_pb
#######################
# IEC61970 BASE WIRES #
#######################
def ac_line_segment_to_pb(cim: AcLineSegment) -> PBAcLineSegment:
return PBAcLineSegment(
cd=conductor_to_pb(cim),
perLengthSequenceImpedanceMRID=mrid_or_empty(cim.per_length_sequence_impedance)
)
def breaker_to_pb(cim: Breaker) -> PBBreaker:
return PBBreaker(sw=protected_switch_to_pb(cim))
def conductor_to_pb(cim: Conductor) -> PBConductor:
return PBConductor(
ce=conducting_equipment_to_pb(cim, True),
length=from_nullable_float(cim.length)
)
def connector_to_pb(cim: Connector) -> PBConnector:
return PBConnector(ce=conducting_equipment_to_pb(cim))
def disconnector_to_pb(cim: Disconnector) -> PBDisconnector:
return PBDisconnector(sw=switch_to_pb(cim))
def energy_connection_to_pb(cim: EnergyConnection, include_asset_info=False) -> PBEnergyConnection:
return PBEnergyConnection(ce=conducting_equipment_to_pb(cim, include_asset_info))
def energy_consumer_to_pb(cim: EnergyConsumer) -> PBEnergyConsumer:
return PBEnergyConsumer(
ec=energy_connection_to_pb(cim),
energyConsumerPhasesMRIDs=[str(io.mrid) for io in cim.phases],
customerCount=from_nullable_int(cim.customer_count),
grounded=cim.grounded,
phaseConnection=PBPhaseShuntConnectionKind.Enum.Value(cim.phase_connection.short_name),
p=from_nullable_float(cim.p),
pFixed=from_nullable_float(cim.p_fixed),
q=from_nullable_float(cim.q),
qFixed=from_nullable_float(cim.q_fixed)
)
def energy_consumer_phase_to_pb(cim: EnergyConsumerPhase) -> PBEnergyConsumerPhase:
return PBEnergyConsumerPhase(
psr=power_system_resource_to_pb(cim),
energyConsumerMRID=mrid_or_empty(cim.energy_consumer),
phase=PBSinglePhaseKind.Value(cim.phase.short_name),
p=from_nullable_float(cim.p),
pFixed=from_nullable_float(cim.p_fixed),
q=from_nullable_float(cim.q),
qFixed=from_nullable_float(cim.q_fixed)
)
def energy_source_to_pb(cim: EnergySource) -> PBEnergySource:
return PBEnergySource(
ec=energy_connection_to_pb(cim),
energySourcePhasesMRIDs=[str(io.mrid) for io in cim.phases],
activePower=from_nullable_float(cim.active_power),
reactivePower=from_nullable_float(cim.reactive_power),
voltageAngle=from_nullable_float(cim.voltage_angle),
voltageMagnitude=from_nullable_float(cim.voltage_magnitude),
r=from_nullable_float(cim.r),
x=from_nullable_float(cim.x),
pMax=from_nullable_float(cim.p_max),
pMin=from_nullable_float(cim.p_min),
r0=from_nullable_float(cim.r0),
rn=from_nullable_float(cim.rn),
x0=from_nullable_float(cim.x0),
xn=from_nullable_float(cim.xn),
isExternalGrid=cim.is_external_grid,
rMin=from_nullable_float(cim.r_min),
rnMin=from_nullable_float(cim.rn_min),
r0Min=from_nullable_float(cim.r0_min),
xMin=from_nullable_float(cim.x_min),
xnMin=from_nullable_float(cim.xn_min),
x0Min=from_nullable_float(cim.x0_min),
rMax=from_nullable_float(cim.r_max),
rnMax=from_nullable_float(cim.rn_max),
r0Max=from_nullable_float(cim.r0_max),
xMax=from_nullable_float(cim.x_max),
xnMax=from_nullable_float(cim.xn_max),
x0Max=from_nullable_float(cim.x0_max)
)
def energy_source_phase_to_pb(cim: EnergySourcePhase) -> PBEnergySourcePhase:
return PBEnergySourcePhase(
psr=power_system_resource_to_pb(cim),
energySourceMRID=mrid_or_empty(cim.energy_source),
phase=PBSinglePhaseKind.Value(cim.phase.short_name)
)
def fuse_to_pb(cim: Fuse) -> PBFuse:
return PBFuse(sw=switch_to_pb(cim))
def jumper_to_pb(cim: Jumper) -> PBJumper:
return PBJumper(sw=switch_to_pb(cim))
def junction_to_pb(cim: Junction) -> PBJunction:
return PBJunction(cn=connector_to_pb(cim))
def busbar_section_to_pb(cim: BusbarSection) -> PBBusbarSection:
return PBBusbarSection(cn=connector_to_pb(cim))
def line_to_pb(cim: Line) -> PBLine:
return PBLine(ec=equipment_container_to_pb(cim))
def linear_shunt_compensator_to_pb(cim: LinearShuntCompensator) -> PBLinearShuntCompensator:
return PBLinearShuntCompensator(
sc=shunt_compensator_to_pb(cim),
b0PerSection=from_nullable_float(cim.b0_per_section),
bPerSection=from_nullable_float(cim.b_per_section),
g0PerSection=from_nullable_float(cim.g0_per_section),
gPerSection=from_nullable_float(cim.g_per_section)
)
def load_break_switch_to_pb(cim: LoadBreakSwitch) -> PBLoadBreakSwitch:
return PBLoadBreakSwitch(ps=protected_switch_to_pb(cim))
def per_length_line_parameter_to_pb(cim: PerLengthLineParameter) -> PBPerLengthLineParameter:
return PBPerLengthLineParameter(io=identified_object_to_pb(cim))
def per_length_impedance_to_pb(cim: PerLengthImpedance) -> PBPerLengthImpedance:
return PBPerLengthImpedance(lp=per_length_line_parameter_to_pb(cim))
def per_length_sequence_impedance_to_pb(cim: PerLengthSequenceImpedance) -> PBPerLengthSequenceImpedance:
return PBPerLengthSequenceImpedance(
pli=per_length_impedance_to_pb(cim),
r=from_nullable_float(cim.r),
x=from_nullable_float(cim.x),
r0=from_nullable_float(cim.r0),
x0=from_nullable_float(cim.x0),
bch=from_nullable_float(cim.bch),
gch=from_nullable_float(cim.gch),
b0ch=from_nullable_float(cim.b0ch),
g0ch=from_nullable_float(cim.g0ch)
)
def power_electronics_connection_to_pb(cim: PowerElectronicsConnection) -> PBPowerElectronicsConnection:
return PBPowerElectronicsConnection(
rce=regulating_cond_eq_to_pb(cim),
powerElectronicsUnitMRIDs=[str(io.mrid) for io in cim.units],
powerElectronicsConnectionPhaseMRIDs=[str(io.mrid) for io in cim.phases],
maxIFault=from_nullable_int(cim.max_i_fault),
maxQ=from_nullable_float(cim.max_q),
minQ=from_nullable_float(cim.min_q),
p=from_nullable_float(cim.p),
q=from_nullable_float(cim.q),
ratedS=from_nullable_int(cim.rated_s),
ratedU=from_nullable_int(cim.rated_u)
)
def power_electronics_connection_phase_to_pb(cim: PowerElectronicsConnectionPhase) -> PBPowerElectronicsConnectionPhase:
return PBPowerElectronicsConnectionPhase(
psr=power_system_resource_to_pb(cim),
powerElectronicsConnectionMRID=mrid_or_empty(cim.power_electronics_connection),
p=from_nullable_float(cim.p),
q=from_nullable_float(cim.q),
phase=PBSinglePhaseKind.Value(cim.phase.short_name)
)
def power_transformer_to_pb(cim: PowerTransformer) -> PBPowerTransformer:
return PBPowerTransformer(
ce=conducting_equipment_to_pb(cim, True),
powerTransformerEndMRIDs=[str(io.mrid) for io in cim.ends],
vectorGroup=PBVectorGroup.Value(cim.vector_group.short_name),
transformerUtilisation=from_nullable_float(cim.transformer_utilisation),
constructionKind=PBTransformerConstructionKind.Value(cim.construction_kind.short_name),
function=PBTransformerFunctionKind.Value(cim.function.short_name)
)
def power_transformer_end_to_pb(cim: PowerTransformerEnd) -> PBPowerTransformerEnd:
return PBPowerTransformerEnd(
te=transformer_end_to_pb(cim),
powerTransformerMRID=mrid_or_empty(cim.power_transformer),
ratedS=from_nullable_int(cim.rated_s),
ratedU=from_nullable_int(cim.rated_u),
r=from_nullable_float(cim.r),
r0=from_nullable_float(cim.r0),
x=from_nullable_float(cim.x),
x0=from_nullable_float(cim.x0),
connectionKind=PBWindingConnection.Value(cim.connection_kind.short_name),
b=from_nullable_float(cim.b),
b0=from_nullable_float(cim.b0),
g=from_nullable_float(cim.g),
g0=from_nullable_float(cim.g0),
phaseAngleClock=from_nullable_int(cim.phase_angle_clock)
)
def protected_switch_to_pb(cim: ProtectedSwitch) -> PBProtectedSwitch:
return PBProtectedSwitch(sw=switch_to_pb(cim))
def ratio_tap_changer_to_pb(cim: RatioTapChanger) -> PBRatioTapChanger:
return PBRatioTapChanger(
tc=tap_changer_to_pb(cim),
transformerEndMRID=mrid_or_empty(cim.transformer_end),
stepVoltageIncrement=from_nullable_float(cim.step_voltage_increment)
)
def recloser_to_pb(cim: Recloser) -> PBRecloser:
return PBRecloser(sw=protected_switch_to_pb(cim))
def regulating_cond_eq_to_pb(cim: RegulatingCondEq, include_asset_info=False) -> PBRegulatingCondEq:
return PBRegulatingCondEq(
ec=energy_connection_to_pb(cim, include_asset_info),
controlEnabled=cim.control_enabled
)
def shunt_compensator_to_pb(cim: ShuntCompensator) -> PBShuntCompensator:
return PBShuntCompensator(
rce=regulating_cond_eq_to_pb(cim, True),
sections=from_nullable_float(cim.sections),
grounded=cim.grounded,
nomU=from_nullable_int(cim.nom_u),
phaseConnection=PBPhaseShuntConnectionKind.Enum.Value(cim.phase_connection.short_name)
)
def switch_to_pb(cim: Switch) -> PBSwitch:
return PBSwitch(
ce=conducting_equipment_to_pb(cim),
normalOpen=cim.get_normal_state(),
open=cim.get_state()
)
def tap_changer_to_pb(cim: TapChanger) -> PBTapChanger:
return PBTapChanger(
psr=power_system_resource_to_pb(cim),
highStep=from_nullable_int(cim.high_step),
lowStep=from_nullable_int(cim.low_step),
step=from_nullable_float(cim.step),
neutralStep=from_nullable_int(cim.neutral_step),
neutralU=from_nullable_int(cim.neutral_u),
normalStep=from_nullable_int(cim.normal_step),
controlEnabled=cim.control_enabled
)
def transformer_end_to_pb(cim: TransformerEnd) -> PBTransformerEnd:
return PBTransformerEnd(
io=identified_object_to_pb(cim),
terminalMRID=mrid_or_empty(cim.terminal),
baseVoltageMRID=mrid_or_empty(cim.base_voltage),
ratioTapChangerMRID=mrid_or_empty(cim.ratio_tap_changer),
starImpedanceMRID=mrid_or_empty(cim.star_impedance),
endNumber=cim.end_number,
grounded=cim.grounded,
rGround=from_nullable_float(cim.r_ground),
xGround=from_nullable_float(cim.x_ground)
)
def transformer_star_impedance_to_pb(cim: TransformerStarImpedance) -> PBTransformerStarImpedance:
return PBTransformerStarImpedance(
io=identified_object_to_pb(cim),
r=cim.r if cim.r else 0.0,
r0=cim.r0 if cim.r0 else 0.0,
x=cim.x if cim.x else 0.0,
x0=cim.x0 if cim.x0 else 0.0,
transformerEndInfoMRID=mrid_or_empty(cim.transformer_end_info)
)
AcLineSegment.to_pb = ac_line_segment_to_pb
Breaker.to_pb = breaker_to_pb
BusbarSection.to_pb = busbar_section_to_pb
Conductor.to_pb = conductor_to_pb
Connector.to_pb = connector_to_pb
Disconnector.to_pb = disconnector_to_pb
EnergyConnection.to_pb = energy_connection_to_pb
EnergyConsumer.to_pb = energy_consumer_to_pb
EnergyConsumerPhase.to_pb = energy_consumer_phase_to_pb
EnergySource.to_pb = energy_source_to_pb
EnergySourcePhase.to_pb = energy_source_phase_to_pb
Fuse.to_pb = fuse_to_pb
Jumper.to_pb = jumper_to_pb
Junction.to_pb = junction_to_pb
Line.to_pb = line_to_pb
LinearShuntCompensator.to_pb = linear_shunt_compensator_to_pb
LoadBreakSwitch.to_pb = load_break_switch_to_pb
PerLengthImpedance.to_pb = per_length_impedance_to_pb
PerLengthLineParameter.to_pb = per_length_line_parameter_to_pb
PerLengthSequenceImpedance.to_pb = per_length_sequence_impedance_to_pb
PowerElectronicsConnection.to_pb = power_electronics_connection_to_pb
PowerElectronicsConnectionPhase.to_pb = power_electronics_connection_phase_to_pb
PowerTransformer.to_pb = power_transformer_to_pb
PowerTransformerEnd.to_pb = power_transformer_end_to_pb
ProtectedSwitch.to_pb = protected_switch_to_pb
RatioTapChanger.to_pb = ratio_tap_changer_to_pb
Recloser.to_pb = recloser_to_pb
RegulatingCondEq.to_pb = regulating_cond_eq_to_pb
ShuntCompensator.to_pb = shunt_compensator_to_pb
Switch.to_pb = switch_to_pb
TapChanger.to_pb = tap_changer_to_pb
TransformerEnd.to_pb = transformer_end_to_pb
TransformerStarImpedance.to_pb = transformer_star_impedance_to_pb
###############################
# IEC61970 INFIEC61970 FEEDER #
###############################
def circuit_to_pb(cim: Circuit) -> PBCircuit:
return PBCircuit(
l=line_to_pb(cim),
loopMRID=mrid_or_empty(cim.loop),
endTerminalMRIDs=[str(io.mrid) for io in cim.end_terminals],
endSubstationMRIDs=[str(io.mrid) for io in cim.end_substations]
)
def loop_to_pb(cim: Loop) -> PBLoop:
return PBLoop(
io=identified_object_to_pb(cim),
circuitMRIDs=[str(io.mrid) for io in cim.circuits],
substationMRIDs=[str(io.mrid) for io in cim.substations],
normalEnergizingSubstationMRIDs=[str(io.mrid) for io in cim.energizing_substations]
)
Circuit.to_pb = circuit_to_pb
Loop.to_pb = loop_to_pb | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/translator/network_cim2proto.py | network_cim2proto.py |
from __future__ import annotations
from typing import Optional
from zepben.protobuf.cim.iec61968.assetinfo.CableInfo_pb2 import CableInfo as PBCableInfo
from zepben.protobuf.cim.iec61968.assetinfo.NoLoadTest_pb2 import NoLoadTest as PBNoLoadTest
from zepben.protobuf.cim.iec61968.assetinfo.OpenCircuitTest_pb2 import OpenCircuitTest as PBOpenCircuitTest
from zepben.protobuf.cim.iec61968.assetinfo.OverheadWireInfo_pb2 import OverheadWireInfo as PBOverheadWireInfo
from zepben.protobuf.cim.iec61968.assetinfo.PowerTransformerInfo_pb2 import PowerTransformerInfo as PBPowerTransformerInfo
from zepben.protobuf.cim.iec61968.assetinfo.ShortCircuitTest_pb2 import ShortCircuitTest as PBShortCircuitTest
from zepben.protobuf.cim.iec61968.assetinfo.ShuntCompensatorInfo_pb2 import ShuntCompensatorInfo as PBShuntCompensatorInfo
from zepben.protobuf.cim.iec61968.assetinfo.TransformerEndInfo_pb2 import TransformerEndInfo as PBTransformerEndInfo
from zepben.protobuf.cim.iec61968.assetinfo.TransformerTankInfo_pb2 import TransformerTankInfo as PBTransformerTankInfo
from zepben.protobuf.cim.iec61968.assetinfo.TransformerTest_pb2 import TransformerTest as PBTransformerTest
from zepben.protobuf.cim.iec61968.assetinfo.WireInfo_pb2 import WireInfo as PBWireInfo
from zepben.protobuf.cim.iec61968.assets.AssetContainer_pb2 import AssetContainer as PBAssetContainer
from zepben.protobuf.cim.iec61968.assets.AssetInfo_pb2 import AssetInfo as PBAssetInfo
from zepben.protobuf.cim.iec61968.assets.AssetOrganisationRole_pb2 import AssetOrganisationRole as PBAssetOrganisationRole
from zepben.protobuf.cim.iec61968.assets.AssetOwner_pb2 import AssetOwner as PBAssetOwner
from zepben.protobuf.cim.iec61968.assets.Asset_pb2 import Asset as PBAsset
from zepben.protobuf.cim.iec61968.assets.Pole_pb2 import Pole as PBPole
from zepben.protobuf.cim.iec61968.assets.Streetlight_pb2 import Streetlight as PBStreetlight
from zepben.protobuf.cim.iec61968.assets.Structure_pb2 import Structure as PBStructure
from zepben.protobuf.cim.iec61968.common.Location_pb2 import Location as PBLocation
from zepben.protobuf.cim.iec61968.common.PositionPoint_pb2 import PositionPoint as PBPositionPoint
from zepben.protobuf.cim.iec61968.common.StreetAddress_pb2 import StreetAddress as PBStreetAddress
from zepben.protobuf.cim.iec61968.common.TownDetail_pb2 import TownDetail as PBTownDetail
from zepben.protobuf.cim.iec61968.common.StreetDetail_pb2 import StreetDetail as PBStreetDetail
from zepben.protobuf.cim.iec61968.metering.EndDevice_pb2 import EndDevice as PBEndDevice
from zepben.protobuf.cim.iec61968.metering.Meter_pb2 import Meter as PBMeter
from zepben.protobuf.cim.iec61968.metering.UsagePoint_pb2 import UsagePoint as PBUsagePoint
from zepben.protobuf.cim.iec61968.operations.OperationalRestriction_pb2 import OperationalRestriction as PBOperationalRestriction
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.AuxiliaryEquipment_pb2 import AuxiliaryEquipment as PBAuxiliaryEquipment
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.FaultIndicator_pb2 import FaultIndicator as PBFaultIndicator
from zepben.protobuf.cim.iec61970.base.core.AcDcTerminal_pb2 import AcDcTerminal as PBAcDcTerminal
from zepben.protobuf.cim.iec61970.base.core.BaseVoltage_pb2 import BaseVoltage as PBBaseVoltage
from zepben.protobuf.cim.iec61970.base.core.ConductingEquipment_pb2 import ConductingEquipment as PBConductingEquipment
from zepben.protobuf.cim.iec61970.base.core.ConnectivityNodeContainer_pb2 import ConnectivityNodeContainer as PBConnectivityNodeContainer
from zepben.protobuf.cim.iec61970.base.core.ConnectivityNode_pb2 import ConnectivityNode as PBConnectivityNode
from zepben.protobuf.cim.iec61970.base.core.EquipmentContainer_pb2 import EquipmentContainer as PBEquipmentContainer
from zepben.protobuf.cim.iec61970.base.core.Equipment_pb2 import Equipment as PBEquipment
from zepben.protobuf.cim.iec61970.base.core.Feeder_pb2 import Feeder as PBFeeder
from zepben.protobuf.cim.iec61970.base.core.GeographicalRegion_pb2 import GeographicalRegion as PBGeographicalRegion
from zepben.protobuf.cim.iec61970.base.core.PowerSystemResource_pb2 import PowerSystemResource as PBPowerSystemResource
from zepben.protobuf.cim.iec61970.base.core.Site_pb2 import Site as PBSite
from zepben.protobuf.cim.iec61970.base.core.SubGeographicalRegion_pb2 import SubGeographicalRegion as PBSubGeographicalRegion
from zepben.protobuf.cim.iec61970.base.core.Substation_pb2 import Substation as PBSubstation
from zepben.protobuf.cim.iec61970.base.core.Terminal_pb2 import Terminal as PBTerminal
from zepben.protobuf.cim.iec61970.base.equivalents.EquivalentBranch_pb2 import EquivalentBranch as PBEquivalentBranch
from zepben.protobuf.cim.iec61970.base.equivalents.EquivalentEquipment_pb2 import EquivalentEquipment as PBEquivalentEquipment
from zepben.protobuf.cim.iec61970.base.meas.Accumulator_pb2 import Accumulator as PBAccumulator
from zepben.protobuf.cim.iec61970.base.meas.Analog_pb2 import Analog as PBAnalog
from zepben.protobuf.cim.iec61970.base.meas.Control_pb2 import Control as PBControl
from zepben.protobuf.cim.iec61970.base.meas.Discrete_pb2 import Discrete as PBDiscrete
from zepben.protobuf.cim.iec61970.base.meas.IoPoint_pb2 import IoPoint as PBIoPoint
from zepben.protobuf.cim.iec61970.base.meas.Measurement_pb2 import Measurement as PBMeasurement
from zepben.protobuf.cim.iec61970.base.scada.RemoteControl_pb2 import RemoteControl as PBRemoteControl
from zepben.protobuf.cim.iec61970.base.scada.RemotePoint_pb2 import RemotePoint as PBRemotePoint
from zepben.protobuf.cim.iec61970.base.scada.RemoteSource_pb2 import RemoteSource as PBRemoteSource
from zepben.protobuf.cim.iec61970.base.wires.AcLineSegment_pb2 import AcLineSegment as PBAcLineSegment
from zepben.protobuf.cim.iec61970.base.wires.Breaker_pb2 import Breaker as PBBreaker
from zepben.protobuf.cim.iec61970.base.wires.BusbarSection_pb2 import BusbarSection as PBBusbarSection
from zepben.protobuf.cim.iec61970.base.wires.Conductor_pb2 import Conductor as PBConductor
from zepben.protobuf.cim.iec61970.base.wires.Connector_pb2 import Connector as PBConnector
from zepben.protobuf.cim.iec61970.base.wires.Disconnector_pb2 import Disconnector as PBDisconnector
from zepben.protobuf.cim.iec61970.base.wires.EnergyConnection_pb2 import EnergyConnection as PBEnergyConnection
from zepben.protobuf.cim.iec61970.base.wires.EnergyConsumerPhase_pb2 import EnergyConsumerPhase as PBEnergyConsumerPhase
from zepben.protobuf.cim.iec61970.base.wires.EnergyConsumer_pb2 import EnergyConsumer as PBEnergyConsumer
from zepben.protobuf.cim.iec61970.base.wires.EnergySourcePhase_pb2 import EnergySourcePhase as PBEnergySourcePhase
from zepben.protobuf.cim.iec61970.base.wires.EnergySource_pb2 import EnergySource as PBEnergySource
from zepben.protobuf.cim.iec61970.base.wires.Fuse_pb2 import Fuse as PBFuse
from zepben.protobuf.cim.iec61970.base.wires.Jumper_pb2 import Jumper as PBJumper
from zepben.protobuf.cim.iec61970.base.wires.Junction_pb2 import Junction as PBJunction
from zepben.protobuf.cim.iec61970.base.wires.Line_pb2 import Line as PBLine
from zepben.protobuf.cim.iec61970.base.wires.LinearShuntCompensator_pb2 import LinearShuntCompensator as PBLinearShuntCompensator
from zepben.protobuf.cim.iec61970.base.wires.LoadBreakSwitch_pb2 import LoadBreakSwitch as PBLoadBreakSwitch
from zepben.protobuf.cim.iec61970.base.wires.PerLengthImpedance_pb2 import PerLengthImpedance as PBPerLengthImpedance
from zepben.protobuf.cim.iec61970.base.wires.PerLengthLineParameter_pb2 import PerLengthLineParameter as PBPerLengthLineParameter
from zepben.protobuf.cim.iec61970.base.wires.PerLengthSequenceImpedance_pb2 import PerLengthSequenceImpedance as PBPerLengthSequenceImpedance
from zepben.protobuf.cim.iec61970.base.wires.PowerElectronicsConnectionPhase_pb2 import PowerElectronicsConnectionPhase as PBPowerElectronicsConnectionPhase
from zepben.protobuf.cim.iec61970.base.wires.PowerElectronicsConnection_pb2 import PowerElectronicsConnection as PBPowerElectronicsConnection
from zepben.protobuf.cim.iec61970.base.wires.PowerTransformerEnd_pb2 import PowerTransformerEnd as PBPowerTransformerEnd
from zepben.protobuf.cim.iec61970.base.wires.PowerTransformer_pb2 import PowerTransformer as PBPowerTransformer
from zepben.protobuf.cim.iec61970.base.wires.ProtectedSwitch_pb2 import ProtectedSwitch as PBProtectedSwitch
from zepben.protobuf.cim.iec61970.base.wires.RatioTapChanger_pb2 import RatioTapChanger as PBRatioTapChanger
from zepben.protobuf.cim.iec61970.base.wires.Recloser_pb2 import Recloser as PBRecloser
from zepben.protobuf.cim.iec61970.base.wires.RegulatingCondEq_pb2 import RegulatingCondEq as PBRegulatingCondEq
from zepben.protobuf.cim.iec61970.base.wires.ShuntCompensator_pb2 import ShuntCompensator as PBShuntCompensator
from zepben.protobuf.cim.iec61970.base.wires.Switch_pb2 import Switch as PBSwitch
from zepben.protobuf.cim.iec61970.base.wires.TapChanger_pb2 import TapChanger as PBTapChanger
from zepben.protobuf.cim.iec61970.base.wires.TransformerEnd_pb2 import TransformerEnd as PBTransformerEnd
from zepben.protobuf.cim.iec61970.base.wires.TransformerStarImpedance_pb2 import TransformerStarImpedance as PBTransformerStarImpedance
from zepben.protobuf.cim.iec61970.base.wires.generation.production.BatteryUnit_pb2 import BatteryUnit as PBBatteryUnit
from zepben.protobuf.cim.iec61970.base.wires.generation.production.PhotoVoltaicUnit_pb2 import PhotoVoltaicUnit as PBPhotoVoltaicUnit
from zepben.protobuf.cim.iec61970.base.wires.generation.production.PowerElectronicsUnit_pb2 import PowerElectronicsUnit as PBPowerElectronicsUnit
from zepben.protobuf.cim.iec61970.base.wires.generation.production.PowerElectronicsWindUnit_pb2 import PowerElectronicsWindUnit as PBPowerElectronicsWindUnit
from zepben.protobuf.cim.iec61970.infiec61970.feeder.Circuit_pb2 import Circuit as PBCircuit
from zepben.protobuf.cim.iec61970.infiec61970.feeder.Loop_pb2 import Loop as PBLoop
import zepben.evolve.services.common.resolver as resolver
from zepben.evolve import TransformerTankInfo, TransformerEndInfo, TransformerStarImpedance, NoLoadTest, OpenCircuitTest, ShortCircuitTest, TransformerTest, \
TracedPhases, ShuntCompensatorInfo, TransformerConstructionKind, TransformerFunctionKind
from zepben.evolve.model.cim.iec61968.assetinfo.power_transformer_info import *
from zepben.evolve.model.cim.iec61968.assetinfo.wire_info import *
from zepben.evolve.model.cim.iec61968.assetinfo.wire_material_kind import *
from zepben.evolve.model.cim.iec61968.assets.asset import *
from zepben.evolve.model.cim.iec61968.assets.asset_info import *
from zepben.evolve.model.cim.iec61968.assets.asset_organisation_role import *
from zepben.evolve.model.cim.iec61968.assets.pole import *
from zepben.evolve.model.cim.iec61968.assets.streetlight import *
from zepben.evolve.model.cim.iec61968.assets.structure import *
from zepben.evolve.model.cim.iec61968.common.location import *
from zepben.evolve.model.cim.iec61968.metering.metering import *
from zepben.evolve.model.cim.iec61968.operations.operational_restriction import *
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.auxiliary_equipment import *
from zepben.evolve.model.cim.iec61970.base.core.base_voltage import *
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import *
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node import *
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node_container import *
from zepben.evolve.model.cim.iec61970.base.core.equipment import *
from zepben.evolve.model.cim.iec61970.base.core.equipment_container import *
from zepben.evolve.model.cim.iec61970.base.core.phase_code import *
from zepben.evolve.model.cim.iec61970.base.core.power_system_resource import *
from zepben.evolve.model.cim.iec61970.base.core.regions import *
from zepben.evolve.model.cim.iec61970.base.core.substation import *
from zepben.evolve.model.cim.iec61970.base.core.terminal import *
from zepben.evolve.model.cim.iec61970.base.domain.unit_symbol import *
from zepben.evolve.model.cim.iec61970.base.equivalents.equivalent_branch import *
from zepben.evolve.model.cim.iec61970.base.equivalents.equivalent_equipment import *
from zepben.evolve.model.cim.iec61970.base.meas.control import *
from zepben.evolve.model.cim.iec61970.base.meas.iopoint import *
from zepben.evolve.model.cim.iec61970.base.meas.measurement import *
from zepben.evolve.model.cim.iec61970.base.scada.remote_control import *
from zepben.evolve.model.cim.iec61970.base.scada.remote_point import *
from zepben.evolve.model.cim.iec61970.base.scada.remote_source import *
from zepben.evolve.model.cim.iec61970.base.wires.aclinesegment import *
from zepben.evolve.model.cim.iec61970.base.wires.connectors import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_connection import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_consumer import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_source import *
from zepben.evolve.model.cim.iec61970.base.wires.energy_source_phase import *
from zepben.evolve.model.cim.iec61970.base.wires.generation.production.battery_state_kind import *
from zepben.evolve.model.cim.iec61970.base.wires.generation.production.power_electronics_unit import *
from zepben.evolve.model.cim.iec61970.base.wires.line import *
from zepben.evolve.model.cim.iec61970.base.wires.per_length import *
from zepben.evolve.model.cim.iec61970.base.wires.phase_shunt_connection_kind import *
from zepben.evolve.model.cim.iec61970.base.wires.power_electronics_connection import *
from zepben.evolve.model.cim.iec61970.base.wires.power_transformer import *
from zepben.evolve.model.cim.iec61970.base.wires.shunt_compensator import *
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import *
from zepben.evolve.model.cim.iec61970.base.wires.switch import *
from zepben.evolve.model.cim.iec61970.base.wires.vector_group import *
from zepben.evolve.model.cim.iec61970.base.wires.winding_connection import *
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.circuit import *
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.loop import *
from zepben.evolve.services.common.translator.base_proto2cim import identified_object_to_cim, organisation_role_to_cim, document_to_cim
from zepben.evolve.services.common.translator.util import int_or_none, float_or_none, long_or_none, str_or_none, uint_or_none
from zepben.evolve.services.network.network_service import NetworkService
__all__ = [
"cable_info_to_cim", "no_load_test_to_cim", "open_circuit_test_to_cim", "overhead_wire_info_to_cim", "power_transformer_info_to_cim",
"short_circuit_test_to_cim", "shunt_compensator_info_to_cim", "transformer_end_info_to_cim", "transformer_tank_info_to_cim", "transformer_test_to_cim",
"wire_info_to_cim", "asset_to_cim", "asset_container_to_cim", "asset_info_to_cim", "asset_organisation_role_to_cim", "asset_owner_to_cim", "pole_to_cim",
"streetlight_to_cim", "structure_to_cim", "location_to_cim", "position_point_to_cim", "street_address_to_cim", "town_detail_to_cim", "end_device_to_cim",
"meter_to_cim", "usage_point_to_cim", "operational_restriction_to_cim", "auxiliary_equipment_to_cim", "fault_indicator_to_cim", "ac_dc_terminal_to_cim",
"base_voltage_to_cim", "conducting_equipment_to_cim", "connectivity_node_to_cim", "connectivity_node_container_to_cim", "equipment_to_cim",
"equipment_container_to_cim", "feeder_to_cim", "geographical_region_to_cim", "power_system_resource_to_cim", "site_to_cim",
"sub_geographical_region_to_cim", "substation_to_cim", "terminal_to_cim", "equivalent_branch_to_cim", "equivalent_equipment_to_cim", "accumulator_to_cim",
"analog_to_cim", "control_to_cim", "discrete_to_cim", "io_point_to_cim", "measurement_to_cim", "remote_control_to_cim", "remote_point_to_cim",
"remote_source_to_cim", "battery_unit_to_cim", "photo_voltaic_unit_to_cim", "power_electronics_unit_to_cim", "power_electronics_wind_unit_to_cim",
"ac_line_segment_to_cim", "breaker_to_cim", "conductor_to_cim", "connector_to_cim", "disconnector_to_cim", "energy_connection_to_cim",
"energy_consumer_to_cim", "energy_consumer_phase_to_cim", "energy_source_to_cim", "energy_source_phase_to_cim", "fuse_to_cim", "jumper_to_cim",
"junction_to_cim", "busbar_section_to_cim", "line_to_cim", "linear_shunt_compensator_to_cim", "load_break_switch_to_cim",
"per_length_line_parameter_to_cim", "per_length_impedance_to_cim", "per_length_sequence_impedance_to_cim", "power_electronics_connection_to_cim",
"power_electronics_connection_phase_to_cim", "power_transformer_to_cim", "power_transformer_end_to_cim", "transformer_star_impedance_to_cim",
"protected_switch_to_cim", "ratio_tap_changer_to_cim", "recloser_to_cim", "regulating_cond_eq_to_cim", "shunt_compensator_to_cim", "switch_to_cim",
"tap_changer_to_cim", "transformer_end_to_cim", "circuit_to_cim", "loop_to_cim",
]
#######################
# IEC61968 ASSET INFO #
#######################
from zepben.evolve.services.network.tracing.feeder.feeder_direction import FeederDirection
def cable_info_to_cim(pb: PBCableInfo, network_service: NetworkService) -> Optional[CableInfo]:
# noinspection PyArgumentList
cim = CableInfo(mrid=pb.mrid())
wire_info_to_cim(pb.wi, cim, network_service)
return cim if network_service.add(cim) else None
def no_load_test_to_cim(pb: PBNoLoadTest, network_service: NetworkService) -> Optional[NoLoadTest]:
# noinspection PyArgumentList
cim = NoLoadTest(
mrid=pb.mrid(),
energised_end_voltage=int_or_none(pb.energisedEndVoltage),
exciting_current=float_or_none(pb.excitingCurrent),
exciting_current_zero=float_or_none(pb.excitingCurrentZero),
loss=int_or_none(pb.loss),
loss_zero=int_or_none(pb.lossZero),
)
transformer_test_to_cim(pb.tt, cim, network_service)
return cim if network_service.add(cim) else None
def open_circuit_test_to_cim(pb: PBOpenCircuitTest, network_service: NetworkService) -> Optional[OpenCircuitTest]:
# noinspection PyArgumentList
cim = OpenCircuitTest(
mrid=pb.mrid(),
energised_end_step=int_or_none(pb.energisedEndStep),
energised_end_voltage=int_or_none(pb.energisedEndVoltage),
open_end_step=int_or_none(pb.openEndStep),
open_end_voltage=int_or_none(pb.openEndVoltage),
phase_shift=float_or_none(pb.phaseShift),
)
transformer_test_to_cim(pb.tt, cim, network_service)
return cim if network_service.add(cim) else None
def overhead_wire_info_to_cim(pb: PBOverheadWireInfo, network_service: NetworkService) -> Optional[OverheadWireInfo]:
# noinspection PyArgumentList
cim = OverheadWireInfo(mrid=pb.mrid())
wire_info_to_cim(pb.wi, cim, network_service)
return cim if network_service.add(cim) else None
def power_transformer_info_to_cim(pb: PBPowerTransformerInfo, network_service: NetworkService) -> Optional[PowerTransformerInfo]:
cim = PowerTransformerInfo(mrid=pb.mrid())
for mrid in pb.transformerTankInfoMRIDs:
network_service.resolve_or_defer_reference(resolver.power_transformer_info_transformer_tank_info(cim), mrid)
asset_info_to_cim(pb.ai, cim, network_service)
return cim if network_service.add(cim) else None
def short_circuit_test_to_cim(pb: PBShortCircuitTest, network_service: NetworkService) -> Optional[ShortCircuitTest]:
# noinspection PyArgumentList
cim = ShortCircuitTest(
mrid=pb.mrid(),
current=float_or_none(pb.current),
energised_end_step=int_or_none(pb.energisedEndStep),
grounded_end_step=int_or_none(pb.groundedEndStep),
leakage_impedance=float_or_none(pb.leakageImpedance),
leakage_impedance_zero=float_or_none(pb.leakageImpedanceZero),
loss=int_or_none(pb.loss),
loss_zero=int_or_none(pb.lossZero),
power=int_or_none(pb.power),
voltage=float_or_none(pb.voltage),
voltage_ohmic_part=float_or_none(pb.voltageOhmicPart),
)
transformer_test_to_cim(pb.tt, cim, network_service)
return cim if network_service.add(cim) else None
def shunt_compensator_info_to_cim(pb: PBShuntCompensatorInfo, network_service: NetworkService) -> Optional[ShuntCompensatorInfo]:
cim = ShuntCompensatorInfo(
mrid=pb.mrid(),
max_power_loss=int_or_none(pb.maxPowerLoss),
rated_current=int_or_none(pb.ratedCurrent),
rated_reactive_power=int_or_none(pb.ratedReactivePower),
rated_voltage=int_or_none(pb.ratedVoltage),
)
asset_info_to_cim(pb.ai, cim, network_service)
return cim if network_service.add(cim) else None
def transformer_end_info_to_cim(pb: PBTransformerEndInfo, network_service: NetworkService) -> Optional[TransformerEndInfo]:
# noinspection PyArgumentList
cim = TransformerEndInfo(
mrid=pb.mrid(),
connection_kind=WindingConnection(pb.connectionKind),
emergency_s=int_or_none(pb.emergencyS),
end_number=pb.endNumber,
insulation_u=int_or_none(pb.insulationU),
phase_angle_clock=int_or_none(pb.phaseAngleClock),
r=float_or_none(pb.r),
rated_s=int_or_none(pb.ratedS),
rated_u=int_or_none(pb.ratedU),
short_term_s=int_or_none(pb.shortTermS),
)
network_service.resolve_or_defer_reference(resolver.transformer_tank_info(cim), pb.transformerTankInfoMRID)
network_service.resolve_or_defer_reference(resolver.transformer_star_impedance(cim), pb.transformerStarImpedanceMRID)
network_service.resolve_or_defer_reference(resolver.energised_end_no_load_tests(cim), pb.energisedEndNoLoadTestsMRID)
network_service.resolve_or_defer_reference(resolver.energised_end_short_circuit_tests(cim), pb.energisedEndShortCircuitTestsMRID)
network_service.resolve_or_defer_reference(resolver.grounded_end_short_circuit_tests(cim), pb.groundedEndShortCircuitTestsMRID)
network_service.resolve_or_defer_reference(resolver.open_end_open_circuit_tests(cim), pb.openEndOpenCircuitTestsMRID)
network_service.resolve_or_defer_reference(resolver.energised_end_open_circuit_tests(cim), pb.energisedEndOpenCircuitTestsMRID)
asset_info_to_cim(pb.ai, cim, network_service)
return cim if network_service.add(cim) else None
def transformer_tank_info_to_cim(pb: PBTransformerTankInfo, network_service: NetworkService) -> Optional[TransformerTankInfo]:
cim = TransformerTankInfo(mrid=pb.mrid())
for mrid in pb.transformerEndInfoMRIDs:
network_service.resolve_or_defer_reference(resolver.transformer_end_info(cim), mrid)
asset_info_to_cim(pb.ai, cim, network_service)
return cim if network_service.add(cim) else None
def transformer_test_to_cim(pb: PBTransformerTest, cim: TransformerTest, network_service: NetworkService):
cim.base_power = int_or_none(pb.basePower)
cim.temperature = float_or_none(pb.temperature)
identified_object_to_cim(pb.io, cim, network_service)
def wire_info_to_cim(pb: PBWireInfo, cim: WireInfo, network_service: NetworkService):
cim.rated_current = int_or_none(pb.ratedCurrent)
cim.material = WireMaterialKind(pb.material)
asset_info_to_cim(pb.ai, cim, network_service)
PBCableInfo.to_cim = cable_info_to_cim
PBNoLoadTest.to_cim = no_load_test_to_cim
PBOpenCircuitTest.to_cim = open_circuit_test_to_cim
PBOverheadWireInfo.to_cim = overhead_wire_info_to_cim
PBPowerTransformerInfo.to_cim = power_transformer_info_to_cim
PBShortCircuitTest.to_cim = short_circuit_test_to_cim
PBShuntCompensatorInfo.to_cim = shunt_compensator_info_to_cim
PBTransformerEndInfo.to_cim = transformer_end_info_to_cim
PBTransformerTankInfo.to_cim = transformer_tank_info_to_cim
PBTransformerTest.to_cim = transformer_test_to_cim
PBWireInfo.to_cim = wire_info_to_cim
###################
# IEC61968 ASSETS #
###################
def asset_to_cim(pb: PBAsset, cim: Asset, network_service: NetworkService):
network_service.resolve_or_defer_reference(resolver.at_location(cim), pb.locationMRID)
for mrid in pb.organisationRoleMRIDs:
network_service.resolve_or_defer_reference(resolver.organisation_roles(cim), mrid)
identified_object_to_cim(pb.io, cim, network_service)
def asset_container_to_cim(pb: PBAssetContainer, cim: AssetContainer, network_service: NetworkService):
asset_to_cim(pb.at, cim, network_service)
def asset_info_to_cim(pb: PBAssetInfo, cim: AssetInfo, network_service: NetworkService):
identified_object_to_cim(pb.io, cim, network_service)
def asset_organisation_role_to_cim(pb: PBAssetOrganisationRole, cim: AssetOrganisationRole,
network_service: NetworkService):
organisation_role_to_cim(getattr(pb, 'or'), cim, network_service)
def asset_owner_to_cim(pb: PBAssetOwner, network_service: NetworkService) -> Optional[AssetOwner]:
# noinspection PyArgumentList
cim = AssetOwner(mrid=pb.mrid())
asset_organisation_role_to_cim(pb.aor, cim, network_service)
return cim if network_service.add(cim) else None
def pole_to_cim(pb: PBPole, network_service: NetworkService) -> Optional[Pole]:
cim = Pole(mrid=pb.mrid(), classification=pb.classification)
for mrid in pb.streetlightMRIDs:
network_service.resolve_or_defer_reference(resolver.streetlights(cim), mrid)
structure_to_cim(pb.st, cim, network_service)
return cim if network_service.add(cim) else None
def streetlight_to_cim(pb: PBStreetlight, network_service: NetworkService) -> Optional[Streetlight]:
cim = Streetlight(
mrid=pb.mrid(),
light_rating=uint_or_none(pb.lightRating),
lamp_kind=StreetlightLampKind(pb.lampKind)
)
network_service.resolve_or_defer_reference(resolver.pole(cim), pb.poleMRID)
asset_to_cim(pb.at, cim, network_service)
return cim if network_service.add(cim) else None
def structure_to_cim(pb: PBStructure, cim: Structure, network_service: NetworkService):
asset_container_to_cim(pb.ac, cim, network_service)
PBAsset.to_cim = asset_to_cim
PBAssetContainer.to_cim = asset_container_to_cim
PBAssetInfo.to_cim = asset_info_to_cim
PBAssetOrganisationRole.to_cim = asset_organisation_role_to_cim
PBAssetOwner.to_cim = asset_owner_to_cim
PBPole.to_cim = pole_to_cim
PBStreetlight.to_cim = streetlight_to_cim
PBStructure.to_cim = structure_to_cim
###################
# IEC61968 COMMON #
###################
def location_to_cim(pb: PBLocation, network_service: NetworkService) -> Optional[Location]:
cim = Location(mrid=pb.mrid(), main_address=street_address_to_cim(pb.mainAddress) if pb.HasField('mainAddress') else None)
for point in pb.positionPoints:
cim.add_point(position_point_to_cim(point))
identified_object_to_cim(pb.io, cim, network_service)
return cim if network_service.add(cim) else None
def position_point_to_cim(pb: PBPositionPoint) -> Optional[PositionPoint]:
# noinspection PyArgumentList
return PositionPoint(pb.xPosition, pb.yPosition)
def street_address_to_cim(pb: PBStreetAddress) -> Optional[StreetAddress]:
# noinspection PyArgumentList
return StreetAddress(
postal_code=pb.postalCode,
town_detail=town_detail_to_cim(pb.townDetail) if pb.HasField('townDetail') else None,
po_box=pb.poBox,
street_detail=street_detail_to_cim(pb.streetDetail) if pb.HasField('streetDetail') else None
)
def street_detail_to_cim(pb: PBStreetDetail) -> Optional[StreetDetail]:
# noinspection PyArgumentList
return StreetDetail(
building_name=pb.buildingName,
floor_identification=pb.floorIdentification,
name=pb.name,
number=pb.number,
suite_number=pb.suiteNumber,
type=pb.type,
display_address=pb.displayAddress
)
def town_detail_to_cim(pb: PBTownDetail) -> Optional[TownDetail]:
# noinspection PyArgumentList
return TownDetail(name=pb.name, state_or_province=pb.stateOrProvince)
PBLocation.to_cim = location_to_cim
PBPositionPoint.to_cim = position_point_to_cim
PBTownDetail.to_cim = town_detail_to_cim
PBStreetAddress.to_cim = street_address_to_cim
#####################
# IEC61968 METERING #
#####################
def end_device_to_cim(pb: PBEndDevice, cim: EndDevice, network_service: NetworkService):
cim.customer_mrid = pb.customerMRID if pb.customerMRID else None
for mrid in pb.usagePointMRIDs:
network_service.resolve_or_defer_reference(resolver.ed_usage_points(cim), mrid)
network_service.resolve_or_defer_reference(resolver.service_location(cim), pb.serviceLocationMRID)
asset_container_to_cim(pb.ac, cim, network_service)
def meter_to_cim(pb: PBMeter, network_service: NetworkService) -> Optional[Meter]:
cim = Meter(mrid=pb.mrid())
end_device_to_cim(pb.ed, cim, network_service)
return cim if network_service.add(cim) else None
def usage_point_to_cim(pb: PBUsagePoint, network_service: NetworkService) -> Optional[UsagePoint]:
cim = UsagePoint(mrid=pb.mrid())
network_service.resolve_or_defer_reference(resolver.usage_point_location(cim), pb.usagePointLocationMRID)
cim.is_virtual = pb.isVirtual
cim.connection_category = pb.connectionCategory if pb.connectionCategory else None
for mrid in pb.equipmentMRIDs:
network_service.resolve_or_defer_reference(resolver.up_equipment(cim), mrid)
for mrid in pb.endDeviceMRIDs:
network_service.resolve_or_defer_reference(resolver.end_devices(cim), mrid)
identified_object_to_cim(pb.io, cim, network_service)
return cim if network_service.add(cim) else None
PBEndDevice.to_cim = end_device_to_cim
PBMeter.to_cim = meter_to_cim
PBUsagePoint.to_cim = usage_point_to_cim
#######################
# IEC61968 OPERATIONS #
#######################
def operational_restriction_to_cim(pb: PBOperationalRestriction, network_service: NetworkService) -> Optional[OperationalRestriction]:
cim = OperationalRestriction(mrid=pb.mrid())
document_to_cim(pb.doc, cim, network_service)
return cim if network_service.add(cim) else None
PBOperationalRestriction.to_cim = operational_restriction_to_cim
#####################################
# IEC61970 BASE AUXILIARY EQUIPMENT #
#####################################
def auxiliary_equipment_to_cim(pb: PBAuxiliaryEquipment, cim: AuxiliaryEquipment, network_service: NetworkService):
network_service.resolve_or_defer_reference(resolver.ae_terminal(cim), pb.terminalMRID)
equipment_to_cim(pb.eq, cim, network_service)
def fault_indicator_to_cim(pb: PBFaultIndicator, network_service: NetworkService) -> Optional[FaultIndicator]:
cim = FaultIndicator(mrid=pb.mrid())
auxiliary_equipment_to_cim(pb.ae, cim, network_service)
return cim if network_service.add(cim) else None
PBAuxiliaryEquipment.to_cim = auxiliary_equipment_to_cim
PBFaultIndicator.to_cim = fault_indicator_to_cim
######################
# IEC61970 BASE CORE #
######################
def ac_dc_terminal_to_cim(pb: PBAcDcTerminal, cim: AcDcTerminal, network_service: NetworkService):
identified_object_to_cim(pb.io, cim, network_service)
def base_voltage_to_cim(pb: PBBaseVoltage, network_service: NetworkService) -> Optional[BaseVoltage]:
# noinspection PyArgumentList
cim = BaseVoltage(mrid=pb.mrid(), nominal_voltage=pb.nominalVoltage)
identified_object_to_cim(pb.io, cim, network_service)
return cim if network_service.add(cim) else None
def conducting_equipment_to_cim(pb: PBConductingEquipment, cim: ConductingEquipment, network_service: NetworkService):
network_service.resolve_or_defer_reference(resolver.ce_base_voltage(cim), pb.baseVoltageMRID)
for mrid in pb.terminalMRIDs:
network_service.resolve_or_defer_reference(resolver.ce_terminals(cim), mrid)
equipment_to_cim(pb.eq, cim, network_service)
def connectivity_node_to_cim(pb: PBConnectivityNode, network_service: NetworkService) -> Optional[ConnectivityNode]:
cim = ConnectivityNode(mrid=pb.mrid())
identified_object_to_cim(pb.io, cim, network_service)
return cim if network_service.add(cim) else None
def connectivity_node_container_to_cim(pb: PBConnectivityNodeContainer, cim: ConnectivityNodeContainer, network_service: NetworkService):
power_system_resource_to_cim(pb.psr, cim, network_service)
def equipment_to_cim(pb: PBEquipment, cim: Equipment, network_service: NetworkService):
cim.in_service = pb.inService
cim.normally_in_service = pb.normallyInService
for mrid in pb.equipmentContainerMRIDs:
network_service.resolve_or_defer_reference(resolver.containers(cim), mrid)
for mrid in pb.usagePointMRIDs:
network_service.resolve_or_defer_reference(resolver.eq_usage_points(cim), mrid)
for mrid in pb.operationalRestrictionMRIDs:
network_service.resolve_or_defer_reference(resolver.operational_restrictions(cim), mrid)
for mrid in pb.currentFeederMRIDs:
network_service.resolve_or_defer_reference(resolver.current_feeders(cim), mrid)
power_system_resource_to_cim(pb.psr, cim, network_service)
def equipment_container_to_cim(pb: PBEquipmentContainer, cim: EquipmentContainer, network_service: NetworkService):
connectivity_node_container_to_cim(pb.cnc, cim, network_service)
def feeder_to_cim(pb: PBFeeder, network_service: NetworkService) -> Optional[Feeder]:
cim = Feeder(mrid=pb.mrid())
network_service.resolve_or_defer_reference(resolver.normal_head_terminal(cim), pb.normalHeadTerminalMRID)
network_service.resolve_or_defer_reference(resolver.normal_energizing_substation(cim), pb.normalEnergizingSubstationMRID)
equipment_container_to_cim(pb.ec, cim, network_service)
return cim if network_service.add(cim) else None
def geographical_region_to_cim(pb: PBGeographicalRegion, network_service: NetworkService) -> Optional[GeographicalRegion]:
cim = GeographicalRegion(mrid=pb.mrid())
for mrid in pb.subGeographicalRegionMRIDs:
network_service.resolve_or_defer_reference(resolver.sub_geographical_regions(cim), mrid)
identified_object_to_cim(pb.io, cim, network_service)
return cim if network_service.add(cim) else None
def power_system_resource_to_cim(pb: PBPowerSystemResource, cim: PowerSystemResource, network_service: NetworkService):
network_service.resolve_or_defer_reference(resolver.psr_location(cim), pb.locationMRID)
identified_object_to_cim(pb.io, cim, network_service)
def site_to_cim(pb: PBSite, network_service: NetworkService) -> Optional[Site]:
# noinspection PyArgumentList
cim = Site(mrid=pb.mrid())
equipment_container_to_cim(pb.ec, cim, network_service)
return cim if network_service.add(cim) else None
def sub_geographical_region_to_cim(pb: PBSubGeographicalRegion, network_service: NetworkService) -> Optional[SubGeographicalRegion]:
cim = SubGeographicalRegion(mrid=pb.mrid())
network_service.resolve_or_defer_reference(resolver.geographical_region(cim), pb.geographicalRegionMRID)
for mrid in pb.substationMRIDs:
network_service.resolve_or_defer_reference(resolver.substations(cim), mrid)
identified_object_to_cim(pb.io, cim, network_service)
return cim if network_service.add(cim) else None
def substation_to_cim(pb: PBSubstation, network_service: NetworkService) -> Optional[Substation]:
cim = Substation(mrid=pb.mrid())
network_service.resolve_or_defer_reference(resolver.sub_geographical_region(cim), pb.subGeographicalRegionMRID)
for mrid in pb.normalEnergizedFeederMRIDs:
network_service.resolve_or_defer_reference(resolver.normal_energizing_feeders(cim), mrid)
for mrid in pb.loopMRIDs:
network_service.resolve_or_defer_reference(resolver.loops(cim), mrid)
for mrid in pb.normalEnergizedLoopMRIDs:
network_service.resolve_or_defer_reference(resolver.normal_energized_loops(cim), mrid)
for mrid in pb.circuitMRIDs:
network_service.resolve_or_defer_reference(resolver.circuits(cim), mrid)
equipment_container_to_cim(pb.ec, cim, network_service)
return cim if network_service.add(cim) else None
def terminal_to_cim(pb: PBTerminal, network_service: NetworkService) -> Optional[Terminal]:
# noinspection PyArgumentList
cim = Terminal(
mrid=pb.mrid(),
phases=phase_code_by_id(pb.phases),
sequence_number=pb.sequenceNumber,
normal_feeder_direction=FeederDirection(pb.normalFeederDirection),
current_feeder_direction=FeederDirection(pb.currentFeederDirection),
traced_phases=TracedPhases(pb.tracedPhases),
)
network_service.resolve_or_defer_reference(resolver.conducting_equipment(cim), pb.conductingEquipmentMRID)
network_service.resolve_or_defer_reference(resolver.connectivity_node(cim), pb.connectivityNodeMRID)
ac_dc_terminal_to_cim(pb.ad, cim, network_service)
return cim if network_service.add(cim) else None
PBAcDcTerminal.to_cim = ac_dc_terminal_to_cim
PBBaseVoltage.to_cim = base_voltage_to_cim
PBConductingEquipment.to_cim = conducting_equipment_to_cim
PBConnectivityNode.to_cim = connectivity_node_to_cim
PBConnectivityNodeContainer.to_cim = connectivity_node_container_to_cim
PBEquipment.to_cim = equipment_to_cim
PBEquipmentContainer.to_cim = equipment_container_to_cim
PBFeeder.to_cim = feeder_to_cim
PBGeographicalRegion.to_cim = geographical_region_to_cim
PBPowerSystemResource.to_cim = power_system_resource_to_cim
PBSite.to_cim = site_to_cim
PBSubGeographicalRegion.to_cim = sub_geographical_region_to_cim
PBSubstation.to_cim = substation_to_cim
PBTerminal.to_cim = terminal_to_cim
#############################
# IEC61970 BASE EQUIVALENTS #
#############################
def equivalent_branch_to_cim(pb: PBEquivalentBranch, network_service: NetworkService) -> Optional[EquivalentBranch]:
cim = EquivalentBranch(
mrid=pb.mrid(),
negative_r12=float_or_none(pb.negativeR12),
negative_r21=float_or_none(pb.negativeR21),
negative_x12=float_or_none(pb.negativeX12),
negative_x21=float_or_none(pb.negativeX21),
positive_r12=float_or_none(pb.positiveR12),
positive_r21=float_or_none(pb.positiveR21),
positive_x12=float_or_none(pb.positiveX12),
positive_x21=float_or_none(pb.positiveX21),
r=float_or_none(pb.r),
r21=float_or_none(pb.r21),
x=float_or_none(pb.x),
x21=float_or_none(pb.x21),
zero_r12=float_or_none(pb.zeroR12),
zero_r21=float_or_none(pb.zeroR21),
zero_x12=float_or_none(pb.zeroX12),
zero_x21=float_or_none(pb.zeroX21),
)
equivalent_equipment_to_cim(pb.ee, cim, network_service)
return cim if network_service.add(cim) else None
def equivalent_equipment_to_cim(pb: PBEquivalentEquipment, cim: EquivalentEquipment, network_service: NetworkService):
conducting_equipment_to_cim(pb.ce, cim, network_service)
PBEquivalentEquipment.to_cim = equivalent_equipment_to_cim
PBEquivalentBranch.to_cim = equivalent_branch_to_cim
######################
# IEC61970 BASE MEAS #
######################
def accumulator_to_cim(pb: PBAccumulator, network_service: NetworkService) -> Optional[Accumulator]:
# noinspection PyArgumentList
cim = Accumulator(mrid=pb.mrid())
measurement_to_cim(pb.measurement, cim, network_service)
return cim if network_service.add(cim) else None
def analog_to_cim(pb: PBAnalog, network_service: NetworkService) -> Optional[Analog]:
# noinspection PyArgumentList
cim = Analog(mrid=pb.mrid(), positive_flow_in=pb.positiveFlowIn)
measurement_to_cim(pb.measurement, cim, network_service)
return cim if network_service.add(cim) else None
def control_to_cim(pb: PBControl, network_service: NetworkService) -> Optional[Control]:
# noinspection PyArgumentList
cim = Control(
mrid=pb.mrid(),
power_system_resource_mrid=pb.powerSystemResourceMRID if pb.powerSystemResourceMRID else None
)
network_service.resolve_or_defer_reference(resolver.remote_control(cim), pb.remoteControlMRID)
io_point_to_cim(pb.ip, cim, network_service)
return cim if network_service.add(cim) else None
def discrete_to_cim(pb: PBDiscrete, network_service: NetworkService) -> Optional[Discrete]:
# noinspection PyArgumentList
cim = Discrete(mrid=pb.mrid())
measurement_to_cim(pb.measurement, cim, network_service)
return cim if network_service.add(cim) else None
def io_point_to_cim(pb: PBIoPoint, cim: IoPoint, service: NetworkService):
identified_object_to_cim(pb.io, cim, service)
def measurement_to_cim(pb: PBMeasurement, cim: Measurement, service: NetworkService):
cim.power_system_resource_mrid = str_or_none(pb.powerSystemResourceMRID)
cim.terminal_mrid = str_or_none(pb.terminalMRID)
cim.phases = phase_code_by_id(pb.phases)
cim.unit_symbol = unit_symbol_from_id(pb.unitSymbol)
service.resolve_or_defer_reference(resolver.remote_source(cim), pb.remoteSourceMRID)
identified_object_to_cim(pb.io, cim, service)
PBAccumulator.to_cim = accumulator_to_cim
PBAnalog.to_cim = analog_to_cim
PBControl.to_cim = control_to_cim
PBDiscrete.to_cim = discrete_to_cim
PBIoPoint.to_cim = io_point_to_cim
PBMeasurement.to_cim = measurement_to_cim
#######################
# IEC61970 BASE SCADA #
#######################
def remote_control_to_cim(pb: PBRemoteControl, network_service: NetworkService) -> Optional[RemoteControl]:
# noinspection PyArgumentList
cim = RemoteControl(mrid=pb.mrid())
network_service.resolve_or_defer_reference(resolver.control(cim), pb.controlMRID)
remote_point_to_cim(pb.rp, cim, network_service)
return cim if network_service.add(cim) else None
def remote_point_to_cim(pb: PBRemotePoint, cim: RemotePoint, service: NetworkService):
identified_object_to_cim(pb.io, cim, service)
def remote_source_to_cim(pb: PBRemoteSource, network_service: NetworkService) -> Optional[RemoteSource]:
# noinspection PyArgumentList
cim = RemoteSource(mrid=pb.mrid())
network_service.resolve_or_defer_reference(resolver.measurement(cim), pb.measurementMRID)
remote_point_to_cim(pb.rp, cim, network_service)
return cim if network_service.add(cim) else None
PBRemoteControl.to_cim = remote_control_to_cim
PBRemotePoint.to_cim = remote_point_to_cim
PBRemoteSource.to_cim = remote_source_to_cim
#############################################
# IEC61970 BASE WIRES GENERATION PRODUCTION #
#############################################
def battery_unit_to_cim(pb: PBBatteryUnit, network_service: NetworkService) -> Optional[BatteryUnit]:
cim = BatteryUnit(
mrid=pb.mrid(),
battery_state=BatteryStateKind(pb.batteryState),
rated_e=long_or_none(pb.ratedE),
stored_e=long_or_none(pb.storedE),
)
power_electronics_unit_to_cim(pb.peu, cim, network_service)
return cim if network_service.add(cim) else None
def photo_voltaic_unit_to_cim(pb: PBPhotoVoltaicUnit, network_service: NetworkService) -> Optional[PhotoVoltaicUnit]:
cim = PhotoVoltaicUnit(mrid=pb.mrid())
power_electronics_unit_to_cim(pb.peu, cim, network_service)
return cim if network_service.add(cim) else None
def power_electronics_unit_to_cim(pb: PBPowerElectronicsUnit, cim: PowerElectronicsUnit, network_service: NetworkService):
cim.max_p = int_or_none(pb.maxP)
cim.min_p = int_or_none(pb.minP)
network_service.resolve_or_defer_reference(resolver.unit_power_electronics_connection(cim), pb.powerElectronicsConnectionMRID)
equipment_to_cim(pb.eq, cim, network_service)
def power_electronics_wind_unit_to_cim(pb: PBPowerElectronicsWindUnit, network_service: NetworkService) -> Optional[PowerElectronicsWindUnit]:
cim = PowerElectronicsWindUnit(mrid=pb.mrid())
power_electronics_unit_to_cim(pb.peu, cim, network_service)
return cim if network_service.add(cim) else None
PBBatteryUnit.to_cim = battery_unit_to_cim
PBPhotoVoltaicUnit.to_cim = photo_voltaic_unit_to_cim
PBPowerElectronicsUnit.to_cim = power_electronics_unit_to_cim
PBPowerElectronicsWindUnit.to_cim = power_electronics_wind_unit_to_cim
#######################
# IEC61970 BASE WIRES #
#######################
def ac_line_segment_to_cim(pb: PBAcLineSegment, network_service: NetworkService) -> Optional[AcLineSegment]:
cim = AcLineSegment(mrid=pb.mrid())
network_service.resolve_or_defer_reference(resolver.per_length_sequence_impedance(cim), pb.perLengthSequenceImpedanceMRID)
conductor_to_cim(pb.cd, cim, network_service)
return cim if network_service.add(cim) else None
def breaker_to_cim(pb: PBBreaker, network_service: NetworkService) -> Optional[Breaker]:
cim = Breaker(mrid=pb.mrid())
protected_switch_to_cim(pb.sw, cim, network_service)
return cim if network_service.add(cim) else None
def conductor_to_cim(pb: PBConductor, cim: Conductor, network_service: NetworkService):
cim.length = float_or_none(pb.length)
network_service.resolve_or_defer_reference(resolver.asset_info(cim), pb.asset_info_mrid())
conducting_equipment_to_cim(pb.ce, cim, network_service)
def connector_to_cim(pb: PBConnector, cim: Connector, network_service: NetworkService):
conducting_equipment_to_cim(pb.ce, cim, network_service)
def disconnector_to_cim(pb: PBDisconnector, network_service: NetworkService) -> Optional[Disconnector]:
cim = Disconnector(mrid=pb.mrid())
switch_to_cim(pb.sw, cim, network_service)
return cim if network_service.add(cim) else None
def energy_connection_to_cim(pb: PBEnergyConnection, cim: EnergyConnection, network_service: NetworkService):
conducting_equipment_to_cim(pb.ce, cim, network_service)
def energy_consumer_to_cim(pb: PBEnergyConsumer, network_service: NetworkService) -> Optional[EnergyConsumer]:
cim = EnergyConsumer(
mrid=pb.mrid(),
customer_count=int_or_none(pb.customerCount),
grounded=pb.grounded,
phase_connection=PhaseShuntConnectionKind(pb.phaseConnection),
p=float_or_none(pb.p),
p_fixed=float_or_none(pb.pFixed),
q=float_or_none(pb.q),
q_fixed=float_or_none(pb.qFixed)
)
for mrid in pb.energyConsumerPhasesMRIDs:
network_service.resolve_or_defer_reference(resolver.ec_phases(cim), mrid)
energy_connection_to_cim(pb.ec, cim, network_service)
return cim if network_service.add(cim) else None
def energy_consumer_phase_to_cim(pb: PBEnergyConsumerPhase, network_service: NetworkService) -> Optional[EnergyConsumerPhase]:
cim = EnergyConsumerPhase(
mrid=pb.mrid(),
phase=single_phase_kind_by_id(pb.phase),
p=float_or_none(pb.p),
p_fixed=float_or_none(pb.pFixed),
q=float_or_none(pb.q),
q_fixed=float_or_none(pb.qFixed)
)
network_service.resolve_or_defer_reference(resolver.energy_consumer(cim), pb.energyConsumerMRID)
power_system_resource_to_cim(pb.psr, cim, network_service)
return cim if network_service.add(cim) else None
def energy_source_to_cim(pb: PBEnergySource, network_service: NetworkService) -> Optional[EnergySource]:
cim = EnergySource(
mrid=pb.mrid(),
active_power=float_or_none(pb.activePower),
reactive_power=float_or_none(pb.reactivePower),
voltage_angle=float_or_none(pb.voltageAngle),
voltage_magnitude=float_or_none(pb.voltageMagnitude),
r=float_or_none(pb.r),
x=float_or_none(pb.x),
p_max=float_or_none(pb.pMax),
p_min=float_or_none(pb.pMin),
r0=float_or_none(pb.r0),
rn=float_or_none(pb.rn),
x0=float_or_none(pb.x0),
xn=float_or_none(pb.xn),
is_external_grid=pb.isExternalGrid,
r_min=float_or_none(pb.rMin),
rn_min=float_or_none(pb.rnMin),
r0_min=float_or_none(pb.r0Min),
x_min=float_or_none(pb.xMin),
xn_min=float_or_none(pb.xnMin),
x0_min=float_or_none(pb.x0Min),
r_max=float_or_none(pb.rMax),
rn_max=float_or_none(pb.rnMax),
r0_max=float_or_none(pb.r0Max),
x_max=float_or_none(pb.xMax),
xn_max=float_or_none(pb.xnMax),
x0_max=float_or_none(pb.x0Max)
)
for mrid in pb.energySourcePhasesMRIDs:
network_service.resolve_or_defer_reference(resolver.es_phases(cim), mrid)
energy_connection_to_cim(pb.ec, cim, network_service)
return cim if network_service.add(cim) else None
def energy_source_phase_to_cim(pb: PBEnergySourcePhase, network_service: NetworkService) -> Optional[EnergySourcePhase]:
cim = EnergySourcePhase(mrid=pb.mrid(), phase=single_phase_kind_by_id(pb.phase))
network_service.resolve_or_defer_reference(resolver.energy_source(cim), pb.energySourceMRID)
power_system_resource_to_cim(pb.psr, cim, network_service)
return cim if network_service.add(cim) else None
def fuse_to_cim(pb: PBFuse, network_service: NetworkService) -> Optional[Fuse]:
cim = Fuse(mrid=pb.mrid())
switch_to_cim(pb.sw, cim, network_service)
return cim if network_service.add(cim) else None
def jumper_to_cim(pb: PBJumper, network_service: NetworkService) -> Optional[Jumper]:
cim = Jumper(mrid=pb.mrid())
switch_to_cim(pb.sw, cim, network_service)
return cim if network_service.add(cim) else None
def junction_to_cim(pb: PBJunction, network_service: NetworkService) -> Optional[Junction]:
cim = Junction(mrid=pb.mrid())
connector_to_cim(pb.cn, cim, network_service)
return cim if network_service.add(cim) else None
def busbar_section_to_cim(pb: PBBusbarSection, network_service: NetworkService) -> Optional[BusbarSection]:
cim = BusbarSection(mrid=pb.mrid())
connector_to_cim(pb.cn, cim, network_service)
return cim if network_service.add(cim) else None
def line_to_cim(pb: PBLine, cim: Line, network_service: NetworkService):
equipment_container_to_cim(pb.ec, cim, network_service)
def linear_shunt_compensator_to_cim(pb: PBLinearShuntCompensator, network_service: NetworkService) -> Optional[LinearShuntCompensator]:
cim = LinearShuntCompensator(
mrid=pb.mrid(),
b0_per_section=float_or_none(pb.b0PerSection),
b_per_section=float_or_none(pb.bPerSection),
g0_per_section=float_or_none(pb.g0PerSection),
g_per_section=float_or_none(pb.gPerSection)
)
shunt_compensator_to_cim(pb.sc, cim, network_service)
return cim if network_service.add(cim) else None
def load_break_switch_to_cim(pb: PBLoadBreakSwitch, network_service: NetworkService) -> Optional[LoadBreakSwitch]:
cim = LoadBreakSwitch(mrid=pb.mrid())
protected_switch_to_cim(pb.ps, cim, network_service)
return cim if network_service.add(cim) else None
def per_length_line_parameter_to_cim(pb: PBPerLengthLineParameter, cim: PerLengthLineParameter, network_service: NetworkService):
identified_object_to_cim(pb.io, cim, network_service)
def per_length_impedance_to_cim(pb: PBPerLengthImpedance, cim: PerLengthImpedance, network_service: NetworkService):
per_length_line_parameter_to_cim(pb.lp, cim, network_service)
def per_length_sequence_impedance_to_cim(pb: PBPerLengthSequenceImpedance, network_service: NetworkService) -> Optional[PerLengthSequenceImpedance]:
# noinspection PyArgumentList
cim = PerLengthSequenceImpedance(
mrid=pb.mrid(),
r=float_or_none(pb.r),
x=float_or_none(pb.x),
r0=float_or_none(pb.r0),
x0=float_or_none(pb.x0),
bch=float_or_none(pb.bch),
gch=float_or_none(pb.gch),
b0ch=float_or_none(pb.b0ch),
g0ch=float_or_none(pb.g0ch)
)
per_length_impedance_to_cim(pb.pli, cim, network_service)
return cim if network_service.add(cim) else None
def power_electronics_connection_to_cim(pb: PBPowerElectronicsConnection, network_service: NetworkService) -> Optional[PowerElectronicsConnection]:
cim = PowerElectronicsConnection(
mrid=pb.mrid(),
max_i_fault=int_or_none(pb.maxIFault),
p=float_or_none(pb.p),
q=float_or_none(pb.q),
max_q=float_or_none(pb.maxQ),
min_q=float_or_none(pb.minQ),
rated_s=int_or_none(pb.ratedS),
rated_u=int_or_none(pb.ratedU)
)
for mrid in pb.powerElectronicsUnitMRIDs:
network_service.resolve_or_defer_reference(resolver.power_electronics_unit(cim), mrid)
for mrid in pb.powerElectronicsConnectionPhaseMRIDs:
network_service.resolve_or_defer_reference(resolver.power_electronics_connection_phase(cim), mrid)
regulating_cond_eq_to_cim(pb.rce, cim, network_service)
return cim if network_service.add(cim) else None
def power_electronics_connection_phase_to_cim(pb: PBPowerElectronicsConnection, network_service: NetworkService) -> Optional[PowerElectronicsConnectionPhase]:
# noinspection PyArgumentList
cim = PowerElectronicsConnectionPhase(
mrid=pb.mrid(),
p=float_or_none(pb.p),
q=float_or_none(pb.q),
phase=single_phase_kind_by_id(pb.phase)
)
network_service.resolve_or_defer_reference(resolver.phase_power_electronics_connection(cim), pb.powerElectronicsConnectionMRID)
power_system_resource_to_cim(pb.psr, cim, network_service)
return cim if network_service.add(cim) else None
def power_transformer_to_cim(pb: PBPowerTransformer, network_service: NetworkService) -> Optional[PowerTransformer]:
cim = PowerTransformer(
mrid=pb.mrid(),
vector_group=VectorGroup(pb.vectorGroup),
transformer_utilisation=float_or_none(pb.transformerUtilisation),
construction_kind=TransformerConstructionKind(pb.constructionKind),
function=TransformerFunctionKind(pb.function)
)
for mrid in pb.powerTransformerEndMRIDs:
network_service.resolve_or_defer_reference(resolver.ends(cim), mrid)
network_service.resolve_or_defer_reference(resolver.power_transformer_info(cim), pb.asset_info_mrid())
conducting_equipment_to_cim(pb.ce, cim, network_service)
return cim if network_service.add(cim) else None
def power_transformer_end_to_cim(pb: PBPowerTransformerEnd, network_service: NetworkService) -> Optional[PowerTransformerEnd]:
cim = PowerTransformerEnd(
mrid=pb.mrid(),
rated_s=int_or_none(pb.ratedS),
rated_u=int_or_none(pb.ratedU),
r=float_or_none(pb.r),
r0=float_or_none(pb.r0),
x=float_or_none(pb.x),
x0=float_or_none(pb.x0),
b=float_or_none(pb.b),
b0=float_or_none(pb.b0),
g=float_or_none(pb.g),
g0=float_or_none(pb.g0),
connection_kind=WindingConnection(pb.connectionKind),
phase_angle_clock=int_or_none(pb.phaseAngleClock)
)
network_service.resolve_or_defer_reference(resolver.power_transformer(cim), pb.powerTransformerMRID)
transformer_end_to_cim(pb.te, cim, network_service)
return cim if network_service.add(cim) else None
def transformer_star_impedance_to_cim(pb: PBTransformerStarImpedance, network_service: NetworkService) -> Optional[TransformerStarImpedance]:
# noinspection PyArgumentList
cim = TransformerStarImpedance(mrid=pb.mrid(), r=pb.r, r0=pb.r0, x=pb.x, x0=pb.x0)
network_service.resolve_or_defer_reference(resolver.star_impedance_transformer_end_info(cim), pb.transformerEndInfoMRID)
identified_object_to_cim(pb.io, cim, network_service)
return cim if network_service.add(cim) else None
def protected_switch_to_cim(pb: PBProtectedSwitch, cim: ProtectedSwitch, network_service: NetworkService):
switch_to_cim(pb.sw, cim, network_service)
def ratio_tap_changer_to_cim(pb: PBRatioTapChanger, network_service: NetworkService) -> Optional[RatioTapChanger]:
cim = RatioTapChanger(
mrid=pb.mrid(),
step_voltage_increment=float_or_none(pb.stepVoltageIncrement)
)
network_service.resolve_or_defer_reference(resolver.transformer_end(cim), pb.transformerEndMRID)
tap_changer_to_cim(pb.tc, cim, network_service)
return cim if network_service.add(cim) else None
def recloser_to_cim(pb: PBRecloser, network_service: NetworkService) -> Optional[Recloser]:
cim = Recloser(mrid=pb.mrid())
protected_switch_to_cim(pb.sw, cim, network_service)
return cim if network_service.add(cim) else None
def regulating_cond_eq_to_cim(pb: PBRegulatingCondEq, cim: RegulatingCondEq, network_service: NetworkService):
cim.control_enabled = pb.controlEnabled
energy_connection_to_cim(pb.ec, cim, network_service)
def shunt_compensator_to_cim(pb: PBShuntCompensator, cim: ShuntCompensator, network_service: NetworkService):
network_service.resolve_or_defer_reference(resolver.shunt_compensator_info(cim), pb.asset_info_mrid())
cim.sections = float_or_none(pb.sections)
cim.grounded = pb.grounded
cim.nom_u = int_or_none(pb.nomU)
cim.phase_connection = PhaseShuntConnectionKind(pb.phaseConnection)
regulating_cond_eq_to_cim(pb.rce, cim, network_service)
def switch_to_cim(pb: PBSwitch, cim: Switch, network_service: NetworkService):
cim.set_normally_open(pb.normalOpen)
cim.set_open(pb.open)
conducting_equipment_to_cim(pb.ce, cim, network_service)
def tap_changer_to_cim(pb: PBTapChanger, cim: TapChanger, network_service: NetworkService):
cim.high_step = int_or_none(pb.highStep)
cim.step = float_or_none(pb.step)
cim.neutral_step = int_or_none(pb.neutralStep)
cim.normal_step = int_or_none(pb.normalStep)
cim.low_step = int_or_none(pb.lowStep)
cim.neutral_u = int_or_none(pb.neutralU)
cim.control_enabled = pb.controlEnabled
power_system_resource_to_cim(pb.psr, cim, network_service)
def transformer_end_to_cim(pb: PBTransformerEnd, cim: TransformerEnd, network_service: NetworkService):
cim.end_number = pb.endNumber
cim.grounded = pb.grounded
cim.r_ground = float_or_none(pb.rGround)
cim.x_ground = float_or_none(pb.xGround)
network_service.resolve_or_defer_reference(resolver.te_terminal(cim), pb.terminalMRID)
network_service.resolve_or_defer_reference(resolver.te_base_voltage(cim), pb.baseVoltageMRID)
network_service.resolve_or_defer_reference(resolver.ratio_tap_changer(cim), pb.ratioTapChangerMRID)
network_service.resolve_or_defer_reference(resolver.transformer_end_transformer_star_impedance(cim), pb.starImpedanceMRID)
identified_object_to_cim(pb.io, cim, network_service)
PBAcLineSegment.to_cim = ac_line_segment_to_cim
PBBreaker.to_cim = breaker_to_cim
PBConductor.to_cim = conductor_to_cim
PBConnector.to_cim = connector_to_cim
PBDisconnector.to_cim = disconnector_to_cim
PBEnergyConnection.to_cim = energy_connection_to_cim
PBEnergyConsumer.to_cim = energy_consumer_to_cim
PBEnergyConsumerPhase.to_cim = energy_consumer_phase_to_cim
PBEnergySource.to_cim = energy_source_to_cim
PBEnergySourcePhase.to_cim = energy_source_phase_to_cim
PBFuse.to_cim = fuse_to_cim
PBJumper.to_cim = jumper_to_cim
PBJunction.to_cim = junction_to_cim
PBBusbarSection.to_cim = busbar_section_to_cim
PBLine.to_cim = line_to_cim
PBLinearShuntCompensator.to_cim = linear_shunt_compensator_to_cim
PBLoadBreakSwitch.to_cim = load_break_switch_to_cim
PBPerLengthSequenceImpedance.to_cim = per_length_sequence_impedance_to_cim
PBPerLengthLineParameter.to_cim = per_length_line_parameter_to_cim
PBPerLengthImpedance = per_length_impedance_to_cim
PBPowerElectronicsConnection.to_cim = power_electronics_connection_to_cim
PBPowerElectronicsConnectionPhase.to_cim = power_electronics_connection_phase_to_cim
PBPowerTransformer.to_cim = power_transformer_to_cim
PBPowerTransformerEnd.to_cim = power_transformer_end_to_cim
PBTransformerStarImpedance.to_cim = transformer_star_impedance_to_cim
PBProtectedSwitch.to_cim = protected_switch_to_cim
PBRatioTapChanger.to_cim = ratio_tap_changer_to_cim
PBRecloser.to_cim = recloser_to_cim
PBRegulatingCondEq.to_cim = regulating_cond_eq_to_cim
PBShuntCompensator.to_cim = shunt_compensator_to_cim
PBSwitch.to_cim = switch_to_cim
PBTapChanger.to_cim = tap_changer_to_cim
PBTransformerEnd.to_cim = transformer_end_to_cim
###############################
# IEC61970 INFIEC61970 FEEDER #
###############################
def circuit_to_cim(pb: PBCircuit, network_service: NetworkService) -> Optional[Circuit]:
cim = Circuit(mrid=pb.mrid())
network_service.resolve_or_defer_reference(resolver.loop(cim), pb.loopMRID)
for mrid in pb.endTerminalMRIDs:
network_service.resolve_or_defer_reference(resolver.end_terminal(cim), mrid)
for mrid in pb.endSubstationMRIDs:
network_service.resolve_or_defer_reference(resolver.end_substation(cim), mrid)
line_to_cim(pb.l, cim, network_service)
return cim if network_service.add(cim) else None
def loop_to_cim(pb: PBLoop, network_service: NetworkService) -> Optional[Loop]:
cim = Loop(mrid=pb.mrid())
for mrid in pb.circuitMRIDs:
network_service.resolve_or_defer_reference(resolver.loop_circuits(cim), mrid)
for mrid in pb.substationMRIDs:
network_service.resolve_or_defer_reference(resolver.loop_substations(cim), mrid)
for mrid in pb.normalEnergizingSubstationMRIDs:
network_service.resolve_or_defer_reference(resolver.loop_energizing_substations(cim), mrid)
identified_object_to_cim(pb.io, cim, network_service)
return cim if network_service.add(cim) else None
PBCircuit.to_cim = circuit_to_cim
PBLoop.to_cim = loop_to_cim | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/translator/network_proto2cim.py | network_proto2cim.py |
from zepben.protobuf.cim.iec61968.assetinfo.CableInfo_pb2 import CableInfo
from zepben.protobuf.cim.iec61968.assetinfo.NoLoadTest_pb2 import NoLoadTest
from zepben.protobuf.cim.iec61968.assetinfo.OpenCircuitTest_pb2 import OpenCircuitTest
from zepben.protobuf.cim.iec61968.assetinfo.OverheadWireInfo_pb2 import OverheadWireInfo
from zepben.protobuf.cim.iec61968.assetinfo.PowerTransformerInfo_pb2 import PowerTransformerInfo
from zepben.protobuf.cim.iec61968.assetinfo.ShortCircuitTest_pb2 import ShortCircuitTest
from zepben.protobuf.cim.iec61968.assetinfo.ShuntCompensatorInfo_pb2 import ShuntCompensatorInfo
from zepben.protobuf.cim.iec61968.assetinfo.TransformerEndInfo_pb2 import TransformerEndInfo
from zepben.protobuf.cim.iec61968.assetinfo.TransformerTankInfo_pb2 import TransformerTankInfo
from zepben.protobuf.cim.iec61968.assetinfo.TransformerTest_pb2 import TransformerTest
from zepben.protobuf.cim.iec61968.assetinfo.WireInfo_pb2 import WireInfo
from zepben.protobuf.cim.iec61968.assets.AssetContainer_pb2 import AssetContainer
from zepben.protobuf.cim.iec61968.assets.AssetInfo_pb2 import AssetInfo
from zepben.protobuf.cim.iec61968.assets.AssetOrganisationRole_pb2 import AssetOrganisationRole
from zepben.protobuf.cim.iec61968.assets.AssetOwner_pb2 import AssetOwner
from zepben.protobuf.cim.iec61968.assets.Asset_pb2 import Asset
from zepben.protobuf.cim.iec61968.assets.Pole_pb2 import Pole
from zepben.protobuf.cim.iec61968.assets.Streetlight_pb2 import Streetlight
from zepben.protobuf.cim.iec61968.assets.Structure_pb2 import Structure
from zepben.protobuf.cim.iec61968.common.Location_pb2 import Location
from zepben.protobuf.cim.iec61968.metering.EndDevice_pb2 import EndDevice
from zepben.protobuf.cim.iec61968.metering.Meter_pb2 import Meter
from zepben.protobuf.cim.iec61968.metering.UsagePoint_pb2 import UsagePoint
from zepben.protobuf.cim.iec61968.operations.OperationalRestriction_pb2 import OperationalRestriction
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.AuxiliaryEquipment_pb2 import AuxiliaryEquipment
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.FaultIndicator_pb2 import FaultIndicator
from zepben.protobuf.cim.iec61970.base.core.AcDcTerminal_pb2 import AcDcTerminal
from zepben.protobuf.cim.iec61970.base.core.BaseVoltage_pb2 import BaseVoltage
from zepben.protobuf.cim.iec61970.base.core.ConductingEquipment_pb2 import ConductingEquipment
from zepben.protobuf.cim.iec61970.base.core.ConnectivityNodeContainer_pb2 import ConnectivityNodeContainer
from zepben.protobuf.cim.iec61970.base.core.ConnectivityNode_pb2 import ConnectivityNode
from zepben.protobuf.cim.iec61970.base.core.EquipmentContainer_pb2 import EquipmentContainer
from zepben.protobuf.cim.iec61970.base.core.Equipment_pb2 import Equipment
from zepben.protobuf.cim.iec61970.base.core.Feeder_pb2 import Feeder
from zepben.protobuf.cim.iec61970.base.core.GeographicalRegion_pb2 import GeographicalRegion
from zepben.protobuf.cim.iec61970.base.core.IdentifiedObject_pb2 import IdentifiedObject
from zepben.protobuf.cim.iec61970.base.core.PowerSystemResource_pb2 import PowerSystemResource
from zepben.protobuf.cim.iec61970.base.core.Site_pb2 import Site
from zepben.protobuf.cim.iec61970.base.core.SubGeographicalRegion_pb2 import SubGeographicalRegion
from zepben.protobuf.cim.iec61970.base.core.Substation_pb2 import Substation
from zepben.protobuf.cim.iec61970.base.core.Terminal_pb2 import Terminal
from zepben.protobuf.cim.iec61970.base.equivalents.EquivalentBranch_pb2 import EquivalentBranch
from zepben.protobuf.cim.iec61970.base.equivalents.EquivalentEquipment_pb2 import EquivalentEquipment
from zepben.protobuf.cim.iec61970.base.meas.Accumulator_pb2 import Accumulator
from zepben.protobuf.cim.iec61970.base.meas.Analog_pb2 import Analog
from zepben.protobuf.cim.iec61970.base.meas.Control_pb2 import Control
from zepben.protobuf.cim.iec61970.base.meas.Discrete_pb2 import Discrete
from zepben.protobuf.cim.iec61970.base.meas.IoPoint_pb2 import IoPoint
from zepben.protobuf.cim.iec61970.base.meas.Measurement_pb2 import Measurement
from zepben.protobuf.cim.iec61970.base.scada.RemoteControl_pb2 import RemoteControl
from zepben.protobuf.cim.iec61970.base.scada.RemotePoint_pb2 import RemotePoint
from zepben.protobuf.cim.iec61970.base.scada.RemoteSource_pb2 import RemoteSource
from zepben.protobuf.cim.iec61970.base.wires.AcLineSegment_pb2 import AcLineSegment
from zepben.protobuf.cim.iec61970.base.wires.Breaker_pb2 import Breaker
from zepben.protobuf.cim.iec61970.base.wires.BusbarSection_pb2 import BusbarSection
from zepben.protobuf.cim.iec61970.base.wires.Conductor_pb2 import Conductor
from zepben.protobuf.cim.iec61970.base.wires.Connector_pb2 import Connector
from zepben.protobuf.cim.iec61970.base.wires.Disconnector_pb2 import Disconnector
from zepben.protobuf.cim.iec61970.base.wires.EnergyConnection_pb2 import EnergyConnection
from zepben.protobuf.cim.iec61970.base.wires.EnergyConsumerPhase_pb2 import EnergyConsumerPhase
from zepben.protobuf.cim.iec61970.base.wires.EnergyConsumer_pb2 import EnergyConsumer
from zepben.protobuf.cim.iec61970.base.wires.EnergySourcePhase_pb2 import EnergySourcePhase
from zepben.protobuf.cim.iec61970.base.wires.EnergySource_pb2 import EnergySource
from zepben.protobuf.cim.iec61970.base.wires.Fuse_pb2 import Fuse
from zepben.protobuf.cim.iec61970.base.wires.Jumper_pb2 import Jumper
from zepben.protobuf.cim.iec61970.base.wires.Junction_pb2 import Junction
from zepben.protobuf.cim.iec61970.base.wires.Line_pb2 import Line
from zepben.protobuf.cim.iec61970.base.wires.LinearShuntCompensator_pb2 import LinearShuntCompensator
from zepben.protobuf.cim.iec61970.base.wires.LoadBreakSwitch_pb2 import LoadBreakSwitch
from zepben.protobuf.cim.iec61970.base.wires.PerLengthImpedance_pb2 import PerLengthImpedance
from zepben.protobuf.cim.iec61970.base.wires.PerLengthLineParameter_pb2 import PerLengthLineParameter
from zepben.protobuf.cim.iec61970.base.wires.PerLengthSequenceImpedance_pb2 import PerLengthSequenceImpedance
from zepben.protobuf.cim.iec61970.base.wires.PowerElectronicsConnectionPhase_pb2 import PowerElectronicsConnectionPhase
from zepben.protobuf.cim.iec61970.base.wires.PowerElectronicsConnection_pb2 import PowerElectronicsConnection
from zepben.protobuf.cim.iec61970.base.wires.PowerTransformerEnd_pb2 import PowerTransformerEnd
from zepben.protobuf.cim.iec61970.base.wires.PowerTransformer_pb2 import PowerTransformer
from zepben.protobuf.cim.iec61970.base.wires.ProtectedSwitch_pb2 import ProtectedSwitch
from zepben.protobuf.cim.iec61970.base.wires.RatioTapChanger_pb2 import RatioTapChanger
from zepben.protobuf.cim.iec61970.base.wires.Recloser_pb2 import Recloser
from zepben.protobuf.cim.iec61970.base.wires.RegulatingCondEq_pb2 import RegulatingCondEq
from zepben.protobuf.cim.iec61970.base.wires.ShuntCompensator_pb2 import ShuntCompensator
from zepben.protobuf.cim.iec61970.base.wires.Switch_pb2 import Switch
from zepben.protobuf.cim.iec61970.base.wires.TapChanger_pb2 import TapChanger
from zepben.protobuf.cim.iec61970.base.wires.TransformerEnd_pb2 import TransformerEnd
from zepben.protobuf.cim.iec61970.base.wires.TransformerStarImpedance_pb2 import TransformerStarImpedance
from zepben.protobuf.cim.iec61970.base.wires.generation.production.BatteryUnit_pb2 import BatteryUnit
from zepben.protobuf.cim.iec61970.base.wires.generation.production.PhotoVoltaicUnit_pb2 import PhotoVoltaicUnit
from zepben.protobuf.cim.iec61970.base.wires.generation.production.PowerElectronicsUnit_pb2 import PowerElectronicsUnit
from zepben.protobuf.cim.iec61970.base.wires.generation.production.PowerElectronicsWindUnit_pb2 import PowerElectronicsWindUnit
from zepben.protobuf.cim.iec61970.infiec61970.feeder.Circuit_pb2 import Circuit
from zepben.protobuf.cim.iec61970.infiec61970.feeder.Loop_pb2 import Loop
__all__ = []
CableInfo.mrid = lambda self: self.wi.mrid()
NoLoadTest.mrid = lambda self: self.tt.mrid()
OpenCircuitTest.mrid = lambda self: self.tt.mrid()
OverheadWireInfo.mrid = lambda self: self.wi.mrid()
PowerTransformerInfo.mrid = lambda self: self.ai.mrid()
ShortCircuitTest.mrid = lambda self: self.tt.mrid()
ShuntCompensatorInfo.mrid = lambda self: self.ai.mrid()
TransformerEndInfo.mrid = lambda self: self.ai.mrid()
TransformerTankInfo.mrid = lambda self: self.ai.mrid()
TransformerTest.mrid = lambda self: self.io.mrid()
TransformerStarImpedance.mrid = lambda self: self.io.mrid()
WireInfo.mrid = lambda self: self.ai.mrid()
Asset.mrid = lambda self: self.io.mrid()
AssetContainer.mrid = lambda self: self.at.mrid()
AssetInfo.mrid = lambda self: self.io.mrid()
AssetOrganisationRole.mrid = lambda self: getattr(self, "or").mrid()
AssetOwner.mrid = lambda self: self.aor.mrid()
Pole.mrid = lambda self: self.st.mrid()
Streetlight.mrid = lambda self: self.at.mrid()
Structure.mrid = lambda self: self.ac.mrid()
Location.mrid = lambda self: self.io.mrid()
EndDevice.mrid = lambda self: self.ac.mrid()
Meter.mrid = lambda self: self.ed.mrid()
UsagePoint.mrid = lambda self: self.io.mrid()
OperationalRestriction.mrid = lambda self: self.doc.mrid()
AuxiliaryEquipment.mrid = lambda self: self.eq.mrid()
FaultIndicator.mrid = lambda self: self.ae.mrid()
AcDcTerminal.mrid = lambda self: self.io.mrid()
BaseVoltage.mrid = lambda self: self.io.mrid()
ConductingEquipment.mrid = lambda self: self.eq.mrid()
ConnectivityNode.mrid = lambda self: self.io.mrid()
ConnectivityNodeContainer.mrid = lambda self: self.psr.mrid()
Equipment.mrid = lambda self: self.psr.mrid()
EquipmentContainer.mrid = lambda self: self.cnc.mrid()
Feeder.mrid = lambda self: self.ec.mrid()
GeographicalRegion.mrid = lambda self: self.io.mrid()
IdentifiedObject.mrid = lambda self: self.mRID
PowerSystemResource.mrid = lambda self: self.io.mrid()
Site.mrid = lambda self: self.ec.mrid()
SubGeographicalRegion.mrid = lambda self: self.io.mrid()
Substation.mrid = lambda self: self.ec.mrid()
Terminal.mrid = lambda self: self.ad.mrid()
EquivalentBranch.mrid = lambda self: self.ee.mrid()
EquivalentEquipment.mrid = lambda self: self.ce.mrid()
Accumulator.mrid = lambda self: self.measurement.mrid()
Analog.mrid = lambda self: self.measurement.mrid()
Discrete.mrid = lambda self: self.measurement.mrid()
Control.mrid = lambda self: self.ip.mrid()
IoPoint.mrid = lambda self: self.io.mrid()
Measurement.mrid = lambda self: self.io.mrid()
RemoteControl.mrid = lambda self: self.rp.mrid()
RemotePoint.mrid = lambda self: self.io.mrid()
RemoteSource.mrid = lambda self: self.rp.mrid()
BatteryUnit.mrid = lambda self: self.peu.mrid()
PhotoVoltaicUnit.mrid = lambda self: self.peu.mrid()
PowerElectronicsUnit.mrid = lambda self: self.eq.mrid()
PowerElectronicsWindUnit.mrid = lambda self: self.peu.mrid()
AcLineSegment.mrid = lambda self: self.cd.mrid()
Breaker.mrid = lambda self: self.sw.mrid()
BusbarSection.mrid = lambda self: self.cn.mrid()
Conductor.mrid = lambda self: self.ce.mrid()
Connector.mrid = lambda self: self.ce.mrid()
Disconnector.mrid = lambda self: self.sw.mrid()
EnergyConnection.mrid = lambda self: self.ce.mrid()
EnergyConsumer.mrid = lambda self: self.ec.mrid()
EnergyConsumerPhase.mrid = lambda self: self.psr.mrid()
EnergySource.mrid = lambda self: self.ec.mrid()
EnergySourcePhase.mrid = lambda self: self.psr.mrid()
Fuse.mrid = lambda self: self.sw.mrid()
Jumper.mrid = lambda self: self.sw.mrid()
Junction.mrid = lambda self: self.cn.mrid()
Line.mrid = lambda self: self.ec.mrid()
LinearShuntCompensator.mrid = lambda self: self.sc.mrid()
LoadBreakSwitch.mrid = lambda self: self.ps.mrid()
PerLengthImpedance.mrid = lambda self: self.lp.mrid()
PerLengthLineParameter.mrid = lambda self: self.io.mrid()
PerLengthSequenceImpedance.mrid = lambda self: self.pli.mrid()
PowerTransformer.mrid = lambda self: self.ce.mrid()
PowerElectronicsConnection.mrid = lambda self: self.rce.mrid()
PowerElectronicsConnectionPhase.mrid = lambda self: self.psr.mrid()
PowerTransformerEnd.mrid = lambda self: self.te.mrid()
ProtectedSwitch.mrid = lambda self: self.sw.mrid()
RatioTapChanger.mrid = lambda self: self.tc.mrid()
Recloser.mrid = lambda self: self.sw.mrid()
RegulatingCondEq.mrid = lambda self: self.ec.mrid()
ShuntCompensator.mrid = lambda self: self.rce.mrid()
Switch.mrid = lambda self: self.ce.mrid()
TapChanger.mrid = lambda self: self.psr.mrid()
TransformerEnd.mrid = lambda self: self.io.mrid()
Loop.mrid = lambda self: self.io.mrid()
Circuit.mrid = lambda self: self.l.mrid()
PowerSystemResource.name_and_mrid = lambda self: self.io.name_and_mrid()
ConductingEquipment.name_and_mrid = lambda self: self.eq.name_and_mrid()
Equipment.name_and_mrid = lambda self: self.psr.name_and_mrid()
ConnectivityNodeContainer.name_and_mrid = lambda self: self.psr.name_and_mrid()
EquipmentContainer.name_and_mrid = lambda self: self.cnc.name_and_mrid()
Feeder.name_and_mrid = lambda self: self.ec.name_and_mrid()
EnergyConsumerPhase.name_and_mrid = lambda self: self.psr.name_and_mrid()
EnergySourcePhase.name_and_mrid = lambda self: self.psr.name_and_mrid()
PowerTransformerEnd.name_and_mrid = lambda self: self.te.name_and_mrid()
AcDcTerminal.name_and_mrid = lambda self: self.io.name_and_mrid()
TransformerEnd.name_and_mrid = lambda self: self.io.name_and_mrid()
Terminal.name_and_mrid = lambda self: self.ad.name_and_mrid()
PowerTransformerInfo.name_and_mrid = lambda self: self.ce.eq.psr.io.name_and_mrid()
# location_mrid
PowerSystemResource.location_mrid = lambda self: getattr(self, "locationMRID", None)
Equipment.location_mrid = lambda self: self.psr.location_mrid()
AuxiliaryEquipment.location_mrid = lambda self: self.eq.location_mrid()
FaultIndicator.location_mrid = lambda self: self.ae.location_mrid()
ConductingEquipment.location_mrid = lambda self: self.eq.location_mrid()
Conductor.location_mrid = lambda self: self.ce.location_mrid()
Connector.location_mrid = lambda self: self.ce.location_mrid()
EnergyConnection.location_mrid = lambda self: self.ce.location_mrid()
PowerTransformer.location_mrid = lambda self: self.ce.location_mrid()
Switch.location_mrid = lambda self: self.ce.location_mrid()
AcLineSegment.location_mrid = lambda self: self.cd.location_mrid()
Junction.location_mrid = lambda self: self.cn.location_mrid()
EnergyConsumer.location_mrid = lambda self: self.ec.location_mrid()
EnergySource.location_mrid = lambda self: self.ec.location_mrid()
RegulatingCondEq.location_mrid = lambda self: self.ec.location_mrid()
Disconnector.location_mrid = lambda self: self.sw.location_mrid()
Fuse.location_mrid = lambda self: self.sw.location_mrid()
Jumper.location_mrid = lambda self: self.sw.location_mrid()
ProtectedSwitch.location_mrid = lambda self: self.sw.location_mrid()
ShuntCompensator.location_mrid = lambda self: self.rce.location_mrid()
Breaker.location_mrid = lambda self: self.sw.location_mrid()
Recloser.location_mrid = lambda self: self.sw.location_mrid()
LinearShuntCompensator.location_mrid = lambda self: self.sc.location_mrid()
# service_location_mrid
EndDevice.service_location_mrid = lambda self: getattr(self, "serviceLocationMRID", None)
Meter.service_location_mrid = lambda self: self.ed.service_location_mrid()
# usage_point_location_mrid
UsagePoint.usage_point_location_mrid = lambda self: getattr(self, "usagePointLocationMRID", None)
# terminal_mrid
AuxiliaryEquipment.terminal_mrid = lambda self: getattr(self, "terminalMRID", None)
FaultIndicator.terminal_mrid = lambda self: self.ae.terminal_mrid()
# terminal_mrids
ConductingEquipment.terminal_mrids = lambda self: getattr(self, "terminalMRIDs", [])
Conductor.terminal_mrids = lambda self: self.ce.terminal_mrids()
Connector.terminal_mrids = lambda self: self.ce.terminal_mrids()
EnergyConnection.terminal_mrids = lambda self: self.ce.terminal_mrids()
PowerTransformer.terminal_mrids = lambda self: self.ce.terminal_mrids()
Switch.terminal_mrids = lambda self: self.ce.terminal_mrids()
AcLineSegment.terminal_mrids = lambda self: self.cd.terminal_mrids()
Junction.terminal_mrids = lambda self: self.cn.terminal_mrids()
EnergyConsumer.terminal_mrids = lambda self: self.ec.terminal_mrids()
EnergySource.terminal_mrids = lambda self: self.ec.terminal_mrids()
RegulatingCondEq.terminal_mrids = lambda self: self.ec.terminal_mrids()
Disconnector.terminal_mrids = lambda self: self.sw.terminal_mrids()
Fuse.terminal_mrids = lambda self: self.sw.terminal_mrids()
Jumper.terminal_mrids = lambda self: self.sw.terminal_mrids()
ProtectedSwitch.terminal_mrids = lambda self: self.sw.terminal_mrids()
ShuntCompensator.terminal_mrids = lambda self: self.rce.terminal_mrids()
Breaker.terminal_mrids = lambda self: self.sw.terminal_mrids()
Recloser.terminal_mrids = lambda self: self.sw.terminal_mrids()
LinearShuntCompensator.terminal_mrids = lambda self: self.sc.terminal_mrids()
# base_voltage_mrid
ConductingEquipment.base_voltage_mrid = lambda self: getattr(self, "baseVoltageMRID", None)
Conductor.base_voltage_mrid = lambda self: self.ce.base_voltage_mrid()
Connector.base_voltage_mrid = lambda self: self.ce.base_voltage_mrid()
EnergyConnection.base_voltage_mrid = lambda self: self.ce.base_voltage_mrid()
PowerTransformer.base_voltage_mrid = lambda self: self.ce.base_voltage_mrid()
Switch.base_voltage_mrid = lambda self: self.ce.base_voltage_mrid()
AcLineSegment.base_voltage_mrid = lambda self: self.cd.base_voltage_mrid()
Junction.base_voltage_mrid = lambda self: self.cn.base_voltage_mrid()
EnergyConsumer.base_voltage_mrid = lambda self: self.ec.base_voltage_mrid()
EnergySource.base_voltage_mrid = lambda self: self.ec.base_voltage_mrid()
RegulatingCondEq.base_voltage_mrid = lambda self: self.ec.base_voltage_mrid()
Disconnector.base_voltage_mrid = lambda self: self.sw.base_voltage_mrid()
Fuse.base_voltage_mrid = lambda self: self.sw.base_voltage_mrid()
Jumper.base_voltage_mrid = lambda self: self.sw.base_voltage_mrid()
ProtectedSwitch.base_voltage_mrid = lambda self: self.sw.base_voltage_mrid()
ShuntCompensator.base_voltage_mrid = lambda self: self.rce.base_voltage_mrid()
Breaker.base_voltage_mrid = lambda self: self.sw.base_voltage_mrid()
Recloser.base_voltage_mrid = lambda self: self.sw.base_voltage_mrid()
LinearShuntCompensator.base_voltage_mrid = lambda self: self.sc.base_voltage_mrid()
# normal_energizing_substation_mrid
Feeder.normal_energizing_substation_mrid = lambda self: getattr(self, "normalEnergizingSubstationMRID", None)
# per_length_sequence_impedance_mrid
AcLineSegment.per_length_sequence_impedance_mrid = lambda self: getattr(self, "perLengthSequenceImpedanceMRID", None)
# asset_info_mrid
ConductingEquipment.asset_info_mrid = lambda self: self.eq.psr.assetInfoMRID
Conductor.asset_info_mrid = lambda self: self.ce.asset_info_mrid()
PowerTransformer.asset_info_mrid = lambda self: self.ce.asset_info_mrid()
ShuntCompensator.asset_info_mrid = lambda self: self.rce.ec.ce.asset_info_mrid()
# ratio_tap_changer_mrid
TransformerEnd.ratio_tap_changer_mrid = lambda self: getattr(self, "ratioTapChangerMRID", None)
PowerTransformerEnd.ratio_tap_changer_mrid = lambda self: self.te.ratio_tap_changer_mrid() | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/translator/__init__.py | __init__.py |
from __future__ import annotations
import logging
from typing import Optional
from zepben.evolve import Switch, ConductingEquipment, SinglePhaseKind
from zepben.evolve.services.network.tracing.queuing_functions import tracing_logger
from zepben.evolve.services.network.tracing.traversals.traversal import Traversal
from zepben.evolve.services.network.tracing.traversals.queue import LifoQueue
from zepben.evolve.services.network.tracing.phases.phase_status import normal_phases, current_phases
__all__ = ["normally_open", "currently_open", "ignore_open", "phase_log"]
phase_logger = logging.getLogger("phase_logger")
def normally_open(equip: ConductingEquipment, phase: Optional[SinglePhaseKind] = None) -> bool:
"""
Test if a given phase on an equipment is normally open.
`equip` The equipment to test
`phase` The Phase to test. If None tests all phases.
Returns True if the equipment is open (de-energised), False otherwise
"""
if isinstance(equip, Switch):
# noinspection PyUnresolvedReferences
return not equip.normally_in_service or equip.is_normally_open(phase)
else:
return not equip.normally_in_service
def currently_open(equip: ConductingEquipment, phase: Optional[SinglePhaseKind] = None) -> bool:
"""
Test if a given phase on an equipment is open.
`equip` The equipment to test
`phase` The phase to test. If None tests all phases.
Returns True if the equipment is open (de-energised), False otherwise
"""
if isinstance(equip, Switch):
# noinspection PyUnresolvedReferences
return not equip.in_service or equip.is_open(phase)
else:
return not equip.in_service
def ignore_open(_ce: ConductingEquipment, _phase: Optional[SinglePhaseKind] = None) -> bool:
"""
Test that always returns that the phase is closed.
`equip` The equipment to test
`phase` The phase to test. If None tests all cores.
Returns False
"""
return False
async def phase_log(cond_equip):
msg = ""
try:
for e in cond_equip:
msg = await _phase_log_trace(e)
except:
msg = await _phase_log_trace(cond_equip)
phase_logger.debug(msg)
async def _phase_log_trace(cond_equip):
log_msg = []
async def log(e, exc):
equip_msgs = []
for term in e.terminals:
e_msg = f"{e.mrid}-T{term.sequence_number}:"
for n in term.phases.single_phases:
ps_n = normal_phases(term, n)
phase_n_msg = f"n: {ps_n.phase().short_name}:{ps_n.direction().short_name}"
ps_c = current_phases(term, n)
phase_c_msg = f"c: {ps_c.phase().short_name}:{ps_c.direction().short_name}"
e_msg = f"{e_msg} {{core {n}: {phase_n_msg} {phase_c_msg}}}"
equip_msgs.append(e_msg)
log_msg.append(equip_msgs)
trace = Traversal(queue_next=queue_next_equipment, start_item=cond_equip, process_queue=LifoQueue(), step_actions=[log])
await trace.trace()
return "\n".join([", ".join(x) for x in log_msg])
def queue_next_equipment(item, traversal):
connected_equips = item.get_connected_equipment()
tracing_logger.debug(f"Queuing connections [{', '.join(e.mrid for e in connected_equips)}] from {item.mrid}")
return traversal.process_queue.extend(connected_equips) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/util.py | util.py |
from __future__ import annotations
from typing import TYPE_CHECKING, TypeVar
from zepben.evolve import PhaseInferrer
from zepben.evolve.services.network.tracing.connected_equipment_trace import queue_next_connected_equipment_with_open_test
from zepben.evolve.services.network.tracing.connectivity.connectivity_trace import queue_next_connectivity_result_with_open_test
from zepben.evolve.services.network.tracing.feeder.assign_to_feeders import AssignToFeeders
from zepben.evolve.services.network.tracing.feeder.direction_status import normal_direction, current_direction
from zepben.evolve.services.network.tracing.feeder.remove_direction import RemoveDirection
from zepben.evolve.services.network.tracing.feeder.set_direction import SetDirection
from zepben.evolve.services.network.tracing.phases.phase_trace import new_phase_trace, new_downstream_phase_trace, new_upstream_phase_trace
from zepben.evolve.services.network.tracing.phases.remove_phases import RemovePhases
from zepben.evolve.services.network.tracing.phases.set_phases import SetPhases
from zepben.evolve.services.network.tracing.traversals.queue import depth_first, breadth_first
from zepben.evolve.services.network.tracing.traversals.traversal import Traversal
from zepben.evolve.services.network.tracing.tree.downstream_tree import DownstreamTree
from zepben.evolve.services.network.tracing.util import ignore_open, normally_open, currently_open
if TYPE_CHECKING:
from zepben.evolve import ConductingEquipment, ConnectivityResult, PhaseStep
from zepben.evolve.types import QueueNext
T = TypeVar("T")
__all__ = ["create_basic_depth_trace", "create_basic_breadth_trace", "connected_equipment_trace", "connected_equipment_breadth_trace",
"normal_connected_equipment_trace", "current_connected_equipment_trace", "phase_trace", "normal_phase_trace", "current_phase_trace",
"connectivity_trace", "connectivity_breadth_trace", "normal_connectivity_trace", "current_connectivity_trace", "normal_downstream_trace",
"current_downstream_trace", "set_phases", "remove_phases", "set_direction", "remove_direction", "assign_equipment_containers_to_feeders"]
# --- Helper functions that create depth-first/breadth-first traversals ---
def create_basic_depth_trace(queue_next: QueueNext[T]) -> Traversal[T]:
# noinspection PyArgumentList
return Traversal(queue_next, depth_first())
def create_basic_breadth_trace(queue_next: QueueNext[T]) -> Traversal[T]:
# noinspection PyArgumentList
return Traversal(queue_next, breadth_first())
# --- Traversals for conducting equipment ---
def connected_equipment_trace() -> Traversal[ConductingEquipment]:
"""
Creates a new traversal that traces equipment that are connected. This ignores phases, open status etc.
It is purely to trace equipment that are connected in any way.
@return The new traversal instance.
"""
return create_basic_depth_trace(queue_next_connected_equipment_with_open_test(ignore_open))
def connected_equipment_breadth_trace() -> Traversal[ConductingEquipment]:
"""
Creates a new traversal that traces equipment that are connected. This ignores phases, open status etc.
It is purely to trace equipment that are connected in any way.
@return The new traversal instance.
"""
return create_basic_breadth_trace(queue_next_connected_equipment_with_open_test(ignore_open))
def normal_connected_equipment_trace() -> Traversal[ConductingEquipment]:
"""
Creates a new traversal that traces equipment that are connected at normally open points.
@return The new traversal instance.
"""
return create_basic_depth_trace(queue_next_connected_equipment_with_open_test(normally_open))
def current_connected_equipment_trace() -> Traversal[ConductingEquipment]:
"""
Creates a new traversal that traces equipment that are connected at currently open points.
@return The new traversal instance.
"""
return create_basic_depth_trace(queue_next_connected_equipment_with_open_test(currently_open))
# Traversals for connectivity results
def connectivity_trace() -> Traversal[ConnectivityResult]:
"""
Creates a new traversal that traces equipment that are connected. This ignores phases, open status etc.
It is purely to trace equipment that are connected in any way.
@return The new traversal instance.
"""
return create_basic_depth_trace(queue_next_connectivity_result_with_open_test(ignore_open))
def connectivity_breadth_trace() -> Traversal[ConnectivityResult]:
"""
Creates a new traversal that traces equipment that are connected. This ignores phases, open status etc.
It is purely to trace equipment that are connected in any way.
@return The new traversal instance.
"""
return create_basic_breadth_trace(queue_next_connectivity_result_with_open_test(ignore_open))
def normal_connectivity_trace() -> Traversal[ConnectivityResult]:
"""
Creates a new traversal that traces equipment that are normally connected.
@return The new traversal instance.
"""
return create_basic_depth_trace(queue_next_connectivity_result_with_open_test(normally_open))
def current_connectivity_trace() -> Traversal[ConnectivityResult]:
"""
Creates a new traversal that traces equipment that are currently connected.
@return The new traversal instance.
"""
return create_basic_depth_trace(queue_next_connectivity_result_with_open_test(currently_open))
# --- Traversals for phase steps ---
def phase_trace() -> Traversal[PhaseStep]:
"""
Creates a new phase-based trace ignoring the state of open phases
@return The new traversal instance.
"""
return new_phase_trace(ignore_open)
def normal_phase_trace() -> Traversal[PhaseStep]:
"""
Creates a new phase-based trace stopping on normally open phases
@return The new traversal instance.
"""
return new_phase_trace(normally_open)
def current_phase_trace() -> Traversal[PhaseStep]:
"""
Creates a new phase-based trace stopping on currently open phases
@return The new traversal instance.
"""
return new_phase_trace(currently_open)
def normal_downstream_trace() -> Traversal[PhaseStep]:
"""
Creates a new downstream trace based on phases and the normal state of the network. Note that the phases
need to be set on the network before a concept of downstream is known.
@return The new traversal instance.
"""
return new_downstream_phase_trace(normally_open, normal_direction)
def current_downstream_trace() -> Traversal[PhaseStep]:
"""
Creates a new downstream trace based on phases and the current state of the network. Note that the phases
need to be set on the network before a concept of downstream is known.
@return The new traversal instance.
"""
return new_downstream_phase_trace(currently_open, current_direction)
def normal_upstream_trace() -> Traversal[PhaseStep]:
"""
Creates a new upstream trace based on phases and the normal state of the network. Note that the phases
need to be set on the network before a concept of upstream is known.
@return The new traversal instance.
"""
return new_upstream_phase_trace(normally_open, normal_direction)
def current_upstream_trace() -> Traversal[PhaseStep]:
"""
Creates a new upstream trace based on phases and the current state of the network. Note that the phases
need to be set on the network before a concept of upstream is known.
@return The new traversal instance.
"""
return new_upstream_phase_trace(currently_open, current_direction)
# --- Downstream trees ---
def normal_downstream_tree() -> DownstreamTree:
"""
Returns an instance of `DownstreamTree` convenience class for tracing using the
normal state of a network
@return A new traversal instance.
"""
return DownstreamTree(normally_open, normal_direction)
def current_downstream_tree() -> DownstreamTree:
"""
Returns an instance of `DownstreamTree` convenience class for tracing using the
current state of a network
@return A new traversal instance.
"""
return DownstreamTree(currently_open, current_direction)
# --- Convenience functions --- TODO: Are these really needed? Why not just call the constructors directly?
def set_phases() -> SetPhases:
"""
Returns an instance of `SetPhases` convenience class for setting phases on a network.
@return A new `SetPhases` instance.
"""
return SetPhases()
def remove_phases() -> RemovePhases:
"""
Returns an instance of `RemovePhases` convenience class for removing phases from a network.
@return A new `RemovePhases` instance.
"""
return RemovePhases()
def set_direction() -> SetDirection:
"""
Returns an instance of `SetDirection` convenience class for setting feeder directions on a network.
@return A new `SetDirection` instance.
"""
return SetDirection()
def remove_direction() -> RemoveDirection:
"""
Returns an instance of `RemoveDirection` convenience class for removing feeder directions from a network.
@return A new `RemoveDirection` instance.
"""
return RemoveDirection()
def phase_inferrer() -> PhaseInferrer:
"""
Returns an instance of `PhaseInferrer` convenience class for inferring missing phases on a network.
@return A new `PhaseInferrer` instance.
"""
return PhaseInferrer()
def assign_equipment_containers_to_feeders() -> AssignToFeeders:
"""
Returns an instance of `zepben.evolve.services.network.tracing.feeder.assign_to_feeders.AssignToFeeders convenience class for assigning equipment
containers to feeders on a network.
"""
return AssignToFeeders()
# TODO
# def find_with_usage_points() -> FindWithUsagePoints:
# """
# Returns an instance of `FindWithUsagePoints` convenience class for finding conducting equipment with attached usage points.
#
# @return A new `FindWithUsagePoints` instance.
# """
# return FindWithUsagePoints() | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/tracing.py | tracing.py |
from __future__ import annotations
from dataclassy import dataclass
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import ConductingEquipment, Traversal
from zepben.evolve.services.network.tracing.phases.phase_step import PhaseStep
from zepben.evolve.services.network.tracing.tracing import normal_downstream_trace, current_downstream_trace
from typing import Callable, List, Optional, Dict
from enum import Enum
__all__ = ["Status", "Result", "find_current", "find_normal"]
class Status(Enum):
SUCCESS = 1,
NO_PATH = 2,
MISMATCHED_FROM_TO = 3
@dataclass(slots=True)
class Result(object):
status: Status = Status.SUCCESS
equipment: Optional[Dict[str, ConductingEquipment]] = dict()
async def _trace(traversal_supplier: Callable[[], Traversal], from_: ConductingEquipment, to: Optional[ConductingEquipment]):
if from_.num_terminals() == 0:
if to is not None:
return Result(status=Status.NO_PATH)
elif from_.num_usage_points() != 0:
return Result(equipment={from_.mrid: from_})
else:
return Result(status=Status.SUCCESS)
extent_ids = {ce.mrid for ce in (from_, to) if ce is not None}
path_found = [to is None]
with_usage_points = {}
async def stop_contains(phase_step):
return phase_step.conducting_equipment.mrid in extent_ids
async def step(phase_step, is_stopping):
if is_stopping:
path_found[0] = True
if phase_step.conducting_equipment.num_usage_points() != 0:
with_usage_points[phase_step.conducting_equipment.mrid] = phase_step.conducting_equipment
traversal = traversal_supplier()
traversal.add_stop_condition(stop_contains)
traversal.add_step_action(step)
traversal.reset()
# noinspection PyArgumentList
await traversal.trace(PhaseStep(from_, frozenset(next(from_.terminals).phases.single_phases)), can_stop_on_start_item=False)
# this works off a downstream trace, so if we didn't find a path try reverse from and to in case the "to" point was higher up in the network.
if to is not None and not path_found[0]:
if to.num_terminals() == 0:
return Result(status=Status.NO_PATH)
with_usage_points.clear()
traversal.reset()
# noinspection PyArgumentList
await traversal.trace(PhaseStep(to, frozenset(next(to.terminals).phases.single_phases)), can_stop_on_start_item=False)
if path_found[0]:
return Result(conducting_equipment=with_usage_points)
else:
return Result(status=Status.NO_PATH)
async def _find(traversal_supplier: Callable[[...], Traversal], froms: List[ConductingEquipment], tos: List[ConductingEquipment]) -> List[Result]:
if len(froms) != len(tos):
return [Result(status=Status.MISMATCHED_FROM_TO)] * min(len(froms), len(tos))
res = []
for f, t in zip(froms, tos):
if t is not None and f.mrid == t.mrid:
res.append(Result(equipment={f.mrid: f} if f.num_usage_points() != 0 else None))
else:
res.append(_trace(traversal_supplier, f, t))
return res
def find_normal(from_: ConductingEquipment, to: ConductingEquipment):
return _find(normal_downstream_trace, froms=[from_], tos=[to])
def find_current(from_: ConductingEquipment, to: ConductingEquipment):
return _find(current_downstream_trace, froms=[from_], tos=[to]) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/find.py | find.py |
import logging
from typing import Optional, Iterable, Set
from zepben.evolve.services.network.network_service import connected_equipment, connected_terminals
from zepben.evolve.services.network.tracing.traversals.traversal import Traversal
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
__all__ = ["conducting_equipment_queue_next", "queue_next_terminal", "tracing_logger"]
tracing_logger = logging.getLogger("queue_next")
def conducting_equipment_queue_next(conducting_equipment: Optional[ConductingEquipment], exclude: Optional[Set] = None) -> Iterable[ConductingEquipment]:
"""
Get the next `ConductingEquipment` to queue next as determined by `conducting_equipment`s connectivity.
`conducting_equipment` the `ConductingEquipment` to fetch connected equipment for.
`exclude` Any `ConductingEquipment` that should be excluded from the result.
Returns a list of `ConductingEquipment` that should be queued next.
"""
if exclude is None:
exclude = []
if conducting_equipment:
crs = connected_equipment(conducting_equipment, exclude)
return [cr.to_equip for cr in crs if cr.to_equip and cr.to_equip not in exclude]
return []
def queue_next_terminal(item: Terminal, traversal: Traversal[Terminal]):
"""
Wrapper tracing queue function for fetching the terminals that should be queued based on their connectivity
`item` The Terminal to fetch connected `zepben.evolve.iec61970.base.core.terminal.Terminal`s for.
`exclude` set of `Terminal`s to be excluded from queuing.
Returns a list of `zepben.evolve.iec61970.base.core.terminal.Terminal`s to be queued
"""
other_terms = item.get_other_terminals()
if not other_terms:
# If there are no other terminals we get connectivity for this one and return that. Note that this will
# also return connections for EnergyConsumer's, but upstream will be covered by the exclude parameter and thus
# should yield an empty list.
to_terms = [cr.to_terminal for cr in connected_terminals(item)]
if len(to_terms) > 0:
tracing_logger.debug(f"Queuing {to_terms[0].mrid} from single terminal equipment {item.mrid}")
traversal.process_queue.extend(to_terms)
return
crs = []
for term in other_terms:
crs.extend(connected_terminals(term))
to_terms = [cr.to_terminal for cr in crs]
tracing_logger.debug(f"Queuing terminals: [{', '.join(t.mrid for t in to_terms)}] from {item.mrid}")
traversal.process_queue.extend(to_terms) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/queuing_functions.py | queuing_functions.py |
from __future__ import annotations
from typing import TYPE_CHECKING, Set, Iterable, Union, Optional
from zepben.evolve import FeederDirection, connected_terminals, PhaseCode, PhaseStep, PriorityQueue, PhaseStepTracker, Traversal
from zepben.evolve.exceptions import TracingException
if TYPE_CHECKING:
from zepben.evolve import Terminal, SinglePhaseKind, ConnectivityResult, ConductingEquipment
from zepben.evolve.types import OpenTest, QueueNext, DirectionSelector
__all__ = ["new_phase_trace", "new_downstream_phase_trace", "new_upstream_phase_trace"]
def new_phase_trace(open_test: OpenTest) -> Traversal[PhaseStep]:
# noinspection PyArgumentList
return Traversal(queue_next=_queue_next(open_test), process_queue=PriorityQueue(), tracker=PhaseStepTracker())
def new_downstream_phase_trace(open_test: OpenTest, active_direction: DirectionSelector) -> Traversal[PhaseStep]:
# noinspection PyArgumentList
return Traversal(queue_next=_queue_next_downstream(open_test, active_direction), process_queue=PriorityQueue(), tracker=PhaseStepTracker())
def new_upstream_phase_trace(open_test: OpenTest, active_direction: DirectionSelector) -> Traversal[PhaseStep]:
# noinspection PyArgumentList
return Traversal(queue_next=_queue_next_upstream(open_test, active_direction), process_queue=PriorityQueue(), tracker=PhaseStepTracker())
def _queue_next(open_test: OpenTest) -> QueueNext[PhaseStep]:
def queue_next(phase_step: PhaseStep, traversal: Traversal[PhaseStep]):
down_phases = set()
for term in phase_step.conducting_equipment.terminals:
down_phases.clear()
for phase in phase_step.phases:
if not open_test(phase_step.conducting_equipment, phase):
down_phases.add(phase)
_queue_connected(traversal, term, down_phases)
return queue_next
def _queue_next_downstream(open_test: OpenTest, active_direction: DirectionSelector) -> QueueNext[PhaseStep]:
def queue_next(phase_step: PhaseStep, traversal: Traversal[PhaseStep]):
for term in phase_step.conducting_equipment.terminals:
_queue_connected(traversal, term, _get_phases_with_direction(open_test, active_direction, term, phase_step.phases, FeederDirection.DOWNSTREAM))
return queue_next
def _queue_next_upstream(open_test: OpenTest, active_direction: DirectionSelector) -> QueueNext[PhaseStep]:
def queue_next(phase_step: PhaseStep, traversal: Traversal[PhaseStep]):
for term in phase_step.conducting_equipment.terminals:
up_phases = _get_phases_with_direction(open_test, active_direction, term, phase_step.phases, FeederDirection.UPSTREAM)
if up_phases:
for cr in connected_terminals(term, up_phases):
# When going upstream, we only want to traverse to connected terminals that have a DOWNSTREAM direction
if active_direction(cr.to_terminal).value().has(FeederDirection.DOWNSTREAM):
_try_queue(traversal, cr, cr.to_nominal_phases)
return queue_next
def _queue_connected(traversal: Traversal[PhaseStep], terminal: Terminal, down_phases: Set[SinglePhaseKind]):
if down_phases:
for cr in connected_terminals(terminal, down_phases):
_try_queue(traversal, cr, cr.to_nominal_phases)
def _try_queue(traversal: Traversal[PhaseStep], cr: ConnectivityResult, down_phases: Iterable[SinglePhaseKind]):
if cr.to_equip:
traversal.process_queue.put(_continue_at(cr.to_equip, down_phases, cr.from_equip))
def _continue_at(conducting_equipment: ConductingEquipment,
phases: Union[PhaseCode, Iterable[SinglePhaseKind]],
previous: Optional[ConductingEquipment]) -> PhaseStep:
if isinstance(phases, PhaseCode):
phases = phases.single_phases
# noinspection PyArgumentList
return PhaseStep(conducting_equipment, frozenset(phases), previous)
def _get_phases_with_direction(open_test: OpenTest,
active_direction: DirectionSelector,
terminal: Terminal,
candidate_phases: Iterable[SinglePhaseKind],
direction: FeederDirection) -> Set[SinglePhaseKind]:
matched_phases: Set[SinglePhaseKind] = set()
if not active_direction(terminal).value().has(direction):
return matched_phases
conducting_equipment = terminal.conducting_equipment
if conducting_equipment is None:
raise TracingException(f"Missing conducting equipment for terminal {terminal.mrid}.")
for phase in candidate_phases:
if phase in terminal.phases.single_phases and not open_test(conducting_equipment, phase):
matched_phases.add(phase)
return matched_phases | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/phases/phase_trace.py | phase_trace.py |
from __future__ import annotations
from typing import TYPE_CHECKING, Optional
if TYPE_CHECKING:
from zepben.evolve import Terminal
from zepben.evolve.model.cim.iec61970.base.core.phase_code import phase_code_from_single_phases, PhaseCode
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
from abc import ABC, abstractmethod
__all__ = ["normal_phases", "current_phases", "PhaseStatus", "NormalPhases", "CurrentPhases"]
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`.
"""
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) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/phases/phase_status.py | phase_status.py |
from __future__ import annotations
from typing import TYPE_CHECKING, Union, Set, Callable, List, Iterable, Optional
from zepben.evolve import connected_terminals
from zepben.evolve.exceptions import PhaseException
from zepben.evolve.exceptions import TracingException
from zepben.evolve.model.cim.iec61970.base.core.phase_code import PhaseCode
from zepben.evolve.model.cim.iec61970.base.wires.energy_source import EnergySource
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
from zepben.evolve.services.network.tracing.connectivity.connectivity_result import ConnectivityResult
from zepben.evolve.services.network.tracing.connectivity.terminal_connectivity_internal import TerminalConnectivityInternal
from zepben.evolve.services.network.tracing.phases.phase_status import normal_phases, current_phases
from zepben.evolve.services.network.tracing.traversals.branch_recursive_tracing import BranchRecursiveTraversal
from zepben.evolve.services.network.tracing.traversals.queue import PriorityQueue
from zepben.evolve.services.network.tracing.util import normally_open, currently_open
if TYPE_CHECKING:
from zepben.evolve import Terminal, ConductingEquipment, NetworkService
from zepben.evolve.types import PhaseSelector
__all__ = ["SetPhases"]
class SetPhases:
"""
Convenience class that provides methods for setting phases on a `NetworkService`.
This class is backed by a `BranchRecursiveTraversal`.
"""
def __init__(self, terminal_connectivity_internal: TerminalConnectivityInternal = TerminalConnectivityInternal()):
self._terminal_connectivity_internal = terminal_connectivity_internal
# The `BranchRecursiveTraversal` used when tracing the normal state of the network.
# NOTE: If you add stop conditions to this traversal it may no longer work correctly, use at your own risk.
# noinspection PyArgumentList
self.normal_traversal = BranchRecursiveTraversal(queue_next=self._set_normal_phases_and_queue_next,
process_queue=PriorityQueue(),
branch_queue=PriorityQueue())
# The `BranchRecursiveTraversal` used when tracing the current state of the network.
# NOTE: If you add stop conditions to this traversal it may no longer work correctly, use at your own risk.
# noinspection PyArgumentList
self.current_traversal = BranchRecursiveTraversal(queue_next=self._set_current_phases_and_queue_next,
process_queue=PriorityQueue(),
branch_queue=PriorityQueue())
async def run(self, network: NetworkService):
"""
Apply phases from all sources in the network.
@param network: The network in which to apply phases.
"""
terminals = [term for es in network.objects(EnergySource) for term in es.terminals]
for term in terminals:
self._apply_phases(term, normal_phases, term.phases.single_phases)
self._apply_phases(term, current_phases, term.phases.single_phases)
await self._run_with_terminals(terminals)
async def run_with_terminal(self, terminal: Terminal, phases: Union[None, PhaseCode, List[SinglePhaseKind]] = None):
"""
Apply phases from the `terminal`.
@param terminal: The terminal to start applying phases from.
@param phases: The phases to apply. Must only contain ABCN.
"""
phases = phases or terminal.phases
if isinstance(phases, PhaseCode):
phases = phases.single_phases
if len(phases) != len(terminal.phases.single_phases):
raise TracingException(
f"Attempted to apply phases [{', '.join(phase.name for phase in phases)}] to {terminal} with nominal phases {terminal.phases.name}. "
f"Number of phases to apply must match the number of nominal phases. Found {len(phases)}, expected {len(terminal.phases.single_phases)}"
)
self._apply_phases(terminal, normal_phases, phases)
self._apply_phases(terminal, current_phases, phases)
self.normal_traversal.tracker.clear()
self.current_traversal.tracker.clear()
await self._run_with_terminals([terminal])
def spread_phases(
self,
from_terminal: Terminal,
to_terminal: Terminal,
phase_selector: PhaseSelector,
phases_to_flow: Optional[Set[SinglePhaseKind]] = None
) -> Set[SinglePhaseKind]:
"""
Apply phases from the `from_terminal` to the `to_terminal`.
@param from_terminal: The terminal to from which to spread phases.
@param to_terminal: The terminal to spread phases to.
@param phase_selector: The selector to use to spread the phases.
@param phases_to_flow: The nominal phases on which to spread phases.
@return: True if any phases were spread, otherwise False.
"""
cr = self._terminal_connectivity_internal.between(from_terminal, to_terminal, phases_to_flow)
return self._flow_via_paths(cr, phase_selector)
async def run_with_terminal_and_phase_selector(self, terminal: Terminal, phase_selector: PhaseSelector):
"""
Apply phases from the `terminal` on the selected phases. Only spreads existing phases.
@param terminal: The terminal from which to spread phases.
@param phase_selector: The selector to use to spread the phases. Must be `normal_phases` or `current_phases`.
@return: True if any phases were spread, otherwise False.
"""
if phase_selector is normal_phases:
await self._run_with_traversal_and_phase_selector([terminal], self.normal_traversal, phase_selector)
elif phase_selector is current_phases:
await self._run_with_traversal_and_phase_selector([terminal], self.current_traversal, phase_selector)
else:
raise TracingException("Invalid PhaseSelector specified. Must be normal_phases or current_phases")
async def _run_with_terminals(self, start_terminals: Iterable[Terminal]):
await self._run_with_traversal_and_phase_selector(start_terminals, self.normal_traversal, normal_phases)
await self._run_with_traversal_and_phase_selector(start_terminals, self.current_traversal, current_phases)
@staticmethod
def _apply_phases(terminal: Terminal, phase_selector: PhaseSelector, phases: Iterable[SinglePhaseKind]):
phases_status = phase_selector(terminal)
for nominal_phase, traced_phase in zip(terminal.phases.single_phases, phases):
phases_status[nominal_phase] = traced_phase if traced_phase not in PhaseCode.XY else SinglePhaseKind.NONE
async def _run_with_traversal_and_phase_selector(
self,
start_terminals: Iterable[Terminal],
traversal: BranchRecursiveTraversal[Terminal],
phase_selector: PhaseSelector
):
for terminal in start_terminals:
await self._run_terminal(terminal, traversal, phase_selector)
async def _run_terminal(self, start: Terminal, traversal: BranchRecursiveTraversal[Terminal], phase_selector: PhaseSelector):
await self._run_from_terminal(traversal, start, phase_selector, set(start.phases.single_phases))
async def _run_from_terminal(
self,
traversal: BranchRecursiveTraversal[Terminal],
terminal: Terminal,
phase_selector: PhaseSelector,
phases_to_flow: Set[SinglePhaseKind]
):
traversal.reset()
traversal.tracker.visit(terminal)
self._flow_to_connected_terminals_and_queue(traversal, terminal, phase_selector, phases_to_flow)
await traversal.trace()
def _set_normal_phases_and_queue_next(self, terminal: Terminal, traversal: BranchRecursiveTraversal[Terminal]):
self._set_phases_and_queue_next(terminal, traversal, normally_open, normal_phases)
def _set_current_phases_and_queue_next(self, terminal: Terminal, traversal: BranchRecursiveTraversal[Terminal]):
self._set_phases_and_queue_next(terminal, traversal, currently_open, current_phases)
def _set_phases_and_queue_next(
self,
current: Terminal,
traversal: BranchRecursiveTraversal[Terminal],
open_test: Callable[[ConductingEquipment, SinglePhaseKind], bool],
phase_selector: PhaseSelector
):
phases_to_flow = self._get_phases_to_flow(current, open_test)
if current.conducting_equipment:
for out_terminal in current.conducting_equipment.terminals:
if out_terminal != current:
phases_flowed = self._flow_through_equipment(traversal, current, out_terminal, phase_selector, phases_to_flow)
if phases_flowed:
self._flow_to_connected_terminals_and_queue(traversal, out_terminal, phase_selector, phases_flowed)
def _flow_through_equipment(
self,
traversal: BranchRecursiveTraversal[Terminal],
from_terminal: Terminal,
to_terminal: Terminal,
phase_selector: PhaseSelector,
phases_to_flow: Set[SinglePhaseKind]
) -> Set[SinglePhaseKind]:
traversal.tracker.visit(to_terminal)
return self.spread_phases(from_terminal, to_terminal, phase_selector, phases_to_flow)
def _flow_to_connected_terminals_and_queue(
self,
traversal: BranchRecursiveTraversal[Terminal],
from_terminal: Terminal,
phase_selector: PhaseSelector,
phases_to_flow: Set[SinglePhaseKind]
):
"""
Applies all the `phases_to_flow` from the `from_terminal` to the connected terminals and queues them.
"""
connectivity_results = connected_terminals(from_terminal, phases_to_flow)
conducting_equip = from_terminal.conducting_equipment
use_branch_queue = len(connectivity_results) > 1 or (conducting_equip and conducting_equip.num_terminals() > 2)
for cr in connectivity_results:
if self._flow_via_paths(cr, phase_selector):
if use_branch_queue:
branch = traversal.create_branch()
branch.start_item = cr.to_terminal
traversal.branch_queue.put(branch)
else:
traversal.process_queue.put(cr.to_terminal)
@staticmethod
def _flow_via_paths(cr: ConnectivityResult, phase_selector: PhaseSelector) -> Set[SinglePhaseKind]:
from_phases = phase_selector(cr.from_terminal)
to_phases = phase_selector(cr.to_terminal)
changed_phases = set()
for path in cr.nominal_phase_paths:
try:
# If the path comes from NONE, then we want to apply the `to phase`.
phase = from_phases[path.from_phase] if path.from_phase != SinglePhaseKind.NONE else \
path.to_phase if path.to_phase not in PhaseCode.XY else to_phases[path.to_phase]
if (phase != SinglePhaseKind.NONE) and to_phases.__setitem__(path.to_phase, phase):
changed_phases.add(path.to_phase)
except PhaseException as ex:
phase_desc = path.from_phase.name if path.from_phase == path.to_phase else f"path {path.from_phase.name} to {path.to_phase.name}"
terminal_desc = f"from {cr.from_terminal} to {cr.to_terminal} through {cr.from_equip}" if cr.from_equip == cr.to_equip else \
f"between {cr.from_terminal} on {cr.from_equip} and {cr.to_terminal} on {cr.to_equip}"
raise PhaseException(
f"Attempted to flow conflicting phase {from_phases[path.from_phase].name} onto {to_phases[path.to_phase].name} on nominal phase " +
f"{phase_desc}. This occurred while flowing {terminal_desc}. This is caused by missing open points, or incorrect phases in upstream " +
"equipment that should be corrected in the source data."
) from ex
return changed_phases
@staticmethod
def _get_phases_to_flow(
terminal: Terminal,
open_test: Callable[[ConductingEquipment, Optional[SinglePhaseKind]], bool]
) -> Set[SinglePhaseKind]:
equip = terminal.conducting_equipment
if not equip:
return set()
return {phase for phase in terminal.phases.single_phases if not open_test(equip, phase)} | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/phases/set_phases.py | set_phases.py |
import logging
from typing import Dict, Callable, List, Set, Awaitable
from zepben.evolve import Terminal, SinglePhaseKind, ConductingEquipment, NetworkService, normal_phases, normal_direction, \
FeederDirection, X_PRIORITY, Y_PRIORITY, SetPhases, is_before, is_after, current_phases, current_direction
from zepben.evolve.types import PhaseSelector, DirectionSelector
__all__ = ["PhaseInferrer"]
logger = logging.getLogger(__name__)
class PhaseInferrer:
"""
A class that can infer missing phases on a network that has been processed by `SetPhases`.
"""
def __init__(self) -> None:
super().__init__()
self._tracking: Dict[ConductingEquipment, bool] = {}
async def run(self, network: NetworkService):
"""
Infer the missing phases on the specified `network`.
:param network: The `NetworkService` to infer phases on.
"""
self._tracking = {}
await self._infer_missing_phases(network, normal_phases, normal_direction)
await self._infer_missing_phases(network, current_phases, current_direction)
for (conducting_equipment, has_suspect_inferred) in self._tracking.items():
if has_suspect_inferred:
logger.warning(
f"*** Action Required *** Inferred missing phases for '{conducting_equipment.name}' [{conducting_equipment.mrid}] which may not be "
"correct. The phases were inferred due to a disconnected nominal phase because of an upstream error in the source data. Phasing "
"information for the upstream equipment should be fixed in the source system."
)
else:
logger.warning(
f"*** Action Required *** Inferred missing phase for '{conducting_equipment.name}' [{conducting_equipment.mrid}] which should be "
"correct. The phase was inferred due to a disconnected nominal phase because of an upstream error in the source data. Phasing "
"information for the upstream equipment should be fixed in the source system."
)
async def _infer_missing_phases(self, network: NetworkService, phase_selector: PhaseSelector, direction_selector: DirectionSelector):
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, phase_selector)]
terms_missing_xy_phases = [it for it in terms_missing_phases if self._has_xy_phases(it)]
async def set_missing_to_nominal(terminal: Terminal) -> bool:
return await self._set_missing_to_nominal(terminal, phase_selector)
async def infer_xy_phases_1(terminal: Terminal) -> bool:
return await self._infer_xy_phases(terminal, phase_selector, 1)
async def infer_xy_phases_4(terminal: Terminal) -> bool:
return await self._infer_xy_phases(terminal, phase_selector, 4)
did_nominal = await self._process(terms_missing_phases, phase_selector, direction_selector, set_missing_to_nominal)
did_xy_1 = await self._process(terms_missing_xy_phases, phase_selector, direction_selector, infer_xy_phases_1)
did_xy_4 = await self._process(terms_missing_xy_phases, phase_selector, direction_selector, infer_xy_phases_4)
if not (did_nominal or did_xy_1 or did_xy_4):
break
@staticmethod
def _is_connected_to_others(terminal: Terminal) -> bool:
return terminal.connectivity_node and (terminal.connectivity_node.num_terminals() > 1)
@staticmethod
def _has_none_phase(terminal: Terminal, phase_selector: PhaseSelector) -> bool:
phases = phase_selector(terminal)
return any(phases[it] == SinglePhaseKind.NONE for it in terminal.phases.single_phases)
@staticmethod
def _has_xy_phases(terminal: Terminal) -> bool:
return (SinglePhaseKind.X in terminal.phases) or (SinglePhaseKind.Y in terminal.phases)
def _find_terminal_at_start_of_missing_phases(
self,
terminals: List[Terminal],
phase_selector: PhaseSelector,
direction_selector: DirectionSelector
) -> List[Terminal]:
candidates = self._missing_from_down_to_up(terminals, phase_selector, direction_selector)
if not candidates:
candidates = self._missing_from_down_to_any(terminals, phase_selector, direction_selector)
if not candidates:
candidates = self._missing_from_any(terminals, phase_selector)
return candidates
def _missing_from_down_to_up(self, terminals: List[Terminal], phase_selector: PhaseSelector, direction_selector: DirectionSelector) -> List[Terminal]:
return [
terminal for terminal in terminals
if (self._has_none_phase(terminal, phase_selector) and
direction_selector(terminal).value().has(FeederDirection.UPSTREAM) and
terminal.connectivity_node and
any(not self._has_none_phase(t, phase_selector) for t in terminal.connectivity_node.terminals if
(t != terminal) and direction_selector(t).value().has(FeederDirection.DOWNSTREAM)))
]
def _missing_from_down_to_any(self, terminals: List[Terminal], phase_selector: PhaseSelector, direction_selector: DirectionSelector) -> List[Terminal]:
return [
terminal for terminal in terminals
if (self._has_none_phase(terminal, phase_selector) and
terminal.connectivity_node and
any(not self._has_none_phase(t, phase_selector) for t in terminal.connectivity_node.terminals if
(t != terminal) and direction_selector(t).value().has(FeederDirection.DOWNSTREAM)))
]
def _missing_from_any(self, terminals: List[Terminal], phase_selector: PhaseSelector) -> List[Terminal]:
return [
terminal for terminal in terminals
if (self._has_none_phase(terminal, phase_selector) and
terminal.connectivity_node and
any(not self._has_none_phase(t, phase_selector) for t in terminal.connectivity_node.terminals if t != terminal))
]
async def _process(
self,
terminals: List[Terminal],
phase_selector: PhaseSelector,
direction_selector: DirectionSelector,
processor: Callable[[Terminal], Awaitable[bool]]
) -> bool:
terminals_to_process = self._find_terminal_at_start_of_missing_phases(terminals, phase_selector, direction_selector)
has_processed = False
while True:
continue_processing = False
for terminal in terminals_to_process:
continue_processing = await processor(terminal) or continue_processing
terminals_to_process = self._find_terminal_at_start_of_missing_phases(terminals, phase_selector, direction_selector)
has_processed = has_processed or continue_processing
if not continue_processing:
break
return has_processed
async def _set_missing_to_nominal(self, terminal: Terminal, phase_selector: PhaseSelector) -> bool:
phases = phase_selector(terminal)
phases_to_process = [it for it in terminal.phases.single_phases if
(it != SinglePhaseKind.X) and (it != 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, phase_selector)
if terminal.conducting_equipment:
self._tracking[terminal.conducting_equipment] = False
return True
async def _infer_xy_phases(self, terminal: Terminal, phase_selector: PhaseSelector, max_missing_phases: int) -> bool:
none: List[SinglePhaseKind] = []
used_phases: Set[SinglePhaseKind] = set()
if not terminal.conducting_equipment:
return False
phases = phase_selector(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
self._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, phase_selector)
return had_changes
@staticmethod
async def _continue_phases(terminal: Terminal, phase_selector: PhaseSelector):
if terminal.conducting_equipment:
for other in terminal.conducting_equipment.terminals:
if other != terminal:
set_phases = SetPhases()
set_phases.spread_phases(terminal, other, phase_selector=phase_selector)
await set_phases.run_with_terminal_and_phase_selector(other, phase_selector)
@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.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/phases/phase_inferrer.py | phase_inferrer.py |
from __future__ import annotations
from zepben.evolve import PhaseCode
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
from typing import FrozenSet, Optional, Union, Iterable
from dataclassy import dataclass
__all__ = ["PhaseStep"]
@dataclass(slots=True)
class PhaseStep(object):
"""
Class that records which phases were traced to get to a given conducting equipment during a trace.
Allows a trace to continue only on the phases used to get to the current step in the trace.
This class is immutable.
"""
conducting_equipment: ConductingEquipment
"""The current `zepben.evolve.cim.iec61970.base.core.conducting_equipment.ConductingEquipment`"""
phases: FrozenSet[SinglePhaseKind]
"""The phases which were traced"""
previous: Optional[ConductingEquipment] = None
"""`previous` The previous `zepben.evolve.cim.iec61970.base.core.conducting_equipment.ConductingEquipment`"""
def __eq__(self, other):
if self is other:
return True
return self.conducting_equipment is other.conducting_equipment and self.phases == other.phases
def __ne__(self, other):
if self is other:
return False
return self.equipment is not other.conducting_equipment or self.phases != other.phases
def __lt__(self, other):
"""
This definition should only be used for sorting within a `zepben.evolve.tracing.queue.PriorityQueue`
`other` Another PhaseStep to compare against
Returns True if self has more phases than other, False otherwise.
"""
return len(self.phases) > len(other.phases)
def __hash__(self):
return hash((self.conducting_equipment, self.phases))
def start_at(conducting_equipment: ConductingEquipment, phases: Union[PhaseCode, Iterable[SinglePhaseKind]]):
if isinstance(phases, PhaseCode):
phases = phases.single_phases
return PhaseStep(conducting_equipment, frozenset(phases), None)
def continue_at(conducting_equipment: ConductingEquipment, phases: Union[PhaseCode, Iterable[SinglePhaseKind]], previous: Optional[ConductingEquipment]):
if isinstance(phases, PhaseCode):
phases = phases.single_phases
return PhaseStep(conducting_equipment, frozenset(phases), previous) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/phases/phase_step.py | phase_step.py |
from __future__ import annotations
from typing import TYPE_CHECKING, Tuple, Set, Optional, Union, FrozenSet
from zepben.evolve import connected_terminals
from zepben.evolve.model.cim.iec61970.base.core.phase_code import PhaseCode
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
from zepben.evolve.services.network.tracing.phases.phase_status import normal_phases, current_phases
from zepben.evolve.services.network.tracing.traversals.branch_recursive_tracing import BranchRecursiveTraversal
from zepben.evolve.services.network.tracing.traversals.queue import PriorityQueue
if TYPE_CHECKING:
from zepben.evolve import ConnectivityResult, ConductingEquipment, NetworkService
from zepben.evolve.types import PhaseSelector
EbbPhases = Tuple[Terminal, FrozenSet[SinglePhaseKind]]
__all__ = ["RemovePhases", "remove_all_traced_phases"]
class RemovePhases(object):
"""
Convenience class that provides methods for removing phases on a `NetworkService`
This class is backed by a `BranchRecursiveTraversal`.
"""
def __init__(self):
# The `BranchRecursiveTraversal` used when tracing the normal state of the network.
# NOTE: If you add stop conditions to this traversal it may no longer work correctly, use at your own risk.
# noinspection PyArgumentList
self.normal_traversal = BranchRecursiveTraversal(queue_next=_ebb_and_queue_normal_phases,
process_queue=PriorityQueue(),
branch_queue=PriorityQueue())
# The `BranchRecursiveTraversal` used when tracing the current state of the network.
# NOTE: If you add stop conditions to this traversal it may no longer work correctly, use at your own risk.
# noinspection PyArgumentList
self.current_traversal = BranchRecursiveTraversal(queue_next=_ebb_and_queue_current_phases,
process_queue=PriorityQueue(),
branch_queue=PriorityQueue())
async def run(self, terminal: Terminal, nominal_phases_to_ebb: Union[None, PhaseCode, FrozenSet[SinglePhaseKind]] = None):
"""
Allows the removal of traced phases from a terminal and the connected equipment chain.
@param terminal: The terminal from which to start the phase removal.
@param nominal_phases_to_ebb: The nominal phases to remove traced phasing from. Defaults to all phases.
"""
nominal_phases_to_ebb = nominal_phases_to_ebb or terminal.phases
if isinstance(nominal_phases_to_ebb, PhaseCode):
nominal_phases_to_ebb = frozenset(nominal_phases_to_ebb.single_phases)
for traversal in (self.normal_traversal, self.current_traversal):
traversal.reset()
await traversal.trace((terminal, nominal_phases_to_ebb))
def remove_all_traced_phases(network_service: NetworkService):
for terminal in network_service.objects(Terminal):
terminal.traced_phases.phase_status = 0
def _ebb_and_queue_normal_phases(ebb_phases: EbbPhases, traversal: BranchRecursiveTraversal[EbbPhases]):
_ebb_and_queue(ebb_phases, traversal, normal_phases)
def _ebb_and_queue_current_phases(ebb_phases: EbbPhases, traversal: BranchRecursiveTraversal[EbbPhases]):
_ebb_and_queue(ebb_phases, traversal, current_phases)
def _ebb_and_queue(ebb_phases: EbbPhases, traversal: BranchRecursiveTraversal[EbbPhases], phase_selector: PhaseSelector):
terminal, nominal_phases = ebb_phases
ebbed_phases = _ebb(terminal, nominal_phases, phase_selector)
for cr in connected_terminals(terminal, nominal_phases):
_queue_through_equipment(traversal, cr.to_equip, cr.to_terminal, _ebb_from_connected_terminal(ebbed_phases, cr, phase_selector))
def _ebb(terminal: Terminal, phases_to_ebb: Set[SinglePhaseKind], phase_selector: PhaseSelector) -> Set[SinglePhaseKind]:
phases = phase_selector(terminal)
ebbed_phases = set(filter(lambda p: phases[p] != SinglePhaseKind.NONE, phases_to_ebb))
for phase in ebbed_phases:
phases[phase] = SinglePhaseKind.NONE
return phases_to_ebb
def _ebb_from_connected_terminal(phases_to_ebb: Set[SinglePhaseKind], cr: ConnectivityResult, phase_selector: PhaseSelector) -> Set[SinglePhaseKind]:
connected_phases = set()
for phase in phases_to_ebb:
connected_phase = next((path.to_phase for path in cr.nominal_phase_paths if path.from_phase == phase), None)
if connected_phase:
connected_phases.add(connected_phase)
return _ebb(cr.to_terminal, connected_phases, phase_selector)
def _queue_through_equipment(traversal: BranchRecursiveTraversal[EbbPhases],
conducting_equipment: Optional[ConductingEquipment],
terminal: Terminal,
phases_to_ebb: Set[SinglePhaseKind]):
if conducting_equipment:
for term in filter(lambda t: t != terminal, conducting_equipment.terminals):
traversal.process_queue.put((term, frozenset(phases_to_ebb))) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/phases/remove_phases.py | remove_phases.py |
from abc import abstractmethod
__all__ = ["BaseTracker", "Tracker"]
from typing import TYPE_CHECKING, TypeVar, Set, Generic
from dataclassy import dataclass
T = TypeVar("T")
@dataclass(slots=True)
class BaseTracker(Generic[T]):
"""
An interface used by `zepben.evolve.tracing.Traversal`'s to 'track' items that have been visited.
A `Traversal` will utilise `has_visited`, `visit`, and `clear`.
"""
@abstractmethod
def has_visited(self, item: T) -> bool:
"""
Check if the tracker has already seen an item.
`item` The item to check if it has been visited.
Returns true if the item has been visited, otherwise false.
"""
raise NotImplementedError()
@abstractmethod
def visit(self, item: T) -> bool:
"""
Visit an item. Item will not be visited if it has previously been visited.
`item` The item to visit.
Returns True if visit succeeds. False otherwise.
"""
raise NotImplementedError()
@abstractmethod
def clear(self):
"""
Clear the tracker, removing all visited items.
"""
raise NotImplementedError()
class Tracker(BaseTracker[T]):
"""
An interface used by `zepben.evolve.traversals.tracing.Traversal`'s to 'track' items that have been visited.
"""
visited: Set = set()
def has_visited(self, item: T) -> bool:
"""
Check if the tracker has already seen an item.
`item` The item to check if it has been visited.
Returns true if the item has been visited, otherwise false.
"""
return item in self.visited
def visit(self, item: T) -> bool:
"""
Visit an item. Item will not be visited if it has previously been visited.
`item` The item to visit.
Returns True if visit succeeds. False otherwise.
"""
if item in self.visited:
return False
else:
self.visited.add(item)
return True
def clear(self):
"""
Clear the tracker, removing all visited items.
"""
self.visited.clear()
def copy(self):
return Tracker(visited=self.visited.copy()) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/traversals/tracker.py | tracker.py |
from __future__ import annotations
from collections import deque
from abc import abstractmethod, ABC
from typing import TypeVar, Generic, Iterable
from heapq import heappush, heappop
__all__ = ["Queue", "FifoQueue", "LifoQueue", "PriorityQueue", "depth_first", "breadth_first"]
T = TypeVar('T')
def depth_first():
return LifoQueue()
def breadth_first():
return FifoQueue()
class Queue(Generic[T], ABC):
def __init__(self, queue=None):
if queue is None:
self.queue = deque()
else:
self.queue = queue
@abstractmethod
def put(self, item: T):
raise NotImplementedError()
@abstractmethod
def extend(self, items: Iterable[T]):
raise NotImplementedError()
@abstractmethod
def get(self) -> T:
"""
Pop an item off the queue.
Raises `IndexError` if the queue is empty.
"""
raise NotImplementedError()
@abstractmethod
def empty(self) -> bool:
"""
Check if queue is empty
Returns True if empty, False otherwise
"""
raise NotImplementedError()
@abstractmethod
def peek(self) -> T:
"""
Retrieve next item on queue, but don't remove from queue.
Returns Next item on the queue
"""
raise NotImplementedError()
@abstractmethod
def clear(self):
"""Clear the queue."""
raise NotImplementedError()
@abstractmethod
def copy(self) -> Queue[T]:
"""Create a copy of this Queue"""
raise NotImplementedError()
class FifoQueue(Queue[T]):
"""Used for Breadth-first Traversal's"""
def put(self, item: T):
self.queue.append(item)
def extend(self, items: Iterable[T]):
self.queue.extend(items)
def get(self) -> T:
"""
Pop an item off the queue.
Raises `IndexError` if the queue is empty.
"""
return self.queue.popleft()
def empty(self) -> bool:
"""
Check if queue is empty
Returns True if empty, False otherwise
"""
return len(self.queue) == 0
def peek(self) -> T:
"""
Retrieve next item on queue, but don't remove from queue.
Returns Next item on the queue
"""
return self.queue[0]
def clear(self):
"""Clear the queue."""
self.queue.clear()
def copy(self) -> FifoQueue[T]:
return FifoQueue(self.queue.copy())
class LifoQueue(Queue[T]):
"""Used for Depth-first Traversal's"""
def put(self, item: T):
self.queue.append(item)
def extend(self, items: Iterable[T]):
self.queue.extend(items)
def get(self) -> T:
"""
Pop an item off the queue.
Raises `IndexError` if the queue is empty.
"""
return self.queue.pop()
def empty(self) -> bool:
"""
Check if queue is empty
Returns True if empty, False otherwise
"""
return len(self.queue) == 0
def peek(self) -> T:
"""
Retrieve next item on queue, but don't remove from queue.
Returns Next item on the queue
"""
return self.queue[-1]
def clear(self):
"""Clear the queue."""
self.queue.clear()
def copy(self) -> LifoQueue[T]:
return LifoQueue(self.queue.copy())
class PriorityQueue(Queue[T]):
"""Used for custom `Traversal`s"""
def __init__(self, queue=None):
if queue is None:
super().__init__([])
else:
super().__init__(queue)
def __len__(self):
return len(self.queue)
def put(self, item: T):
"""
Place an item in the queue based on its priority.
`item` The item to place on the queue. Must implement `__lt__`
Returns True if put was successful, False otherwise.
"""
heappush(self.queue, item)
def extend(self, items: Iterable[T]):
for item in items:
heappush(self.queue, item)
def get(self) -> T:
"""
Get the next item in the queue, removing it from the queue.
Returns The next item in the queue by priority.
Raises `IndexError` if the queue is empty
"""
return heappop(self.queue)
def peek(self) -> T:
"""
Retrieve the next item in the queue, but don't remove it from the queue.
Note that you shouldn't modify the returned item after using this function, as you could change its
priority and thus corrupt the queue. Always use `get` if you intend on modifying the result.
Returns The next item in the queue
"""
return self.queue[0]
def empty(self) -> bool:
return len(self) == 0
def clear(self):
"""Clear the queue."""
self.queue.clear()
def copy(self) -> PriorityQueue[T]:
return PriorityQueue(self.queue.copy()) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/traversals/queue.py | queue.py |
from __future__ import annotations
from abc import abstractmethod
from dataclassy import dataclass
from zepben.evolve.services.network.tracing.traversals.queue import FifoQueue, LifoQueue, PriorityQueue, Queue
from zepben.evolve.exceptions import TracingException
from zepben.evolve.services.network.tracing.traversals.tracker import Tracker, BaseTracker
from typing import List, Callable, Awaitable, TypeVar, Generic
from enum import Enum
__all__ = ["SearchType", "create_queue", "BaseTraversal", "Traversal"]
T = TypeVar('T')
class SearchType(Enum):
BREADTH = 1
DEPTH = 2
PRIORITY = 3
def create_queue(search_type):
if search_type == SearchType.DEPTH:
return LifoQueue()
elif search_type == SearchType.BREADTH:
return FifoQueue()
elif search_type == SearchType.PRIORITY:
return PriorityQueue()
@dataclass(slots=True)
class BaseTraversal(Generic[T]):
"""
A basic traversal implementation that can be used to traverse any type of item.
This class is asyncio compatible. Stop condition and step action callbacks are called with await.
A stop condition is a callback function that must return a boolean indicating whether the Tracer should stop
processing the current branch. Tracing will only stop when either:
- All branches have been exhausted, or
- A stop condition has returned true on every possible branch.
Stop conditions will be called prior to applying any callbacks, but the stop will only occur after all actions
have been applied.
Step actions are functions to be called on each item visited in the trace. These are called after the stop conditions are evaluated, and each action is
passed the current `zepben.evolve.network.tracing.connectivity.ConnectivityResult` as well as the `stopping` state (True if the trace is stopping after
the current `ConnectivityResult, False otherwise). Thus, the signature of each step action must be:
:func: action(cr: `zepben.evolve.tracing.ConnectivityResult`, is_stopping: bool) -> None
"""
start_item: T = None
"""The starting item for this `BaseTraversal`"""
stop_conditions: List[Callable[[T], Awaitable[bool]]] = []
"""A list of callback functions, to be called in order with the current item."""
step_actions: List[Callable[[T, bool], Awaitable[None]]] = []
"""A list of callback functions, to be called on each item."""
_has_run: bool = False
"""Whether this traversal has run """
_running: bool = False
"""Whether this traversal is currently running"""
async def matches_any_stop_condition(self, item: T):
"""
Checks all the stop conditions for the passed in item and returns true if any match.
This calls all registered stop conditions even if one has already returned true to make sure everything is
notified about this item.
Each stop condition will be awaited and thus must be an async function.
`item` The item to pass to the stop conditions.
Returns True if any of the stop conditions return True.
"""
stop = False
for cond in self.stop_conditions:
stop = stop or await cond(item)
return stop
def add_stop_condition(self, cond: Callable[[T], Awaitable[bool]]):
"""
Add a callback to check whether the current item in the traversal is a stop point.
If any of the registered stop conditions return true, the traversal will not call the callback to queue more items.
Note that a match on a stop condition doesn't necessarily stop the traversal, it just stops traversal of the current branch.
`cond` A function that if returns true will cause the traversal to stop traversing the branch.
Returns this traversal instance.
"""
self.stop_conditions.append(cond)
def add_step_action(self, action: Callable[[T, bool], Awaitable[None]]) -> BaseTraversal[T]:
"""
Add a callback which is called for every item in the traversal (including the starting item).
`action` Action to be called on each item in the traversal, passing if the trace will stop on this step.
Returns this traversal instance.
"""
self.step_actions.append(action)
return self
def copy_stop_conditions(self, other: BaseTraversal[T]):
"""Copy the stop conditions from `other` to this `BaseTraversal`."""
self.stop_conditions.extend(other.stop_conditions)
def copy_step_actions(self, other: BaseTraversal[T]):
"""Copy the step actions from `other` to this `BaseTraversal`."""
self.step_actions.extend(other.step_actions)
def clear_stop_conditions(self):
"""Clear all stop conditions."""
self.stop_conditions.clear()
def clear_step_actions(self):
"""Clear all step actions"""
self.step_actions.clear()
async def apply_step_actions(self, item: T, is_stopping: bool):
"""
Calls all the step actions with the passed in item.
Each action will be awaited.
`item` The item to pass to the step actions.
`is_stopping` Indicates if the trace will stop on this step.
"""
for action in self.step_actions:
await action(item, is_stopping)
def _reset_run_flag(self):
if self._running:
raise TracingException("Can't reset when Traversal is currently executing.")
self._has_run = False
@abstractmethod
def reset(self):
"""
Reset this traversal. Should take care to reset all fields and queues so that the traversal can be reused.
"""
raise NotImplementedError()
async def trace(self, start_item: T = None, can_stop_on_start_item: bool = True):
"""
Perform a trace across the network from `start_item`, applying actions to each piece of equipment encountered
until all branches of the network are exhausted, or a stop condition succeeds and we cannot continue any further.
When a stop condition is reached, we will stop tracing that branch of the network and continue with other branches.
`start_item` The starting point. Must implement :func:`zepben.evolve.ConductingEquipment::get_connectivity`
which allows tracing over the terminals in a network.
`can_stop_on_start_item` If it's possible for stop conditions to apply to the start_item.
"""
if self._running:
raise TracingException("Traversal is already running.")
if self._has_run:
raise TracingException("Traversal must be reset before reuse.")
self._running = True
self._has_run = True
self.start_item = start_item if start_item is not None else self.start_item
await self._run_trace(can_stop_on_start_item)
self._running = False
@abstractmethod
async def _run_trace(self, can_stop_on_start_item: bool = True):
"""
Extend and implement your tracing algorithm here.
`start_item` The starting object to commence tracing. Must implement :func:`zepben.evolve.ConductingEquipment.get_connectivity`
`can_stop_on_start_item` Whether to
"""
raise NotImplementedError()
class Traversal(BaseTraversal[T]):
"""
A basic traversal implementation that can be used to traverse any type of item.
The traversal gets the next items to be traversed to by calling a user provided callback (next_), with the current
item of the traversal. This function should return a list of ConnectivityResult's, that will get added to the
process_queue for processing.
Different `SearchType`'s types can be used to provide different trace types via the `process_queue`.
The default `Depth` will utilise a `LifoQueue` to provide a depth-first search of the network, while a `Breadth`
will use a FIFO `Queue` breadth-first search. More complex searches can be achieved with `Priority`, which
will use a PriorityQueue under the hood.
The traversal also requires a `zepben.evolve.traversals.tracker.Tracker` to be supplied. This gives flexibility
to track items in unique ways, more than just "has this item been visited" e.g. visiting more than once,
visiting under different conditions etc.
"""
queue_next: Callable[[T, Traversal[T]], None]
"""A function that will return a list of `T` to add to the queue. The function must take the item to queue and optionally a set of already visited items."""
process_queue: Queue[T]
"""Dictates the type of search to be performed on the network graph. Breadth-first, Depth-first, and Priority based searches are possible."""
tracker: BaseTracker = Tracker()
"""A `zepben.evolve.traversals.tracker.Tracker` for tracking which items have been seen. If not provided a `Tracker` will be created for this trace."""
async def _run_trace(self, can_stop_on_start_item: bool = True):
"""
Run's the trace. Stop conditions and step_actions are called with await, so you can utilise asyncio when
performing a trace if your step actions or conditions are IO intensive. Stop conditions and
step actions will always be called for each item in the order provided.
`can_stop_on_start_item` Whether the trace can stop on the start_item. Actions will still be applied to
the start_item.
"""
can_stop = True
if self.start_item:
self.process_queue.put(self.start_item)
can_stop = can_stop_on_start_item
while not self.process_queue.empty():
current = self.process_queue.get()
if self.tracker.visit(current):
stopping = can_stop and await self.matches_any_stop_condition(current)
await self.apply_step_actions(current, stopping)
if not stopping:
self.queue_next(current, self)
can_stop = True
def reset(self):
self._reset_run_flag()
self.process_queue.queue.clear()
self.tracker.clear()
def _depth_trace(start_item, stop_on_start_item=True, stop_fn=None, equip_fn=None, term_fn=None):
equips_to_trace = []
traced = set()
for t in start_item.terminals:
traced.add(t.mrid)
if stop_on_start_item:
yield start_item
equips_to_trace.append(start_item)
while equips_to_trace:
try:
equip = equips_to_trace.pop()
except IndexError: # No more equipment
break
# Explore all connectivity nodes for this equipments terminals,
# and set upstream on each terminal.
for terminal in equip.terminals:
conn_node = terminal.connectivity_node
for term in conn_node:
# keep this
if term.mrid in traced:
continue
if term != terminal:
if not term.conducting_equipment.connected():
continue
equips_to_trace.append(term.conducting_equipment)
yield term.conducting_equipment
# Don't trace over a terminal twice to stop us from reversing direction
traced.add(term.mrid) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/traversals/traversal.py | traversal.py |
from __future__ import annotations
from zepben.evolve.services.network.tracing.traversals.queue import Queue
from zepben.evolve.services.network.tracing.traversals.traversal import BaseTraversal
from zepben.evolve.services.network.tracing.traversals.tracker import Tracker
from typing import Callable, TypeVar, Optional
__all__ = ["BranchRecursiveTraversal"]
T = TypeVar('T')
class BranchRecursiveTraversal(BaseTraversal[T]):
queue_next: Callable[[T, BaseTraversal[T]], None]
"""A callable for each item encountered during the trace, that should queue the next items found on the given traversal's `process_queue`.
The first argument will be the current item, the second this traversal, and the third a set of already visited items that can be used as an optional
optimisation to skip queuing."""
branch_queue: Queue[BranchRecursiveTraversal[T]]
"""Queue containing branches to be processed"""
process_queue: Queue[T]
"""Queue containing the items to process for this branch"""
tracker: Tracker = Tracker()
"""Tracker for the items in this branch"""
parent: Optional[BranchRecursiveTraversal[T]] = None
"""The parent branch for this branch, None implies this branch has no parent"""
on_branch_start: Optional[Callable[[T], None]] = None
"""A function to call at the start of each branches processing"""
def __lt__(self, other):
"""
This Traversal is Less than `other` if the starting item is less than other's starting item.
This is used to dictate which branch is next to traverse in the branch_queue.
"""
if self.start_item is not None and other.start_item is not None:
return self.start_item < other.start_item
elif self.start_item is None and other.start_item is None:
return False
elif other.start_item is None:
return True
else:
return False
def has_visited(self, item: T):
"""
Check whether item has been visited before. An item is visited if this traversal or any parent has visited it.
`item` The item to check
Returns True if the item has been visited once.
"""
parent = self.parent
while parent is not None:
if parent.tracker.has_visited(item):
return True
parent = parent.parent
return self.tracker.has_visited(item)
def visit(self, item: T):
"""
Visit an item.
`item` Item to visit
Returns True if we visit the item. False if this traversal or any parent has previously visited this item.
"""
parent = self.parent
while parent is not None:
if parent.tracker.has_visited(item):
return False
parent = parent.parent
return self.tracker.visit(item)
async def traverse_branches(self):
"""
Start a new traversal for the next branch in the queue.
on_branch_start will be called on the start_item for the branch.
"""
while not self.branch_queue.empty():
t = self.branch_queue.get()
if t is not None:
if self.on_branch_start is not None:
self.on_branch_start(t.start_item)
await t.trace()
def reset(self) -> BranchRecursiveTraversal:
"""Reset the run state, queues and tracker for this traversal"""
self._reset_run_flag()
self.process_queue.clear()
self.branch_queue.clear()
self.tracker.clear()
return self
def create_branch(self):
"""
Create a branch for this `Traversal`. Will take copies of queues, actions, conditions, and tracker, and
pass this `Traversal` as the parent. The new Traversal will be :meth:`reset` prior to being returned.
Returns A new `BranchRecursiveTraversal` the same as this, but with this Traversal as its parent
"""
# noinspection PyArgumentList
branch = BranchRecursiveTraversal(queue_next=self.queue_next,
branch_queue=self.branch_queue.copy(),
tracker=self.tracker.copy(),
parent=self,
on_branch_start=self.on_branch_start,
process_queue=self.process_queue.copy(),
step_actions=list(self.step_actions),
stop_conditions=list(self.stop_conditions))
branch.reset()
return branch
async def _run_trace(self, can_stop_on_start_item: bool = True):
"""
Run's the trace. Stop conditions and step_actions are called with await, so you can utilise asyncio when performing a trace if your step actions or
conditions are IO intensive. Stop conditions and step actions will always be called for each item in the order provided.
`can_stop_on_start_item` Whether the trace can stop on the start_item. Actions will still be applied to the start_item.
"""
# Unroll first iteration of loop to handle can_stop_on_start_item = True
if self.start_item is None:
try:
self.start_item = self.process_queue.get()
except IndexError:
# Our start point may very well be a branch - if so we don't need to process this branch.
await self.traverse_branches()
return
if not self.visit(self.start_item):
return
# If we can't stop on the start item we don't run any stop conditions. if this causes a problem for you,
# work around it by running the stop conditions for the start item prior to running the trace.
stopping = can_stop_on_start_item and await self.matches_any_stop_condition(self.start_item)
await self.apply_step_actions(self.start_item, stopping)
if not stopping:
self.queue_next(self.start_item, self)
while not self.process_queue.empty():
current = self.process_queue.get()
if self.visit(current):
stopping = await self.matches_any_stop_condition(current)
await self.apply_step_actions(current, stopping)
if not stopping:
self.queue_next(current, self)
await self.traverse_branches() | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/traversals/branch_recursive_tracing.py | branch_recursive_tracing.py |
from typing import Dict, List
from zepben.evolve import SinglePhaseKind, PhaseCode, NominalPhasePath
__all__ = ["straight_phase_connectivity", "viable_inferred_phase_connectivity"]
# noinspection PyArgumentList
_STRAIGHT_PHASE_PATHS = {
SinglePhaseKind.A: NominalPhasePath(SinglePhaseKind.A, SinglePhaseKind.A),
SinglePhaseKind.B: NominalPhasePath(SinglePhaseKind.B, SinglePhaseKind.B),
SinglePhaseKind.C: NominalPhasePath(SinglePhaseKind.C, SinglePhaseKind.C),
SinglePhaseKind.N: NominalPhasePath(SinglePhaseKind.N, SinglePhaseKind.N),
SinglePhaseKind.X: NominalPhasePath(SinglePhaseKind.X, SinglePhaseKind.X),
SinglePhaseKind.Y: NominalPhasePath(SinglePhaseKind.Y, SinglePhaseKind.Y),
}
_KNOWN_PHASE_CODES = [pc for pc in PhaseCode if any(it in PhaseCode.ABC.single_phases for it in pc.single_phases) or (pc == PhaseCode.N)]
_UNKNOWN_PHASE_CODES = [pc for pc in PhaseCode if any(it in PhaseCode.XY.single_phases for it in pc.single_phases)]
straight_phase_connectivity: Dict[PhaseCode, Dict[PhaseCode, List[NominalPhasePath]]] = {
from_phases: {
to_phases: [
_STRAIGHT_PHASE_PATHS[phase] for phase in from_phases.single_phases if phase in to_phases.single_phases
] for to_phases in _KNOWN_PHASE_CODES
} for from_phases in _KNOWN_PHASE_CODES
}
straight_phase_connectivity.update({
from_phases: {
to_phases: [
_STRAIGHT_PHASE_PATHS[phase] for phase in from_phases.single_phases if phase in to_phases.single_phases
] for to_phases in _UNKNOWN_PHASE_CODES
} for from_phases in _UNKNOWN_PHASE_CODES
})
viable_inferred_phase_connectivity: Dict[PhaseCode, Dict[PhaseCode, Dict[SinglePhaseKind, List[SinglePhaseKind]]]] = {
PhaseCode.XY: {
PhaseCode.ABC: {SinglePhaseKind.X: [SinglePhaseKind.A, SinglePhaseKind.B, SinglePhaseKind.C],
SinglePhaseKind.Y: [SinglePhaseKind.B, SinglePhaseKind.C]},
PhaseCode.AB: {SinglePhaseKind.X: [SinglePhaseKind.A, SinglePhaseKind.B], SinglePhaseKind.Y: [SinglePhaseKind.B]},
PhaseCode.AC: {SinglePhaseKind.X: [SinglePhaseKind.A, SinglePhaseKind.C], SinglePhaseKind.Y: [SinglePhaseKind.C]},
PhaseCode.BC: {SinglePhaseKind.X: [SinglePhaseKind.B, SinglePhaseKind.C], SinglePhaseKind.Y: [SinglePhaseKind.B, SinglePhaseKind.C]},
PhaseCode.A: {SinglePhaseKind.X: [SinglePhaseKind.A]},
PhaseCode.B: {SinglePhaseKind.X: [SinglePhaseKind.B], SinglePhaseKind.Y: [SinglePhaseKind.B]},
PhaseCode.C: {SinglePhaseKind.X: [SinglePhaseKind.C], SinglePhaseKind.Y: [SinglePhaseKind.C]}
},
PhaseCode.X: {
PhaseCode.ABC: {SinglePhaseKind.X: [SinglePhaseKind.A, SinglePhaseKind.B, SinglePhaseKind.C]},
PhaseCode.AB: {SinglePhaseKind.X: [SinglePhaseKind.A, SinglePhaseKind.B]},
PhaseCode.AC: {SinglePhaseKind.X: [SinglePhaseKind.A, SinglePhaseKind.C]},
PhaseCode.BC: {SinglePhaseKind.X: [SinglePhaseKind.B, SinglePhaseKind.C]},
PhaseCode.A: {SinglePhaseKind.X: [SinglePhaseKind.A]},
PhaseCode.B: {SinglePhaseKind.X: [SinglePhaseKind.B]},
PhaseCode.C: {SinglePhaseKind.X: [SinglePhaseKind.C]}
},
PhaseCode.Y: {
PhaseCode.ABC: {SinglePhaseKind.Y: [SinglePhaseKind.B, SinglePhaseKind.C]},
PhaseCode.AB: {SinglePhaseKind.Y: [SinglePhaseKind.B]},
PhaseCode.AC: {SinglePhaseKind.Y: [SinglePhaseKind.C]},
PhaseCode.BC: {SinglePhaseKind.Y: [SinglePhaseKind.B, SinglePhaseKind.C]},
PhaseCode.A: {},
PhaseCode.B: {SinglePhaseKind.Y: [SinglePhaseKind.B]},
PhaseCode.C: {SinglePhaseKind.Y: [SinglePhaseKind.C]}
}
} | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/connectivity/phase_paths.py | phase_paths.py |
from typing import Set, Optional
from zepben.evolve import Terminal, PowerTransformer, SinglePhaseKind, ConnectivityResult, NominalPhasePath
from zepben.evolve.services.network.tracing.connectivity.transformer_phase_paths import transformer_phase_paths
__all__ = ["TerminalConnectivityInternal"]
class TerminalConnectivityInternal:
"""
Helper class for finding the paths through equipment.
"""
def between(
self,
terminal: Terminal,
other_terminal: Terminal,
include_phases: Optional[Set[SinglePhaseKind]] = None
) -> ConnectivityResult:
"""
* Find the connectivity between the two terminals. The function assumes they are on the same conducting equipment.
*
* @param terminal The terminal you are moving from
* @param other_terminal The terminal you are moving to
* @param include_phases The nominal phases on the [terminal] you want to use.
*
* @return The connectivity between [terminal] and [other_terminal]. If the conducting equipment is a power transformer the nominal phase paths may
* contain an entry with the 'from' phase set to NONE and the 'to' phase set to N, indicating a neutral has been added by the transformer1.
"""
if include_phases is None:
include_phases = set(terminal.phases.single_phases)
if isinstance(terminal.conducting_equipment, PowerTransformer):
return self._transformer_terminal_connectivity(terminal, other_terminal, include_phases)
return self._straight_terminal_connectivity(terminal, other_terminal, include_phases)
@staticmethod
def _transformer_terminal_connectivity(
terminal: Terminal,
other_terminal: Terminal,
include_phases: Set[SinglePhaseKind]
) -> ConnectivityResult:
paths = [it for it in transformer_phase_paths.get(terminal.phases, {}).get(other_terminal.phases, [])
if (it.from_phase in include_phases) or (it.from_phase == SinglePhaseKind.NONE)]
return ConnectivityResult(terminal, other_terminal, paths)
@staticmethod
def _straight_terminal_connectivity(
terminal: Terminal,
other_terminal: Terminal,
include_phases: Set[SinglePhaseKind]
) -> ConnectivityResult:
# noinspection PyArgumentList
paths = [NominalPhasePath(it, it) for it in set(terminal.phases.single_phases).intersection(set(other_terminal.phases.single_phases))
if it in include_phases]
return ConnectivityResult(terminal, other_terminal, paths) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/connectivity/terminal_connectivity_internal.py | terminal_connectivity_internal.py |
from typing import Dict, List
from zepben.evolve import SinglePhaseKind as Phase, NominalPhasePath, PhaseCode
__all__ = ["transformer_phase_paths"]
def _path(from_phase: Phase, to_phase: Phase) -> NominalPhasePath:
# noinspection PyArgumentList
return NominalPhasePath(from_phase, to_phase)
# This is used to indicate that a transformer adds a neutral, and it should be energised from the transformer.
_add_neutral = _path(Phase.NONE, Phase.N)
transformer_phase_paths: Dict[PhaseCode, Dict[PhaseCode, List[NominalPhasePath]]] = {
PhaseCode.ABCN: {
PhaseCode.ABCN: [_path(Phase.A, Phase.A), _path(Phase.B, Phase.B), _path(Phase.C, Phase.C), _path(Phase.N, Phase.N)],
PhaseCode.ABC: [_path(Phase.A, Phase.A), _path(Phase.B, Phase.B), _path(Phase.C, Phase.C)]
},
PhaseCode.AN: {
PhaseCode.AN: [_path(Phase.A, Phase.A), _path(Phase.N, Phase.N)],
PhaseCode.XN: [_path(Phase.A, Phase.X), _path(Phase.N, Phase.N)],
PhaseCode.AB: [_path(Phase.A, Phase.A), _path(Phase.NONE, Phase.B)],
PhaseCode.XY: [_path(Phase.A, Phase.X), _path(Phase.NONE, Phase.Y)],
PhaseCode.X: [_path(Phase.A, Phase.X)],
PhaseCode.A: [_path(Phase.A, Phase.A)],
},
PhaseCode.BN: {
PhaseCode.BN: [_path(Phase.B, Phase.B), _path(Phase.N, Phase.N)],
PhaseCode.XN: [_path(Phase.B, Phase.X), _path(Phase.N, Phase.N)],
PhaseCode.BC: [_path(Phase.B, Phase.B), _path(Phase.NONE, Phase.C)],
PhaseCode.XY: [_path(Phase.B, Phase.X), _path(Phase.NONE, Phase.Y)],
PhaseCode.B: [_path(Phase.B, Phase.B)],
PhaseCode.X: [_path(Phase.B, Phase.X)],
},
PhaseCode.CN: {
PhaseCode.CN: [_path(Phase.C, Phase.C), _path(Phase.N, Phase.N)],
PhaseCode.XN: [_path(Phase.C, Phase.X), _path(Phase.N, Phase.N)],
PhaseCode.AC: [_path(Phase.C, Phase.C), _path(Phase.NONE, Phase.A)],
PhaseCode.XY: [_path(Phase.C, Phase.X), _path(Phase.NONE, Phase.Y)],
PhaseCode.C: [_path(Phase.C, Phase.C)],
PhaseCode.X: [_path(Phase.C, Phase.X)],
},
PhaseCode.XN: {
PhaseCode.AN: [_path(Phase.X, Phase.A), _path(Phase.N, Phase.N)],
PhaseCode.BN: [_path(Phase.X, Phase.B), _path(Phase.N, Phase.N)],
PhaseCode.CN: [_path(Phase.X, Phase.C), _path(Phase.N, Phase.N)],
PhaseCode.XN: [_path(Phase.X, Phase.X), _path(Phase.N, Phase.N)],
PhaseCode.AB: [_path(Phase.X, Phase.A), _path(Phase.NONE, Phase.B)],
PhaseCode.BC: [_path(Phase.X, Phase.B), _path(Phase.NONE, Phase.C)],
PhaseCode.AC: [_path(Phase.X, Phase.C), _path(Phase.NONE, Phase.A)],
PhaseCode.XY: [_path(Phase.X, Phase.X), _path(Phase.NONE, Phase.Y)],
PhaseCode.A: [_path(Phase.X, Phase.A)],
PhaseCode.B: [_path(Phase.X, Phase.B)],
PhaseCode.C: [_path(Phase.X, Phase.C)],
PhaseCode.X: [_path(Phase.X, Phase.X)],
},
PhaseCode.ABC: {
PhaseCode.ABCN: [_path(Phase.A, Phase.A), _path(Phase.B, Phase.B), _path(Phase.C, Phase.C), _add_neutral],
PhaseCode.ABC: [_path(Phase.A, Phase.A), _path(Phase.B, Phase.B), _path(Phase.C, Phase.C)],
},
PhaseCode.AB: {
PhaseCode.AN: [_path(Phase.A, Phase.A), _add_neutral],
PhaseCode.XN: [_path(Phase.A, Phase.X), _add_neutral],
PhaseCode.AB: [_path(Phase.A, Phase.A), _path(Phase.B, Phase.B)],
PhaseCode.XY: [_path(Phase.A, Phase.X), _path(Phase.B, Phase.Y)],
PhaseCode.A: [_path(Phase.A, Phase.A)],
PhaseCode.X: [_path(Phase.A, Phase.X)],
},
PhaseCode.BC: {
PhaseCode.BN: [_path(Phase.B, Phase.B), _add_neutral],
PhaseCode.XN: [_path(Phase.B, Phase.X), _add_neutral],
PhaseCode.BC: [_path(Phase.B, Phase.B), _path(Phase.C, Phase.C)],
PhaseCode.XY: [_path(Phase.B, Phase.X), _path(Phase.C, Phase.Y)],
PhaseCode.B: [_path(Phase.B, Phase.B)],
PhaseCode.X: [_path(Phase.B, Phase.X)],
},
PhaseCode.AC: {
PhaseCode.CN: [_path(Phase.C, Phase.C), _add_neutral],
PhaseCode.XN: [_path(Phase.C, Phase.X), _add_neutral],
PhaseCode.AC: [_path(Phase.A, Phase.A), _path(Phase.C, Phase.C)],
PhaseCode.XY: [_path(Phase.A, Phase.X), _path(Phase.C, Phase.Y)],
PhaseCode.C: [_path(Phase.C, Phase.C)],
PhaseCode.X: [_path(Phase.C, Phase.X)],
},
PhaseCode.XY: {
PhaseCode.AN: [_path(Phase.X, Phase.A), _add_neutral],
PhaseCode.BN: [_path(Phase.X, Phase.B), _add_neutral],
PhaseCode.CN: [_path(Phase.X, Phase.C), _add_neutral],
PhaseCode.XN: [_path(Phase.X, Phase.X), _add_neutral],
PhaseCode.AB: [_path(Phase.X, Phase.A), _path(Phase.Y, Phase.B)],
PhaseCode.BC: [_path(Phase.X, Phase.B), _path(Phase.Y, Phase.C)],
PhaseCode.AC: [_path(Phase.X, Phase.A), _path(Phase.Y, Phase.C)],
PhaseCode.XY: [_path(Phase.X, Phase.X), _path(Phase.Y, Phase.Y)],
PhaseCode.A: [_path(Phase.X, Phase.A)],
PhaseCode.B: [_path(Phase.X, Phase.B)],
PhaseCode.C: [_path(Phase.X, Phase.C)],
PhaseCode.X: [_path(Phase.X, Phase.X)],
},
PhaseCode.A: {
PhaseCode.AN: [_path(Phase.A, Phase.A), _add_neutral],
PhaseCode.XN: [_path(Phase.A, Phase.X), _add_neutral],
PhaseCode.AB: [_path(Phase.A, Phase.A), _path(Phase.NONE, Phase.B)],
PhaseCode.XY: [_path(Phase.A, Phase.X), _path(Phase.NONE, Phase.Y)],
PhaseCode.A: [_path(Phase.A, Phase.A)],
PhaseCode.X: [_path(Phase.A, Phase.X)],
},
PhaseCode.B: {
PhaseCode.BN: [_path(Phase.B, Phase.B), _add_neutral],
PhaseCode.XN: [_path(Phase.B, Phase.X), _add_neutral],
PhaseCode.BC: [_path(Phase.B, Phase.B), _path(Phase.NONE, Phase.C)],
PhaseCode.XY: [_path(Phase.B, Phase.X), _path(Phase.NONE, Phase.Y)],
PhaseCode.B: [_path(Phase.B, Phase.B)],
PhaseCode.X: [_path(Phase.B, Phase.X)],
},
PhaseCode.C: {
PhaseCode.CN: [_path(Phase.C, Phase.C), _add_neutral],
PhaseCode.XN: [_path(Phase.C, Phase.X), _add_neutral],
PhaseCode.AC: [_path(Phase.C, Phase.C), _path(Phase.NONE, Phase.A)],
PhaseCode.XY: [_path(Phase.C, Phase.X), _path(Phase.NONE, Phase.Y)],
PhaseCode.C: [_path(Phase.C, Phase.C)],
PhaseCode.X: [_path(Phase.C, Phase.X)],
},
PhaseCode.X: {
PhaseCode.AN: [_path(Phase.X, Phase.A), _add_neutral],
PhaseCode.BN: [_path(Phase.X, Phase.B), _add_neutral],
PhaseCode.CN: [_path(Phase.X, Phase.C), _add_neutral],
PhaseCode.XN: [_path(Phase.X, Phase.X), _add_neutral],
PhaseCode.AB: [_path(Phase.X, Phase.A), _path(Phase.NONE, Phase.B)],
PhaseCode.BC: [_path(Phase.X, Phase.B), _path(Phase.NONE, Phase.C)],
PhaseCode.AC: [_path(Phase.X, Phase.C), _path(Phase.NONE, Phase.A)],
PhaseCode.XY: [_path(Phase.X, Phase.X), _path(Phase.NONE, Phase.Y)],
PhaseCode.A: [_path(Phase.X, Phase.A)],
PhaseCode.B: [_path(Phase.X, Phase.B)],
PhaseCode.C: [_path(Phase.X, Phase.C)],
PhaseCode.X: [_path(Phase.X, Phase.X)],
},
} | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/connectivity/transformer_phase_paths.py | transformer_phase_paths.py |
from __future__ import annotations
from operator import attrgetter
from typing import List, Optional, Tuple, TYPE_CHECKING
from dataclassy import dataclass
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
from zepben.evolve.model.phases import NominalPhasePath
if TYPE_CHECKING:
pass
__all__ = ["ConnectivityResult", "terminal_compare"]
def terminal_compare(terminal: Terminal, other: Terminal):
"""
This definition should only be used for sorting within a `zepben.evolve.traversals.queue.PriorityQueue`
`terminal` The terminal to compare
`other` The terminal to compare against
Returns True if `terminal` has more phases than `other`, False otherwise.
"""
return terminal.phases.num_phases > other.phases.num_phases
Terminal.__lt__ = terminal_compare
@dataclass(slots=True, init=False)
class ConnectivityResult(object):
"""
Stores the connectivity between two terminals, including the mapping between the nominal phases.
This class is intended to be used in an immutable way. You should avoid modifying it after it has been created.
"""
from_terminal: Terminal
"""The terminal from which the connectivity was requested."""
to_terminal: Terminal
"""The terminal which is connected to the requested terminal."""
nominal_phase_paths: Tuple[NominalPhasePath]
"""The mapping of nominal phase paths between the from and to terminals."""
def __init__(self, from_terminal: Terminal, to_terminal: Terminal, nominal_phase_paths: List[NominalPhasePath]):
self.nominal_phase_paths = tuple(sorted(nominal_phase_paths, key=attrgetter('from_phase', 'to_phase')))
self.from_terminal = from_terminal
self.to_terminal = to_terminal
def __eq__(self, other: ConnectivityResult):
if self is other:
return True
# noinspection PyBroadException
try:
return self.from_terminal is other.from_terminal and self.to_terminal is other.to_terminal and self.nominal_phase_paths != other.nominal_phase_paths
except Exception:
return False
def __ne__(self, other):
if self is other:
return False
# noinspection PyBroadException
try:
return self.from_terminal is not other.from_terminal \
or self.to_terminal is not other.to_terminal \
or self.nominal_phase_paths != other.nominal_phase_paths
except Exception:
return True
def __str__(self):
return (f"ConnectivityResult(from_terminal={self.from_equip.mrid}-t{self.from_terminal.sequence_number}"
f", to_terminal={self.to_equip.mrid}-t{self.to_terminal.sequence_number}, core_paths={self.nominal_phase_paths})")
def __hash__(self):
res = self.from_terminal.mrid.__hash__()
res = 31 * res + self.to_terminal.mrid.__hash__()
res = 31 * res + self.nominal_phase_paths.__hash__()
return res
@property
def from_equip(self) -> Optional[ConductingEquipment]:
"""The conducting equipment that owns the `from_terminal."""
return self.from_terminal.conducting_equipment
@property
def to_equip(self) -> Optional[ConductingEquipment]:
"""The conducting equipment that owns the `to_terminal`."""
return self.to_terminal.conducting_equipment
@property
def from_nominal_phases(self) -> List[SinglePhaseKind]:
"""The nominal phases that are connected in the `from_terminal`."""
return [npp.from_phase for npp in self.nominal_phase_paths]
@property
def to_nominal_phases(self) -> List[SinglePhaseKind]:
"""The nominal phases that are connected in the `to_terminal`."""
return [npp.to_phase for npp in self.nominal_phase_paths] | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/connectivity/connectivity_result.py | connectivity_result.py |
from typing import List, Iterable, Optional, Set, Dict, Callable
from zepben.evolve import Terminal, PhaseCode, SinglePhaseKind, NominalPhasePath, Queue, LifoQueue, Switch
from zepben.evolve.services.network.tracing.connectivity.connectivity_result import ConnectivityResult
from zepben.evolve.services.network.tracing.connectivity.xy_candidate_phase_paths import XyCandidatePhasePaths
from zepben.evolve.services.network.tracing.connectivity.xy_phase_step import XyPhaseStep
from zepben.evolve.services.network.tracing.connectivity.phase_paths import viable_inferred_phase_connectivity, straight_phase_connectivity
__all__ = ["TerminalConnectivityConnected"]
class TerminalConnectivityConnected(object):
_create_candidate_phases: Callable[[], XyCandidatePhasePaths]
def __init__(self, create_candidate_phases: Callable[[], XyCandidatePhasePaths] = lambda: XyCandidatePhasePaths()):
self._create_candidate_phases = create_candidate_phases
def connected_terminals(
self,
terminal: Terminal,
phases: Optional[Iterable[SinglePhaseKind]] = None
) -> List[ConnectivityResult]:
phases = set(phases or terminal.phases.single_phases)
include_phases = phases.intersection(terminal.phases.single_phases)
connectivity_node = terminal.connectivity_node
if connectivity_node is None:
return []
results = []
for connected_terminal in connectivity_node.terminals:
if connected_terminal != terminal:
cr = self._terminal_connectivity(terminal, connected_terminal, include_phases)
if cr.nominal_phase_paths:
results.append(cr)
return results
def _terminal_connectivity(
self,
terminal: Terminal,
connected_terminal: Terminal,
include_phases: Set[SinglePhaseKind]
) -> ConnectivityResult:
return ConnectivityResult(
from_terminal=terminal,
to_terminal=connected_terminal,
nominal_phase_paths=[
path for path in (
self._find_straight_phase_paths(terminal, connected_terminal)
or self._find_xy_phase_paths(terminal, connected_terminal)
or []) if (path.from_phase in include_phases) and (path.to_phase in connected_terminal.phases)
]
)
@staticmethod
def _find_straight_phase_paths(terminal: Terminal, connected_terminal: Terminal) -> Optional[List[NominalPhasePath]]:
paths = straight_phase_connectivity[terminal.phases]
return paths and paths.get(connected_terminal.phases)
def _find_xy_phase_paths(self, terminal: Terminal, connected_terminal: Terminal) -> Optional[List[NominalPhasePath]]:
xy_phases = _find_xy_phases(terminal)
connected_xy_phases = _find_xy_phases(connected_terminal)
if (_is_none(xy_phases) and _is_none(connected_xy_phases)) or (_is_not_none(xy_phases) and _is_not_none(connected_xy_phases)):
return None
nominal_phase_paths = []
if SinglePhaseKind.N in terminal.phases and SinglePhaseKind.N in connected_terminal.phases:
# noinspection PyArgumentList
nominal_phase_paths.append(NominalPhasePath(SinglePhaseKind.N, SinglePhaseKind.N))
def add_from_to(from_phase, to_phase):
# noinspection PyArgumentList
nominal_phase_paths.append(NominalPhasePath(from_phase, to_phase))
def add_to_from(from_phase, to_phase):
# noinspection PyArgumentList
nominal_phase_paths.append(NominalPhasePath(to_phase, from_phase))
if _is_not_none(xy_phases):
self._add_xy_phase_paths(terminal, add_from_to)
else:
self._add_xy_phase_paths(terminal, add_to_from)
return nominal_phase_paths
def _add_xy_phase_paths(self, terminal: Terminal, add_path: Callable[[SinglePhaseKind, SinglePhaseKind], None]):
"""
val xyPhases = cn.terminals.associateWith { it.findXyPhases() }.filterValues { it.isNotNone() }
val primaryPhases = cn.terminals.associateWith { it.findPrimaryPhases() }.filterValues { it.isNotNone() }
findXyCandidatePhases(xyPhases, primaryPhases).apply {
calculatePaths()
.asSequence()
.filter { (_, to) -> to != SPK.NONE }
.filter { (from, to) -> (from in terminal.phases.singlePhases) || (to in terminal.phases.singlePhases) }
.forEach { (from, to) -> addPath(from, to) }
}
"""
cn = terminal.connectivity_node
xy_phases = {it: _find_xy_phases(it) for it in cn.terminals if _is_not_none(_find_xy_phases(it))}
primary_phases = {it: _find_primary_phases(it) for it in cn.terminals if _is_not_none(_find_primary_phases(it))}
candidate_phases = self._find_xy_candidate_phases(xy_phases, primary_phases)
for from_phase, to_phase in candidate_phases.calculate_paths().items():
if (to_phase != SinglePhaseKind.NONE) and ((from_phase in terminal.phases.single_phases) or (to_phase in terminal.phases.single_phases)):
add_path(from_phase, to_phase)
def _find_xy_candidate_phases(self, xy_phases: Dict[Terminal, PhaseCode], primary_phases: Dict[Terminal, PhaseCode]) -> XyCandidatePhasePaths:
queue = LifoQueue()
visited = set()
candidate_phases = self._create_candidate_phases()
for terminal, xy_phase_code in xy_phases.items():
for primary_phase_code in primary_phases.values():
for phase, candidates in viable_inferred_phase_connectivity.get(xy_phase_code, {}).get(primary_phase_code, {}).items():
candidate_phases.add_candidates(phase, candidates)
# noinspection PyArgumentList
self._find_more_xy_candidate_phases(XyPhaseStep(terminal, xy_phase_code), visited, queue, candidate_phases)
while not queue.empty():
self._find_more_xy_candidate_phases(queue.get(), visited, queue, candidate_phases)
return candidate_phases
def _find_more_xy_candidate_phases(
self,
step: XyPhaseStep,
visited: Set[XyPhaseStep],
queue: Queue[XyPhaseStep],
candidate_phases: XyCandidatePhasePaths
):
if step in visited:
return
visited.add(step)
without_neutral = step.terminal.phases.without_neutral
if (SinglePhaseKind.X in without_neutral) or (SinglePhaseKind.Y in without_neutral):
if not self._check_traced_phases(step, candidate_phases):
self._queue_next(step.terminal, without_neutral, queue)
else:
for (phase, candidates) in viable_inferred_phase_connectivity.get(step.phase_code, {}).get(without_neutral, {}).items():
candidate_phases.add_candidates(phase, candidates)
@staticmethod
def _check_traced_phases(step: XyPhaseStep, candidate_phases: XyCandidatePhasePaths) -> bool:
found_traced = False
normal_x = step.terminal.normal_phases[SinglePhaseKind.X]
if normal_x != SinglePhaseKind.NONE:
candidate_phases.add_known(SinglePhaseKind.X, normal_x)
found_traced = True
normal_y = step.terminal.normal_phases[SinglePhaseKind.Y]
if normal_y != SinglePhaseKind.NONE:
candidate_phases.add_known(SinglePhaseKind.Y, normal_y)
found_traced = True
return found_traced
@staticmethod
def _queue_next(terminal: Terminal, phase_code: PhaseCode, queue: Queue[XyPhaseStep]):
ce = terminal.conducting_equipment
if not ce:
return
if not isinstance(ce, Switch) or not ce.is_normally_open:
for other in ce.terminals:
if (other != terminal) and other.connectivity_node:
for connected in other.connectivity_node.terminals:
if connected.conducting_equipment != ce:
# noinspection PyArgumentList
queue.put(XyPhaseStep(connected, phase_code))
def _find_xy_phases(terminal: Terminal):
if (terminal.phases == PhaseCode.XY) or (terminal.phases == PhaseCode.XYN):
return PhaseCode.XY
elif (terminal.phases == PhaseCode.X) or (terminal.phases == PhaseCode.XN):
return PhaseCode.X
elif (terminal.phases == PhaseCode.Y) or (terminal.phases == PhaseCode.YN):
return PhaseCode.Y
else:
return PhaseCode.NONE
def _find_primary_phases(terminal: Terminal):
if (terminal.phases == PhaseCode.ABC) or (terminal.phases == PhaseCode.ABCN):
return PhaseCode.ABC
elif (terminal.phases == PhaseCode.AB) or (terminal.phases == PhaseCode.ABN):
return PhaseCode.AB
elif (terminal.phases == PhaseCode.AC) or (terminal.phases == PhaseCode.ACN):
return PhaseCode.AC
elif (terminal.phases == PhaseCode.BC) or (terminal.phases == PhaseCode.BCN):
return PhaseCode.BC
elif (terminal.phases == PhaseCode.A) or (terminal.phases == PhaseCode.AN):
return PhaseCode.A
elif (terminal.phases == PhaseCode.B) or (terminal.phases == PhaseCode.BN):
return PhaseCode.B
elif (terminal.phases == PhaseCode.C) or (terminal.phases == PhaseCode.CN):
return PhaseCode.C
else:
return PhaseCode.NONE
def _is_none(phase_code: PhaseCode) -> bool:
return phase_code == PhaseCode.NONE
def _is_not_none(phase_code: PhaseCode) -> bool:
return phase_code != PhaseCode.NONE | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/connectivity/terminal_connectivity_connected.py | terminal_connectivity_connected.py |
from collections import Counter
from itertools import takewhile
from typing import List, Dict, Tuple, Optional, Counter as CounterType
from dataclassy import dataclass
from zepben.evolve import SinglePhaseKind, PhaseCode
__all__ = ["X_PRIORITY", "Y_PRIORITY", "XyCandidatePhasePaths", "is_before", "is_after"]
X_PRIORITY = [SinglePhaseKind.A, SinglePhaseKind.B, SinglePhaseKind.C]
"""
The pathing priority for nominal phase X
"""
Y_PRIORITY = [SinglePhaseKind.C, SinglePhaseKind.B]
"""
The pathing priority for nominal phase X
"""
def is_before(phase: SinglePhaseKind, before: Optional[SinglePhaseKind]) -> bool:
if (before is None) or (before == SinglePhaseKind.NONE):
return True
elif before == SinglePhaseKind.A:
return False
elif before == SinglePhaseKind.B:
return phase == SinglePhaseKind.A
elif before == SinglePhaseKind.C:
return (phase == SinglePhaseKind.A) or (phase == SinglePhaseKind.B)
else:
raise ValueError("INTERNAL ERROR: is_before should only ever be checking against valid Y phases. If you get this message you need to ask the dev "
"team to go put the planets back into alignment as they stuffed something up!")
def is_after(phase: SinglePhaseKind, after: Optional[SinglePhaseKind]) -> bool:
if (after is None) or (after == SinglePhaseKind.NONE):
return True
elif after == SinglePhaseKind.C:
return False
elif after == SinglePhaseKind.B:
return phase == SinglePhaseKind.C
elif after == SinglePhaseKind.A:
return (phase == SinglePhaseKind.C) or (phase == SinglePhaseKind.B)
else:
raise ValueError("INTERNAL ERROR: is_after should only ever be checking against valid X phases. If you get this message you need to ask the dev "
"team to go put the planets back into alignment as they stuffed something up!")
@dataclass(slots=True)
class XyCandidatePhasePaths:
"""
Used to track the candidate and know paths for XY phase connectivity.
"""
_known_tracking: Dict[SinglePhaseKind, SinglePhaseKind] = {}
"""
Map of nominal phase to known phase.
"""
_candidate_tracking: Dict[SinglePhaseKind, List[SinglePhaseKind]] = {}
"""
Map of nominal phase to list of candidate phases.
"""
def add_known(self, xy_phase: SinglePhaseKind, known_phase: SinglePhaseKind):
"""
Add a `known_phase` for the specified `xy_phase`. If there is already a `known_phase` the new value will be ignored.
`xy_phase` The phase that is being tracked.
`known_phase` The phase that should be allocated to the tracked phase.
Raises `NominalPhaseException` if the `xy_phase` is invalid.
"""
_validate_for_tracking(xy_phase)
if xy_phase not in self._known_tracking:
self._known_tracking[xy_phase] = known_phase
def add_candidates(self, xy_phase: SinglePhaseKind, candidate_phases: List[SinglePhaseKind]):
"""
Add `candidate_phases` for the specified `xy_phase`. If the same candidate has been found from more than
one path it should be added multiple times
`xy_phase` The phase that is being tracked.
`candidate_phases` The phases that could be allocated to the tracked phase.
Raises `NominalPhaseException` if the `xy_phase` is invalid.
Raises `PhaseException` if the `candidate_phases` is invalid.
"""
_validate_for_tracking(xy_phase)
if xy_phase not in self._candidate_tracking:
self._candidate_tracking[xy_phase] = []
self._candidate_tracking[xy_phase].extend([it for it in candidate_phases if _is_valid_candidate(it, xy_phase)])
def calculate_paths(self) -> Dict[SinglePhaseKind, SinglePhaseKind]:
"""
Calculate the paths for the tracked phases taking into account the following:
1. Known phases take preference.
2. X is always a "lower" phase than Y.
3. If multiple candidates are valid then the one with the most occurrences will be chosen.
4. If multiple candidates are valid and are equally common, the phases will be chosen with the following priority maintaining the above rules:
X: A, B then C
Y: C then B
"""
paths = {}
known_x = self._known_tracking.get(SinglePhaseKind.X)
if known_x is not None:
paths[SinglePhaseKind.X] = known_x
known_y = self._known_tracking.get(SinglePhaseKind.Y)
if (known_y is not None) and (known_x != known_y):
paths[SinglePhaseKind.Y] = known_y
else:
known_y = None
if (known_x is not None) and (known_y is not None):
return paths
candidate_phase_counts = {xy: Counter(candidates) for xy, candidates in self._candidate_tracking.items()}
if known_x is not None:
candidates = candidate_phase_counts.get(SinglePhaseKind.Y)
if candidates:
paths[SinglePhaseKind.Y] = self._find_candidate(candidates, priority=Y_PRIORITY, after=known_x)
else:
paths[SinglePhaseKind.Y] = SinglePhaseKind.NONE
elif known_y is not None:
candidates = candidate_phase_counts.get(SinglePhaseKind.X)
if candidates:
paths[SinglePhaseKind.X] = self._find_candidate(candidates, priority=X_PRIORITY, before=known_y)
else:
paths[SinglePhaseKind.X] = SinglePhaseKind.NONE
else:
x_candidate, y_candidate = self._process_candidates(candidate_phase_counts)
paths[SinglePhaseKind.X] = x_candidate
paths[SinglePhaseKind.Y] = y_candidate
return paths
def _process_candidates(self, candidate_phase_counts: Dict[SinglePhaseKind, CounterType[SinglePhaseKind]]) -> Tuple[SinglePhaseKind, SinglePhaseKind]:
candidate_x_counts = candidate_phase_counts.get(SinglePhaseKind.X, Counter())
candidate_y_counts = candidate_phase_counts.get(SinglePhaseKind.Y, Counter())
if not candidate_x_counts:
return SinglePhaseKind.NONE, self._find_candidate(candidate_y_counts, priority=Y_PRIORITY)
elif len(candidate_x_counts) == 1:
x_candidate = list(candidate_x_counts.keys())[0]
return x_candidate, self._find_candidate(candidate_y_counts, priority=Y_PRIORITY, after=x_candidate)
elif not candidate_y_counts:
return self._find_candidate(candidate_x_counts, priority=X_PRIORITY), SinglePhaseKind.NONE
elif len(candidate_y_counts) == 1:
y_candidate = list(candidate_y_counts.keys())[0]
return self._find_candidate(candidate_x_counts, priority=X_PRIORITY, before=y_candidate), y_candidate
else:
x_candidate = self._find_candidate(candidate_x_counts, priority=X_PRIORITY)
y_candidate = self._find_candidate(candidate_y_counts, priority=Y_PRIORITY)
if is_before(x_candidate, y_candidate):
return x_candidate, y_candidate
elif candidate_x_counts[x_candidate] > candidate_y_counts[y_candidate]:
return x_candidate, self._find_candidate(candidate_y_counts, priority=Y_PRIORITY, after=x_candidate)
elif candidate_y_counts[y_candidate] > candidate_x_counts[x_candidate]:
return self._find_candidate(candidate_x_counts, priority=X_PRIORITY, before=y_candidate), y_candidate
else:
x_candidate2 = self._find_candidate(candidate_x_counts, priority=X_PRIORITY, before=y_candidate)
y_candidate2 = self._find_candidate(candidate_y_counts, priority=Y_PRIORITY, after=x_candidate)
if x_candidate2 == SinglePhaseKind.NONE:
return x_candidate, y_candidate2
elif y_candidate2 == SinglePhaseKind.NONE:
return x_candidate2, y_candidate
elif candidate_x_counts[x_candidate2] > candidate_y_counts[y_candidate2]:
return x_candidate2, y_candidate
elif candidate_y_counts[y_candidate2] > candidate_x_counts[x_candidate2]:
return x_candidate, y_candidate2
else:
return x_candidate, y_candidate2
@staticmethod
def _find_candidate(
candidate_counts: CounterType[SinglePhaseKind],
priority: List[SinglePhaseKind],
before: Optional[SinglePhaseKind] = None,
after: Optional[SinglePhaseKind] = None
) -> SinglePhaseKind:
valid_candidates = [(phase, count) for (phase, count) in candidate_counts.most_common() if is_before(phase, before) and is_after(phase, after)]
if not valid_candidates:
return SinglePhaseKind.NONE
elif len(valid_candidates) == 1:
return valid_candidates[0][0]
candidates = list(takewhile(lambda cand: cand[1] == valid_candidates[0][1], valid_candidates))
if len(candidates) == 1:
return candidates[0][0]
for phase in priority:
for candidate, _ in candidates:
if candidate == phase:
return candidate
raise ValueError("INTERNAL ERROR: If you get here it means you did not limit the candidates to only valid phases, go fix that!")
def _validate_for_tracking(phase: SinglePhaseKind):
if phase not in PhaseCode.XY:
raise ValueError(f"Unable to track phase {phase}, expected X or Y.")
def _is_valid_candidate(phase: SinglePhaseKind, xy_phase: SinglePhaseKind) -> bool:
if xy_phase == SinglePhaseKind.X:
return _is_valid_candidate_x(phase)
else:
return _is_valid_candidate_y(phase)
def _is_valid_candidate_x(phase: SinglePhaseKind) -> bool:
if phase in PhaseCode.ABC:
return True
else:
raise ValueError(f"Unable to use phase {phase} as a candidate, expected A, B or C.")
def _is_valid_candidate_y(phase: SinglePhaseKind) -> bool:
if phase in PhaseCode.BC:
return True
else:
raise ValueError(f"Unable to use phase {phase} as a candidate, expected B or C.") | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/connectivity/xy_candidate_phase_paths.py | xy_candidate_phase_paths.py |
from typing import Set, Callable, Optional, Awaitable, Any
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
from zepben.evolve.model.cim.iec61970.base.core.equipment_container import Feeder, EquipmentContainer
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.model.cim.iec61970.base.wires.power_transformer import PowerTransformer
from zepben.evolve.services.network.network_service import NetworkService
from zepben.evolve.services.network.tracing.feeder.associated_terminal_trace import new_normal_trace, new_current_trace, get_associated_terminals
from zepben.evolve.services.network.tracing.traversals.traversal import Traversal
__all__ = ["AssignToFeeders"]
class AssignToFeeders:
"""
Convenience class that provides methods for assigning feeders on a `NetworkService`.
Requires that a Feeder have a normalHeadTerminal with associated ConductingEquipment.
This class is backed by a `BasicTraversal`.
"""
def __init__(self, _normal_traversal: Optional[Traversal[Terminal]] = None, _current_traversal: Optional[Traversal[Terminal]] = None):
self._normal_traversal: Traversal[Terminal] = _normal_traversal if _normal_traversal is not None else new_normal_trace()
"""
The traversal used to trace the network in its normal state of the network.
"""
self._current_traversal: Traversal[Terminal] = _current_traversal if _current_traversal is not None else new_current_trace()
"""
The traversal used to trace the network in its current state of the network.
"""
self._active_feeder: Optional[Feeder] = None # This will never be optional by the time it is used.
"""
The feeder that is currently being processed.
"""
self._normal_traversal.add_step_action(self._process_normal)
self._current_traversal.add_step_action(self._process_current)
async def run(self, network: NetworkService):
"""
Assign equipment to each feeder in the specified network.
:param network: The network containing the feeders to process
"""
feeder_start_points = set()
for feeder in network.objects(Feeder):
if feeder.normal_head_terminal:
if feeder.normal_head_terminal.conducting_equipment:
feeder_start_points.add(feeder.normal_head_terminal.conducting_equipment)
self._configure_stop_conditions(self._normal_traversal, feeder_start_points)
self._configure_stop_conditions(self._current_traversal, feeder_start_points)
for feeder in network.objects(Feeder):
await self.run_feeder(feeder)
async def run_feeder(self, feeder: Feeder):
"""
Assign equipment to the specified feeders by tracing from the head terminal.
:param feeder: The feeder to trace.
"""
self._active_feeder = feeder
if not feeder.normal_head_terminal:
return
await self._run_from_head_terminal(self._normal_traversal, feeder.normal_head_terminal)
await self._run_from_head_terminal(self._current_traversal, feeder.normal_head_terminal)
@staticmethod
async def _run_from_head_terminal(traversal: Traversal, head_terminal: Terminal):
traversal.reset()
traversal.tracker.visit(head_terminal)
await traversal.apply_step_actions(head_terminal, False)
traversal.process_queue.extend(get_associated_terminals(head_terminal))
await traversal.trace()
def _configure_stop_conditions(self, traversal: Traversal, feeder_start_points: Set[ConductingEquipment]):
traversal.clear_stop_conditions()
traversal.add_stop_condition(self._reached_equipment(feeder_start_points))
traversal.add_stop_condition(self._reached_substation_transformer)
@staticmethod
def _reached_equipment(ce: Set[ConductingEquipment]) -> Callable[[Terminal], Awaitable[bool]]:
async def check_reached(t: Terminal) -> bool:
return t.conducting_equipment in ce
return check_reached
@staticmethod
async def _reached_substation_transformer(t: Terminal) -> bool:
return isinstance(t.conducting_equipment, PowerTransformer) and t.conducting_equipment.num_substations()
async def _process_normal(self, terminal: Terminal, is_stopping: bool):
self._process(terminal.conducting_equipment, terminal.conducting_equipment.add_container, self._active_feeder.add_equipment, is_stopping)
async def _process_current(self, terminal: Terminal, is_stopping: bool):
self._process(terminal.conducting_equipment, terminal.conducting_equipment.add_current_feeder, self._active_feeder.add_current_equipment, is_stopping)
def _process(
self,
ce: Optional[ConductingEquipment],
assign_feeder_to_equip: Callable[[EquipmentContainer], Any],
assign_equip_to_feeder: Callable[[ConductingEquipment], Any],
is_stopping: bool
):
if is_stopping and isinstance(ce, PowerTransformer):
return
if ce:
assign_feeder_to_equip(self._active_feeder)
assign_equip_to_feeder(ce) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/feeder/assign_to_feeders.py | assign_to_feeders.py |
__all__ = ["normal_direction", "current_direction", "DirectionStatus", "NormalDirection", "CurrentDirection"]
from abc import ABC, abstractmethod
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.services.network.tracing.feeder.feeder_direction import FeederDirection
def normal_direction(terminal: Terminal):
return NormalDirection(terminal)
def current_direction(terminal: Terminal):
return CurrentDirection(terminal)
class DirectionStatus(ABC):
"""
Interface to query or set the `FeederDirection` for a `Terminal`.
"""
@abstractmethod
def value(self) -> FeederDirection:
"""
Returns The direction added to this status.
"""
raise NotImplementedError()
@abstractmethod
def set(self, direction: FeederDirection) -> bool:
"""
Clears the existing direction and sets it to the specified direction.
`direction` The direction of the `Terminal`.
Returns True if the direction has been updated, otherwise False.
"""
raise NotImplementedError
@abstractmethod
def add(self, direction: FeederDirection) -> bool:
"""
Adds the given direction to the `Terminal`.
`direction` The direction to add to the `Terminal`.
Returns True if the direction has been updated, otherwise False.
"""
raise NotImplementedError
@abstractmethod
def remove(self, direction: FeederDirection) -> bool:
"""
Removes the given direction from the `Terminal`.
`direction` The direction to remove from the `Terminal`.
Returns True if the direction has been updated, otherwise False.
"""
raise NotImplementedError
class NormalDirection(DirectionStatus):
def __init__(self, terminal: Terminal):
self.terminal = terminal
def value(self) -> FeederDirection:
return self.terminal.normal_feeder_direction
def set(self, direction: FeederDirection) -> bool:
if self.terminal.normal_feeder_direction == direction:
return False
self.terminal.normal_feeder_direction = direction
return True
def add(self, direction: FeederDirection) -> bool:
previous = self.terminal.normal_feeder_direction
new = previous + direction
if new == previous:
return False
self.terminal.normal_feeder_direction = new
return True
def remove(self, direction: FeederDirection) -> bool:
previous = self.terminal.normal_feeder_direction
new = previous - direction
if new == previous:
return False
self.terminal.normal_feeder_direction = new
return True
class CurrentDirection(DirectionStatus):
def __init__(self, terminal: Terminal):
self.terminal = terminal
def value(self) -> FeederDirection:
return self.terminal.current_feeder_direction
def set(self, direction: FeederDirection) -> bool:
if self.terminal.current_feeder_direction == direction:
return False
self.terminal.current_feeder_direction = direction
return True
def add(self, direction: FeederDirection) -> bool:
previous = self.terminal.current_feeder_direction
new = previous + direction
if new == previous:
return False
self.terminal.current_feeder_direction = new
return True
def remove(self, direction: FeederDirection) -> bool:
previous = self.terminal.current_feeder_direction
new = previous - direction
if new == previous:
return False
self.terminal.current_feeder_direction = new
return True | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/feeder/direction_status.py | direction_status.py |
from typing import List, Callable
from zepben.evolve import BranchRecursiveTraversal, Terminal, FifoQueue, Tracker, NetworkService, Feeder, FeederDirection, normally_open, \
currently_open, current_direction, normal_direction
from zepben.evolve.types import OpenTest, DirectionSelector
__all__ = ["SetDirection"]
class SetDirection:
"""
Convenience class that provides methods for setting feeder direction on a [NetworkService]
This class is backed by a [BranchRecursiveTraversal].
"""
def __init__(self) -> None:
super().__init__()
# noinspection PyArgumentList
self.normal_traversal: BranchRecursiveTraversal[Terminal] = BranchRecursiveTraversal(
queue_next=lambda terminal, traversal: self._set_downstream_and_queue_next(traversal, terminal, normally_open, normal_direction),
process_queue=FifoQueue(),
tracker=Tracker(),
branch_queue=FifoQueue()
)
"""
The [BranchRecursiveTraversal] used when tracing the normal state of the network.
NOTE: If you add stop conditions to this traversal it may no longer work correctly, use at your own risk.
"""
# noinspection PyArgumentList
self.current_traversal: BranchRecursiveTraversal[Terminal] = BranchRecursiveTraversal(
queue_next=lambda terminal, traversal: self._set_downstream_and_queue_next(traversal, terminal, currently_open, current_direction),
process_queue=FifoQueue(),
tracker=Tracker(),
branch_queue=FifoQueue()
)
"""
The [BranchRecursiveTraversal] used when tracing the current state of the network.
NOTE: If you add stop conditions to this traversal it may no longer work correctly, use at your own risk.
"""
async def run(self, network: NetworkService):
"""
Apply feeder directions from all feeder head terminals in the network.
:param network: The network in which to apply feeder directions.
"""
await self._run_terminals([f.normal_head_terminal for f in network.objects(Feeder) if f.normal_head_terminal])
async def run_terminal(self, terminal: Terminal):
"""
Apply [FeederDirection.DOWNSTREAM] from the [terminal].
:param terminal: The terminal to start applying feeder direction from.
"""
await self._run_terminals([terminal])
async def _run_terminals(self, start_terminals: List[Terminal]):
self.normal_traversal.tracker.clear()
self.current_traversal.tracker.clear()
for t in start_terminals:
await self.normal_traversal.reset().trace(t)
await self.current_traversal.reset().trace(t)
def _set_downstream_and_queue_next(
self,
traversal: BranchRecursiveTraversal[Terminal],
terminal: Terminal,
open_test: OpenTest,
direction_selector: DirectionSelector
):
direction = direction_selector(terminal)
if not direction.add(FeederDirection.DOWNSTREAM):
return
connected = [t for t in terminal.connectivity_node or [] if t != terminal]
processor = self._flow_upstream_and_queue_next_straight if len(connected) == 1 else self._flow_upstream_and_queue_next_branch
for t in connected:
# noinspection PyArgumentList
processor(traversal, t, open_test, direction_selector)
@staticmethod
def _is_feeder_head_terminal(terminal: Terminal) -> bool:
ce = terminal.conducting_equipment
if not ce:
return False
return any(f.normal_head_terminal == terminal for f in ce.containers if isinstance(f, Feeder))
def _flow_upstream_and_queue_next_straight(
self,
traversal: BranchRecursiveTraversal[Terminal],
terminal: Terminal,
open_test: OpenTest,
direction_selector: DirectionSelector
):
if not traversal.tracker.visit(terminal):
return
if terminal.conducting_equipment and (terminal.conducting_equipment.num_terminals() == 2):
self._flow_upstream_and_queue_next(terminal, open_test, direction_selector, traversal.process_queue.put)
else:
self._flow_upstream_and_queue_next(terminal, open_test, direction_selector, lambda it: self._start_new_branch(traversal, it))
def _flow_upstream_and_queue_next_branch(
self,
traversal: BranchRecursiveTraversal[Terminal],
terminal: Terminal,
open_test: OpenTest,
direction_selector: DirectionSelector
):
# We don't want to visit the upstream terminal if we have branched as it prevents the downstream path of a loop processing correctly, but we
# still need to make sure we don't re-visit the upstream terminal.
if traversal.has_visited(terminal):
return
self._flow_upstream_and_queue_next(terminal, open_test, direction_selector, lambda it: self._start_new_branch(traversal, it))
def _flow_upstream_and_queue_next(
self,
terminal: Terminal,
open_test: OpenTest,
direction_selector: DirectionSelector,
queue: Callable[[Terminal], None]
):
direction = direction_selector(terminal)
if not direction.add(FeederDirection.UPSTREAM):
return
if self._is_feeder_head_terminal(terminal):
return
ce = terminal.conducting_equipment
if not ce:
return
if open_test(ce, None):
return
for t in ce.terminals:
if t != terminal:
queue(t)
@staticmethod
def _start_new_branch(traversal: BranchRecursiveTraversal[Terminal], terminal: Terminal):
branch = traversal.create_branch()
branch.start_item = terminal
traversal.branch_queue.put(branch) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/feeder/set_direction.py | set_direction.py |
from dataclassy import dataclass
from zepben.evolve import FifoQueue, Tracker, normal_direction, BranchRecursiveTraversal, current_direction, NetworkService, Terminal, FeederDirection
from zepben.evolve.types import DirectionSelector
__all__ = ["RemoveDirection"]
@dataclass(slots=True)
class TerminalDirection:
"""
A terminal linked with a direction
"""
terminal: Terminal
direction_to_ebb: FeederDirection
class RemoveDirection:
"""
Convenience class that provides methods for removing feeder direction on a [NetworkService]
This class is backed by a [BranchRecursiveTraversal].
"""
def __init__(self) -> None:
super().__init__()
# noinspection PyArgumentList
self.normal_traversal: BranchRecursiveTraversal[TerminalDirection] = BranchRecursiveTraversal(
queue_next=lambda current, traversal: self._ebb_and_queue(traversal, current, normal_direction),
process_queue=FifoQueue(),
tracker=Tracker(),
branch_queue=FifoQueue()
)
"""
The [BranchRecursiveTraversal] used when tracing the normal state of the network.
NOTE: If you add stop conditions to this traversal it may no longer work correctly, use at your own risk.
"""
# noinspection PyArgumentList
self.current_traversal: BranchRecursiveTraversal[TerminalDirection] = BranchRecursiveTraversal(
queue_next=lambda current, traversal: self._ebb_and_queue(traversal, current, current_direction),
process_queue=FifoQueue(),
tracker=Tracker(),
branch_queue=FifoQueue()
)
"""
The [BranchRecursiveTraversal] used when tracing the current state of the network.
NOTE: If you add stop conditions to this traversal it may no longer work correctly, use at your own risk.
"""
@staticmethod
def run(network_service: NetworkService):
"""
Remove all feeder directions from the specified network.
:param network_service: The network service to remove feeder directions from.
"""
for terminal in network_service.objects(Terminal):
terminal.normal_feeder_direction = FeederDirection.NONE
terminal.current_feeder_direction = FeederDirection.NONE
async def run_terminal(self, terminal: Terminal, direction: FeederDirection = FeederDirection.NONE):
"""
Allows the removal of feeder direction from a terminal and the connected equipment chain.
:param terminal: The terminal from which to start the direction removal.
:param direction: The feeder direction to remove. Defaults to all present directions. Specifying [FeederDirection.BOTH] will cause all directions
to be cleared from all connected equipment.
"""
await self._run_from_terminal(self.normal_traversal, TerminalDirection(terminal, self._validate_direction(direction, terminal.normal_feeder_direction)))
await self._run_from_terminal(self.current_traversal, TerminalDirection(terminal, self._validate_direction(direction, terminal.current_feeder_direction)))
@staticmethod
async def _run_from_terminal(traversal: BranchRecursiveTraversal[TerminalDirection], start: TerminalDirection):
await traversal.reset().trace(start)
def _ebb_and_queue(self, traversal: BranchRecursiveTraversal[TerminalDirection], current: TerminalDirection, direction_selector: DirectionSelector):
if not direction_selector(current.terminal).remove(current.direction_to_ebb):
return
other_terminals = [t for t in current.terminal.connectivity_node or [] if t != current.terminal]
if current.direction_to_ebb == FeederDirection.BOTH:
for other in other_terminals:
if direction_selector(other).remove(FeederDirection.BOTH):
self._queue_if_required(traversal, other, FeederDirection.BOTH, direction_selector)
else:
#
# Check the number of other terminals with same direction:
# 0: remove opposite direction from all other terminals.
# 1: remove opposite direction from only the matched terminal.
# 2+: do not queue or remove anything else as everything is still valid.
#
opposite_direction = self._find_opposite(current.direction_to_ebb)
matching_terminals = [t for t in other_terminals if direction_selector(t).value().has(current.direction_to_ebb)]
if not matching_terminals:
for other in other_terminals:
if direction_selector(other).remove(opposite_direction):
self._queue_if_required(traversal, other, opposite_direction, direction_selector)
for other in other_terminals:
traversal.process_queue.put(TerminalDirection(other, opposite_direction))
elif len(matching_terminals) == 1:
match = matching_terminals[0]
if direction_selector(match).remove(opposite_direction):
self._queue_if_required(traversal, match, opposite_direction, direction_selector)
def _queue_if_required(
self,
traversal: BranchRecursiveTraversal[TerminalDirection],
terminal: Terminal,
direction_ebbed: FeederDirection,
direction_selector: DirectionSelector
):
ce = terminal.conducting_equipment
if not ce:
return
other_terminals = [t for t in ce.terminals if t != terminal]
if direction_ebbed == FeederDirection.BOTH:
for other in other_terminals:
traversal.process_queue.put(TerminalDirection(other, direction_ebbed))
else:
#
# Check the number of other terminals with same direction:
# 0: remove opposite direction from all other terminals.
# 1: remove opposite direction from only the matched terminal.
# 2+: do not queue or remove anything else as everything is still valid.
#
opposite_direction = self._find_opposite(direction_ebbed)
matching_terminals = [t for t in other_terminals if direction_selector(t).value().has(direction_ebbed)]
if not matching_terminals:
for other in other_terminals:
traversal.process_queue.put(TerminalDirection(other, opposite_direction))
elif len(matching_terminals) == 1:
traversal.process_queue.put(TerminalDirection(matching_terminals[0], opposite_direction))
@staticmethod
def _validate_direction(direction: FeederDirection, default: FeederDirection) -> FeederDirection:
if direction == FeederDirection.NONE:
return default
return direction
@staticmethod
def _find_opposite(direction: FeederDirection) -> FeederDirection:
# This will never be called for NONE or BOTH.
if direction == FeederDirection.UPSTREAM:
return FeederDirection.DOWNSTREAM
return FeederDirection.UPSTREAM | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/feeder/remove_direction.py | remove_direction.py |
from typing import Callable, Optional, Set, List
from zepben.evolve import LifoQueue
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
from zepben.evolve.services.network.tracing.feeder.associated_terminal_tracker import AssociatedTerminalTracker
from zepben.evolve.services.network.tracing.traversals.traversal import Traversal
from zepben.evolve.services.network.tracing.util import ignore_open, normally_open, currently_open
__all__ = ["new_normal_trace", "new_current_trace", "new_trace", "get_associated_terminals", "queue_next_terminal_if_closed"]
def new_trace(open_test: Callable[[ConductingEquipment, Optional[SinglePhaseKind]], bool] = ignore_open):
# noinspection PyArgumentList
return Traversal(queue_next=queue_next_terminal_if_closed(open_test), process_queue=LifoQueue(), tracker=AssociatedTerminalTracker())
def new_normal_trace() -> Traversal:
return new_trace(normally_open)
def new_current_trace() -> Traversal:
return new_trace(currently_open)
def get_associated_terminals(terminal: Terminal, exclude: Set[Terminal] = None) -> List[Terminal]:
"""
Gets all associated `zepben.evolve.model.cim.iec61970.base.core.terminal.Terminal`s for `terminal`.
Associated terminals include every other `Terminal` on `terminal`s `connectivity_node`.
`terminal` The `zepben.evolve.model.cim.iec61970.base.core.terminal.Terminal` to use for associations.
`exclude` A set of `Terminal`s to exclude from the result.
Returns the list of `Terminal`s associated with `terminal`
"""
if exclude is None:
exclude = set()
if terminal.connectivity_node is not None:
return [term for term in terminal.connectivity_node.terminals if term is not terminal and term not in exclude]
else:
return []
def queue_next_terminal_if_closed(
open_test: Callable[[ConductingEquipment, Optional[SinglePhaseKind]], bool]
) -> Callable[[Terminal, Traversal[Terminal]], None]:
"""
Creates a queue next function based on the given `open_test` that given a `zepben.evolve.model.cim.iec61970.base.core.terminal.Terminal` where all its
`phases` are closed, will return all its associated `Terminal`s for queuing as per `get_associated_terminals`.
`open_test` Function that tests whether a given phase on an equipment is open.
Returns the queuing function to be used to populate a `zepben.evolve.services.network.tracing.traversals.tracing.Traversal`s `process_queue`.
"""
def queue_next(terminal: Terminal, traversal: Traversal[Terminal]):
if terminal is not None:
if terminal.conducting_equipment is not None:
# Stop only if all phases are open.
if any(not open_test(terminal.conducting_equipment, phase) for phase in terminal.phases.single_phases):
for term in terminal.conducting_equipment.terminals:
if terminal is not term:
traversal.process_queue.extend(get_associated_terminals(term))
return queue_next | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/feeder/associated_terminal_trace.py | associated_terminal_trace.py |
from __future__ import annotations
from typing import TYPE_CHECKING, Optional, List, Set
from zepben.evolve.services.network.network_service import connected_terminals
from zepben.evolve.exceptions import TracingException
from zepben.evolve.services.network.tracing.feeder.feeder_direction import FeederDirection
from zepben.evolve.services.network.tracing.traversals.queue import PriorityQueue
from zepben.evolve.services.network.tracing.traversals.branch_recursive_tracing import BranchRecursiveTraversal
if TYPE_CHECKING:
from zepben.evolve import ConductingEquipment, Terminal, SinglePhaseKind
from zepben.evolve.types import OpenTest, DirectionSelector
__all__ = ["DownstreamTree"]
def _queue_connected_terminals(traversal: BranchRecursiveTraversal[TreeNode],
current: TreeNode,
down_terminal: Terminal,
down_phases: Set[SinglePhaseKind]):
# Get all the terminals connected to terminals with phases going out
up_terminals = connected_terminals(down_terminal, down_phases)
# Make sure we do not loop back out the incoming terminal if its direction is both.
if current.parent and any(term.to_equip == current.parent.conducting_equipment for term in up_terminals):
return
fork = len(up_terminals) > 1 or down_terminal.conducting_equipment.num_terminals() > 2
for equip in (term.to_equip for term in up_terminals if term.to_equip):
next_node = TreeNode(equip, current)
if not traversal.has_visited(next_node):
current.add_child(next_node)
if fork:
branch = traversal.create_branch()
branch.start_item = next_node
traversal.branch_queue.put(branch)
else:
traversal.process_queue.put(next_node)
class DownstreamTree(object):
def __init__(self, open_test: OpenTest, direction_selector: DirectionSelector):
self._open_test = open_test
self._direction_selector = direction_selector
# noinspection PyArgumentList
self._traversal = BranchRecursiveTraversal(queue_next=self._add_and_queue_next,
process_queue=PriorityQueue(),
branch_queue=PriorityQueue())
def _add_and_queue_next(self, current: Optional[TreeNode], traversal: BranchRecursiveTraversal[TreeNode]):
# Loop through each of the terminals on the current conducting equipment
if current is None:
return
for term in current.conducting_equipment.terminals:
# Find all the nominal phases which are going out
down_phases = self._get_down_phases(term)
if down_phases:
_queue_connected_terminals(traversal, current, term, down_phases)
def _get_down_phases(self, terminal: Terminal) -> Set[SinglePhaseKind]:
direction = self._direction_selector(terminal).value()
if not direction.has(FeederDirection.DOWNSTREAM):
return set()
conducting_equipment = terminal.conducting_equipment
if conducting_equipment is None:
raise TracingException(f"Missing conducting equipment for terminal {terminal.mrid}.")
return set(filter(lambda phase: not self._open_test(conducting_equipment, phase), terminal.phases.single_phases))
class TreeNode(object):
def __init__(self, conducting_equipment: ConductingEquipment, parent: Optional[TreeNode]):
self.conducting_equipment = conducting_equipment
self.parent = parent
self._children: List[TreeNode] = []
self._sort_weight = max((len(term.phases.single_phases) for term in conducting_equipment.terminals), default=1)
def __lt__(self, other: TreeNode):
"""
This definition should only be used for sorting within a `zepben.evolve.tracing.queue.PriorityQueue`
@param other: Another PhaseStep to compare against
@return: True if this node's max phase count over its equipment's terminals is greater than the other's, False otherwise.
"""
return self._sort_weight > other._sort_weight
def __str__(self):
return f"{{conducting_equipment: {self.conducting_equipment.mrid}, parent: {self.parent and self.parent.conducting_equipment.mrid}, " \
f"num children: {len(self._children)}}}"
def add_child(self, child: TreeNode):
self._children.append(child) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/network/tracing/tree/downstream_tree.py | downstream_tree.py |
from typing import Dict, List
from zepben.evolve.model.cim.iec61970.base.diagramlayout.diagram_layout import DiagramObject
from zepben.evolve.services.common.base_service import BaseService
__all__ = ["DiagramService"]
class DiagramService(BaseService):
name: str = "diagram"
_diagram_objects_by_diagram_mrid: Dict[str, Dict[str, DiagramObject]] = dict()
_diagram_objects_by_identified_object_mrid: Dict[str, Dict[str, DiagramObject]] = dict()
_diagram_object_indexes: List[Dict[str, Dict[str, DiagramObject]]] = list()
def __init__(self):
self._diagram_object_indexes.append(self._diagram_objects_by_identified_object_mrid)
self._diagram_object_indexes.append(self._diagram_objects_by_diagram_mrid)
def get_diagram_objects(self, mrid: str) -> List[DiagramObject]:
"""
Get `DiagramObject`'s from the service associated with the given mRID.
`DiagramObject`'s are indexed by its `DiagramObject.mrid`, its `DiagramObject.diagram.mrid`,
and its `DiagramObject.identifiedObjectMRID`'s (if present).
If you request a `DiagramObject` by its mRID you will receive a List with a single entry, otherwise
the list will contain as many `DiagramObject`'s as have been recorded against the provided mRID.
`mrid` The mRID to look up in the service.
Returns A list of `DiagramObject`'s associated with `mrid`.
"""
obj = self.get(mrid, DiagramObject, None)
if obj is not None:
return [obj]
for index in self._diagram_object_indexes:
if mrid in index:
return list(index[mrid].values())
return []
def add_diagram_object(self, diagram_object: DiagramObject):
"""
Associate a `DiagramObject` with this service.
The `DiagramObject` will be indexed by its `Diagram` and its `IdentifiedObject` (if present).
`diagram_object` The `DiagramObject` to add.
Returns True if the `DiagramObject` was successfully associated with the service.
"""
return self.add(diagram_object) and self._add_index(diagram_object)
def remove(self, diagram_object: DiagramObject) -> bool:
"""
Disassociate a `DiagramObject` with the service. This will remove all indexing of the `DiagramObject` and it
will no longer be able to be found via the service.
`diagram_object` The `DiagramObject` to disassociate with this service.
Returns True if the `DiagramObject` was removed successfully.
"""
return super(DiagramService, self).remove(diagram_object) and self._remove_index(diagram_object)
def _add_index(self, diagram_object: DiagramObject) -> bool:
"""
Index a `DiagramObject` against its associated [Diagram] and [IdentifiedObject].
`diagram_object` The `DiagramObject` to remove from the indexes.
Returns True if the index was updated.
"""
if diagram_object.diagram:
self._diagram_objects_by_diagram_mrid.setdefault(diagram_object.diagram.mrid, dict())[diagram_object.mrid] = diagram_object
io_mrid = diagram_object.identified_object_mrid
if io_mrid:
self._diagram_objects_by_identified_object_mrid.setdefault(io_mrid, dict())[diagram_object.mrid] = diagram_object
return True
def _remove_index(self, diagram_object: DiagramObject) -> bool:
"""
Remove the indexes of a `DiagramObject`.
`diagram_object` The `DiagramObject` to remove from the indexes.
Returns True if the index was updated.
"""
if diagram_object.diagram.mrid:
diagram_map = self._diagram_objects_by_diagram_mrid[diagram_object.diagram.mrid]
if diagram_map is not None:
del diagram_map[diagram_object.mrid]
if not diagram_map:
del self._diagram_objects_by_diagram_mrid[diagram_object.diagram.mrid]
io_mrid = diagram_object.identified_object_mrid
if io_mrid is not None:
io_map = self._diagram_objects_by_identified_object_mrid[io_mrid]
if io_map is not None:
del io_map[diagram_object.mrid]
if not io_map:
del self._diagram_objects_by_identified_object_mrid[io_mrid]
return True | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/diagram/diagrams.py | diagrams.py |
from zepben.protobuf.cim.iec61970.base.diagramlayout.DiagramObjectPoint_pb2 import DiagramObjectPoint as PBDiagramObjectPoint
from zepben.protobuf.cim.iec61970.base.diagramlayout.DiagramObject_pb2 import DiagramObject as PBDiagramObject
from zepben.protobuf.cim.iec61970.base.diagramlayout.Diagram_pb2 import Diagram as PBDiagram
import zepben.evolve.services.common.resolver as resolver
from zepben.evolve import identified_object_to_cim, OrientationKind, DiagramStyle
from zepben.evolve.model.cim.iec61970.base.diagramlayout.diagram_layout import Diagram, DiagramObject, DiagramObjectPoint
from zepben.evolve.services.diagram.diagrams import DiagramService
__all__ = ["diagram_object_point_to_cim", "diagram_to_cim", "diagram_object_to_cim"]
################################
# IEC61970 BASE DIAGRAM LAYOUT #
################################
def diagram_to_cim(pb: PBDiagram, service: DiagramService):
cim = Diagram(
mrid=pb.mrid(),
orientation_kind=OrientationKind(pb.orientationKind),
diagram_style=DiagramStyle(pb.diagramStyle)
)
for mrid in pb.diagramObjectMRIDs:
service.resolve_or_defer_reference(resolver.diagram_objects(cim), mrid)
identified_object_to_cim(pb.io, cim, service)
return cim if service.add(cim) else None
def diagram_object_to_cim(pb: PBDiagramObject, service: DiagramService):
cim = DiagramObject(
mrid=pb.mrid(),
identified_object_mrid=pb.identifiedObjectMRID if pb.identifiedObjectMRID else None,
style=pb.diagramObjectStyle if pb.diagramObjectStyle else None,
rotation=pb.rotation,
)
service.resolve_or_defer_reference(resolver.diagram(cim), pb.diagramMRID)
for point in pb.diagramObjectPoints:
cim.add_point(diagram_object_point_to_cim(point))
identified_object_to_cim(pb.io, cim, service)
return cim if service.add_diagram_object(cim) else None
def diagram_object_point_to_cim(pb: PBDiagramObjectPoint) -> DiagramObjectPoint:
# noinspection PyArgumentList
return DiagramObjectPoint(pb.xPosition, pb.yPosition)
PBDiagram.to_cim = diagram_to_cim
PBDiagramObject.to_cim = diagram_object_to_cim
PBDiagramObjectPoint.to_cim = diagram_object_point_to_cim | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/diagram/translator/diagram_proto2cim.py | diagram_proto2cim.py |
from zepben.protobuf.cim.iec61968.common.Agreement_pb2 import Agreement as PBAgreement
from zepben.protobuf.cim.iec61968.customers.CustomerAgreement_pb2 import CustomerAgreement as PBCustomerAgreement
from zepben.protobuf.cim.iec61968.customers.CustomerKind_pb2 import CustomerKind as PBCustomerKind
from zepben.protobuf.cim.iec61968.customers.Customer_pb2 import Customer as PBCustomer
from zepben.protobuf.cim.iec61968.customers.PricingStructure_pb2 import PricingStructure as PBPricingStructure
from zepben.protobuf.cim.iec61968.customers.Tariff_pb2 import Tariff as PBTariff
from zepben.evolve.model.cim.iec61968.common.document import Agreement
from zepben.evolve.model.cim.iec61968.customers.customer import Customer
from zepben.evolve.model.cim.iec61968.customers.customer_agreement import CustomerAgreement
from zepben.evolve.model.cim.iec61968.customers.pricing_structure import PricingStructure
from zepben.evolve.model.cim.iec61968.customers.tariff import Tariff
from zepben.evolve.services.common.translator.base_cim2proto import document_to_pb, organisation_role_to_pb
from zepben.evolve.services.common.translator.util import mrid_or_empty
__all__ = ["agreement_to_pb", "customer_to_pb", "customer_agreement_to_pb", "pricing_structure_to_pb", "tariff_to_pb"]
######################
# IEC61968 CUSTOMERS #
######################
def agreement_to_pb(cim: Agreement) -> PBAgreement:
return PBAgreement(doc=document_to_pb(cim))
def customer_to_pb(cim: Customer) -> PBCustomer:
customer = PBCustomer(
kind=PBCustomerKind.Value(cim.kind.short_name),
customerAgreementMRIDs=[str(io.mrid) for io in cim.agreements]
)
getattr(customer, 'or').CopyFrom(organisation_role_to_pb(cim))
return customer
def customer_agreement_to_pb(cim: CustomerAgreement) -> PBCustomerAgreement:
return PBCustomerAgreement(
agr=agreement_to_pb(cim),
customerMRID=mrid_or_empty(cim.customer),
pricingStructureMRIDs=[str(io.mrid) for io in cim.pricing_structures]
)
def pricing_structure_to_pb(cim: PricingStructure) -> PBPricingStructure:
return PBPricingStructure(
doc=document_to_pb(cim),
tariffMRIDs=[str(io.mrid) for io in cim.tariffs]
)
def tariff_to_pb(cim: Tariff) -> PBTariff:
return PBTariff(doc=document_to_pb(cim))
Agreement.to_pb = agreement_to_pb
Customer.to_pb = customer_to_pb
CustomerAgreement.to_pb = customer_agreement_to_pb
PricingStructure.to_pb = pricing_structure_to_pb
Tariff.to_pb = tariff_to_pb | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/customer/translator/customer_cim2proto.py | customer_cim2proto.py |
from __future__ import annotations
from typing import Optional
from zepben.protobuf.cim.iec61968.common.Agreement_pb2 import Agreement as PBAgreement
from zepben.protobuf.cim.iec61968.customers.CustomerAgreement_pb2 import CustomerAgreement as PBCustomerAgreement
from zepben.protobuf.cim.iec61968.customers.Customer_pb2 import Customer as PBCustomer
from zepben.protobuf.cim.iec61968.customers.PricingStructure_pb2 import PricingStructure as PBPricingStructure
from zepben.protobuf.cim.iec61968.customers.Tariff_pb2 import Tariff as PBTariff
import zepben.evolve.services.common.resolver as resolver
from zepben.evolve import organisation_role_to_cim, document_to_cim, BaseService, CustomerKind
from zepben.evolve.model.cim.iec61968.common.document import Agreement
from zepben.evolve.model.cim.iec61968.customers.customer import Customer
from zepben.evolve.model.cim.iec61968.customers.customer_agreement import CustomerAgreement
from zepben.evolve.model.cim.iec61968.customers.pricing_structure import PricingStructure
from zepben.evolve.model.cim.iec61968.customers.tariff import Tariff
from zepben.evolve.services.customer.customers import CustomerService
__all__ = ["agreement_to_cim", "customer_to_cim", "customer_agreement_to_cim", "pricing_structure_to_cim", "tariff_to_cim"]
######################
# IEC61968 CUSTOMERS #
######################
def agreement_to_cim(pb: PBAgreement, cim: Agreement, service: BaseService):
document_to_cim(pb.doc, cim, service)
def customer_to_cim(pb: PBCustomer, service: CustomerService) -> Optional[Customer]:
cim = Customer(
mrid=pb.mrid(),
kind=CustomerKind(pb.kind)
)
for mrid in pb.customerAgreementMRIDs:
service.resolve_or_defer_reference(resolver.agreements(cim), mrid)
organisation_role_to_cim(getattr(pb, 'or'), cim, service)
return cim if service.add(cim) else None
def customer_agreement_to_cim(pb: PBCustomerAgreement, service: CustomerService) -> Optional[CustomerAgreement]:
cim = CustomerAgreement(mrid=pb.mrid())
service.resolve_or_defer_reference(resolver.customer(cim), pb.customerMRID)
for mrid in pb.pricingStructureMRIDs:
service.resolve_or_defer_reference(resolver.pricing_structures(cim), mrid)
agreement_to_cim(pb.agr, cim, service)
return cim if service.add(cim) else None
def pricing_structure_to_cim(pb: PBPricingStructure, service: CustomerService) -> Optional[PricingStructure]:
cim = PricingStructure(mrid=pb.mrid())
for mrid in pb.tariffMRIDs:
service.resolve_or_defer_reference(resolver.tariffs(cim), mrid)
document_to_cim(pb.doc, cim, service)
return cim if service.add(cim) else None
def tariff_to_cim(pb: PBTariff, service: CustomerService) -> Optional[Tariff]:
# noinspection PyArgumentList
cim = Tariff(mrid=pb.mrid())
document_to_cim(pb.doc, cim, service)
return cim if service.add(cim) else None
PBAgreement.to_cim = agreement_to_cim
PBCustomer.to_cim = customer_to_cim
PBCustomerAgreement.to_cim = customer_agreement_to_cim
PBPricingStructure.to_cim = pricing_structure_to_cim
PBTariff.to_cim = tariff_to_cim | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/customer/translator/customer_proto2cim.py | customer_proto2cim.py |
from __future__ import annotations
from zepben.evolve import AcLineSegment, Asset, AuxiliaryEquipment, ConductingEquipment, Conductor, PowerTransformer, Pole, Streetlight, ConnectivityNode, \
Control, Customer, CustomerAgreement, Diagram, DiagramObject, EndDevice, Equipment, EquipmentContainer, EnergyConsumer, EnergyConsumerPhase, EnergySource, \
EnergySourcePhase, Feeder, GeographicalRegion, Measurement, OperationalRestriction, OrganisationRole, PowerSystemResource, PowerTransformerEnd, \
PricingStructure, RatioTapChanger, RemoteControl, RemoteSource, SubGeographicalRegion, Substation, Terminal, TransformerEnd, UsagePoint, Circuit, Loop, \
PowerElectronicsUnit, PowerElectronicsConnectionPhase, PowerElectronicsConnection, TransformerTankInfo, TransformerEndInfo, PowerTransformerInfo, \
TransformerStarImpedance, ShuntCompensator
from zepben.evolve.services.common.reference_resolvers import *
__all__ = ["per_length_sequence_impedance", "organisation_roles", "at_location", "ae_terminal", "ce_base_voltage", "ce_terminals",
"asset_info", "streetlights", "pole", "cn_terminals", "remote_control", "agreements", "customer",
"pricing_structures", "power_transformer_info",
"diagram_objects", "diagram", "service_location", "ed_usage_points", "containers", "current_feeders",
"operational_restrictions",
"eq_usage_points", "ec_equipment", "ec_phases", "energy_consumer", "es_phases", "energy_source", "current_equipment",
"normal_energizing_substation", "normal_head_terminal", "sub_geographical_regions", "remote_source",
"or_equipment", "organisation",
"psr_location", "ends", "power_transformer", "tariffs", "transformer_end", "control", "measurement",
"geographical_region", "substations",
"normal_energizing_feeders", "sub_geographical_region", "conducting_equipment", "connectivity_node",
"te_base_voltage", "ratio_tap_changer",
"te_terminal", "end_devices", "up_equipment", "usage_point_location", "shunt_compensator_info",
"transformer_end_info", "power_transformer_info_transformer_tank_info", "transformer_star_impedance",
"star_impedance_transformer_end_info", "transformer_end_transformer_star_impedance"]
def per_length_sequence_impedance(ac_line_segment: AcLineSegment):
# noinspection PyArgumentList
return BoundReferenceResolver(ac_line_segment, acls_to_plsi_resolver, None)
def organisation_roles(asset: Asset) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(asset, asset_to_asset_org_role_resolver, None)
def at_location(asset: Asset) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(asset, asset_to_location_resolver, None)
def ae_terminal(auxiliary_equipment: AuxiliaryEquipment) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(auxiliary_equipment, aux_equip_to_term_resolver, None)
def ce_base_voltage(ce: ConductingEquipment) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(ce, cond_equip_to_bv_resolver, None)
def ce_terminals(ce: ConductingEquipment) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(ce, cond_equip_to_terminal_resolver, term_to_ce_resolver)
def asset_info(conductor: Conductor) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(conductor, conductor_to_wire_info_resolver, None)
def power_transformer_info(pt: PowerTransformer) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(pt, powertransformer_to_power_transformer_info_resolver, None)
def shunt_compensator_info(sc: ShuntCompensator) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(sc, shunt_compensator_to_shunt_compensator_info_resolver, None)
def streetlights(p: Pole) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(p, pole_to_streetlight_resolver, streetlight_to_pole_resolver)
def pole(streetlight: Streetlight) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(streetlight, streetlight_to_pole_resolver, pole_to_streetlight_resolver)
def cn_terminals(cn: ConnectivityNode) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(cn, conn_node_to_term_resolver, term_to_cn_resolver)
def remote_control(c: Control) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(c, control_to_remote_control_resolver, rc_to_cont_resolver)
def agreements(c: Customer) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(c, cust_to_custagr_resolver, custagr_to_cust_resolver)
def customer(customer_agreement: CustomerAgreement) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(customer_agreement, custagr_to_cust_resolver, cust_to_custagr_resolver)
def pricing_structures(customer_agreement: CustomerAgreement) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(customer_agreement, custagr_to_ps_resolver, None)
def diagram_objects(d: Diagram) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(d, diag_to_diagobj_resolver, diagobj_to_diag_resolver)
def diagram(diagram_object: DiagramObject) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(diagram_object, diagobj_to_diag_resolver, diag_to_diagobj_resolver)
def service_location(end_device: EndDevice) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(end_device, ed_to_loc_resolver, None)
def ed_usage_points(end_device: EndDevice) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(end_device, ed_to_up_resolver, up_to_ed_resolver)
def containers(equipment: Equipment) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(equipment, eq_to_ec_resolver, ec_to_eq_resolver)
def current_feeders(equipment: Equipment) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(equipment, eq_to_curfeeder_resolver, curfeeder_to_eq_resolver)
def operational_restrictions(equipment: Equipment) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(equipment, eq_to_or_resolver, or_to_eq_resolver)
def eq_usage_points(equipment: Equipment) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(equipment, eq_to_up_resolver, up_to_eq_resolver)
def ec_equipment(equipment_container: EquipmentContainer) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(equipment_container, ec_to_eq_resolver, eq_to_ec_resolver)
def ec_phases(ec: EnergyConsumer) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(ec, ec_to_ecp_resolver, ecp_to_ec_resolver)
def energy_consumer(energy_consumer_phase: EnergyConsumerPhase) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(energy_consumer_phase, ecp_to_ec_resolver, ec_to_ecp_resolver)
def es_phases(es: EnergySource) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(es, es_to_esp_resolver, esp_to_es_resolver)
def energy_source(energy_source_phase: EnergySourcePhase) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(energy_source_phase, esp_to_es_resolver, es_to_esp_resolver)
def current_equipment(feeder: Feeder) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(feeder, curfeeder_to_eq_resolver, eq_to_curfeeder_resolver)
def normal_energizing_substation(feeder: Feeder) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(feeder, feeder_to_nes_resolver, sub_to_feeder_resolver)
def normal_head_terminal(feeder: Feeder) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(feeder, feeder_to_nht_resolver, None)
def sub_geographical_regions(gr: GeographicalRegion) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(gr, gr_to_sgr_resolver, sgr_to_gr_resolver)
def remote_source(m: Measurement) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(m, meas_to_rs_resolver, rs_to_meas_resolver)
def or_equipment(operational_restriction: OperationalRestriction) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(operational_restriction, or_to_eq_resolver, eq_to_or_resolver)
def organisation(organisation_role: OrganisationRole) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(organisation_role, orgr_to_org_resolver, None)
def psr_location(power_system_resource: PowerSystemResource) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(power_system_resource, psr_to_loc_resolver, None)
def ends(pt: PowerTransformer) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(pt, pt_to_pte_resolver, pte_to_pt_resolver)
def power_transformer(power_transformer_end: PowerTransformerEnd) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(power_transformer_end, pte_to_pt_resolver, pt_to_pte_resolver)
def tariffs(pricing_structure: PricingStructure) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(pricing_structure, ps_to_tariff_resolver, None)
def transformer_end(rtt: RatioTapChanger) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(rtt, rtc_to_te_resolver, te_to_rtc_resolver)
def control(rc: RemoteControl) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(rc, rc_to_cont_resolver, control_to_remote_control_resolver)
def measurement(rs: RemoteSource) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(rs, rs_to_meas_resolver, meas_to_rs_resolver)
def geographical_region(sgr: SubGeographicalRegion) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(sgr, sgr_to_gr_resolver, gr_to_sgr_resolver)
def substations(sgr: SubGeographicalRegion) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(sgr, sgr_to_sub_resolver, sub_to_sgr_resolver)
def normal_energizing_feeders(substation: Substation) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(substation, sub_to_feeder_resolver, feeder_to_nes_resolver)
def sub_geographical_region(substation: Substation) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(substation, sub_to_sgr_resolver, sgr_to_sub_resolver)
def circuits(substation: Substation) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(substation, sub_to_circuit_resolver, circuit_to_sub_resolver)
def normal_energized_loops(substation: Substation) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(substation, sub_to_eloop_resolver, loop_to_esub_resolver)
def loops(substation: Substation) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(substation, sub_to_loop_resolver, loop_to_sub_resolver)
def conducting_equipment(terminal: Terminal) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(terminal, term_to_ce_resolver, cond_equip_to_terminal_resolver)
def connectivity_node(terminal: Terminal) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(terminal, term_to_cn_resolver, conn_node_to_term_resolver)
def te_base_voltage(te: TransformerEnd) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(te, te_to_bv_resolver, None)
def ratio_tap_changer(te: TransformerEnd) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(te, te_to_rtc_resolver, rtc_to_te_resolver)
def te_terminal(te: TransformerEnd) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(te, te_to_term_resolver, None)
def end_devices(usage_point: UsagePoint) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(usage_point, up_to_ed_resolver, ed_to_up_resolver)
def up_equipment(usage_point: UsagePoint) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(usage_point, up_to_eq_resolver, eq_to_up_resolver)
def usage_point_location(usage_point: UsagePoint) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(usage_point, up_to_loc_resolver, None)
def loop(circuit: Circuit) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(circuit, circuit_to_loop_resolver, loop_to_circuit_resolver)
def end_terminal(circuit: Circuit) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(circuit, circuit_to_term_resolver, None)
def end_substation(circuit: Circuit) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(circuit, circuit_to_sub_resolver, sub_to_circuit_resolver)
def loop_circuits(l_: Loop) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(l_, loop_to_circuit_resolver, circuit_to_loop_resolver)
def loop_substations(l_: Loop) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(l_, loop_to_sub_resolver, sub_to_loop_resolver)
def loop_energizing_substations(l_: Loop) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(l_, loop_to_esub_resolver, sub_to_eloop_resolver)
def unit_power_electronics_connection(pec: PowerElectronicsUnit) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(pec, peu_to_pec_resolver, pec_to_peu_resolver)
def phase_power_electronics_connection(pec: PowerElectronicsConnectionPhase) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(pec, pecphase_to_pec_resolver, pec_to_pecphase_resolver)
def power_electronics_unit(pec: PowerElectronicsConnection) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(pec, pec_to_peu_resolver, peu_to_pec_resolver)
def power_electronics_connection_phase(pec: PowerElectronicsConnection) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(pec, pec_to_pecphase_resolver, pecphase_to_pec_resolver)
def transformer_end_info(tti: TransformerTankInfo) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(tti, tti_to_tei_resolver, tei_to_tti_resolver)
def transformer_tank_info(tei: TransformerEndInfo) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(tei, tei_to_tti_resolver, tti_to_tei_resolver)
def power_transformer_info_transformer_tank_info(pti: PowerTransformerInfo) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(pti, pti_to_tti_resolver, None)
def transformer_star_impedance(tei: TransformerEndInfo) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(tei, tei_to_tsi_resolver, tsi_to_tei_resolver)
def star_impedance_transformer_end_info(tsi: TransformerStarImpedance) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(tsi, tsi_to_tei_resolver, tei_to_tsi_resolver)
def transformer_end_transformer_star_impedance(te: TransformerEnd) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(te, te_to_tsi_resolver, None)
def energised_end_no_load_tests(tei: TransformerEndInfo) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(tei, tei_to_ee_nlt_resolver, None)
def energised_end_short_circuit_tests(tei: TransformerEndInfo) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(tei, tei_to_ee_sct_resolver, None)
def grounded_end_short_circuit_tests(tei: TransformerEndInfo) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(tei, tei_to_ge_sct_resolver, None)
def open_end_open_circuit_tests(tei: TransformerEndInfo) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(tei, tei_to_oe_oct_resolver, None)
def energised_end_open_circuit_tests(tei: TransformerEndInfo) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(tei, tei_to_ee_oct_resolver, None) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/common/resolver.py | resolver.py |
from __future__ import annotations
from abc import ABCMeta
from collections import OrderedDict
from typing import Dict, Generator, Callable, Optional, List, Union, Sized, Set
from typing import TypeVar, Type
from dataclassy import dataclass
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.model.cim.iec61970.base.core.name_type import NameType
from zepben.evolve.services.common.reference_resolvers import BoundReferenceResolver, UnresolvedReference
__all__ = ["BaseService"]
T = TypeVar("T", bound=IdentifiedObject)
_GET_DEFAULT = (1,)
@dataclass(slots=True)
class BaseService(object, metaclass=ABCMeta):
name: str
_objects_by_type: Dict[type, Dict[str, IdentifiedObject]] = OrderedDict()
_name_types: Dict[str, NameType] = dict()
_unresolved_references_to: Dict[str, Set[UnresolvedReference]] = OrderedDict()
"""
A dictionary of references between mRID's that as yet have not been resolved - typically when transferring services between systems.
The key is the to_mrid of the `UnresolvedReference`s, and the value is a list of `UnresolvedReference`s for that specific object.
For example, if an AcLineSegment with mRID 'acls1' is present in the service, but the service is missing its `location` with mRID 'location-l1'
and `perLengthSequenceImpedance` with mRID 'plsi-1', the following key value pairs would be present:
{
"plsi-1": [
UnresolvedReference(from_ref=AcLineSegment('acls1'),
to_mrid='plsi-1',
resolver=ReferenceResolver(from_class=AcLineSegment, to_class=PerLengthSequenceImpedance, resolve=...), ...)
],
"location-l1": [
UnresolvedReference(from_ref=AcLineSegment('acls1'),
to_mrid='location-l1',
resolver=ReferenceResolver(from_class=AcLineSegment, to_class=Location, resolve=...), ...)
]
}
`resolve` in `ReferenceResolver` will be the function used to populate the relationship between the `IdentifiedObject`s either when
`resolveOrDeferReference() is called if the other side of the reference exists in the service, or otherwise when the second object is added to the service.
"""
_unresolved_references_from: Dict[str, Set[UnresolvedReference]] = OrderedDict()
"""
An index of the unresolved references by their `from_ref.mrid`. For the above example this will be a dictionary of the form:
{
"acls1": [
UnresolvedReference(from_ref=AcLineSegment('acls1'),
to_mrid='location-l1',
resolver=ReferenceResolver(from_class=AcLineSegment, to_class=Location, resolve=...), ...),
UnresolvedReference(from_ref=AcLineSegment('acls1'),
to_mrid='plsi-1',
resolver=ReferenceResolver(from_class=AcLineSegment, to_class=PerLengthSequenceImpedance, resolve=...), ...)
]
}
"""
def __contains__(self, mrid: str) -> bool:
"""
Check if `mrid` has any associated object.
`mrid` The mRID to search for.
Returns True if there is an object associated with the specified `mrid`, False otherwise.
"""
for type_map in self._objects_by_type.values():
if mrid in type_map:
return True
return False
def __str__(self):
return f"{self.__class__.__name__}{f' {self.name}' if self.name else ''}"
def has_unresolved_references(self, mrid: str = None) -> bool:
"""
Check if there are `UnresolvedReference`s in the service
`mrid` The mRID to check for `UnresolvedReference`s. If None, will check if any unresolved references exist in the service.
Returns True if at least one reference exists.
"""
return len(self._unresolved_references_to) > 0 if mrid is None else mrid in self._unresolved_references_to
def len_of(self, t: type = None) -> int:
"""
Get the len of objects of type `t` in the service.
`t` The type of object to get the len of. If None (default), will get the len of all objects in the service.
"""
if t is None:
return sum([len(vals) for vals in self._objects_by_type.values()])
else:
try:
return len(self._objects_by_type[t].values())
except KeyError:
count = 0
for c, obj_map in self._objects_by_type.items():
if issubclass(c, t):
try:
count += len(self._objects_by_type[c].values())
except KeyError:
pass
return count
def num_unresolved_references(self, mrid: str = None):
"""
Get the total number of unresolved references in this service.
`mRID` The mRID to check the number of [UnresolvedReference]s for. If None, will default to number of all unresolved references in the service.
Returns The number of `UnresolvedReference`s.
"""
if mrid is None:
return sum([len(r) for r in self._unresolved_references_to.copy().values()])
elif mrid in self._unresolved_references_to:
return len(self._unresolved_references_to[mrid])
else:
return 0
def unresolved_references(self) -> Generator[UnresolvedReference, None, None]:
"""
Returns a generator over all the `UnresolvedReferences` that are known to this service. This should typically be avoided when resolving references in
favour of `get_unresolved_reference_mrids_by_resolver()`, `get_unresolved_reference_mrids_from()`, and `get_unresolved_reference_mrids_to()`
"""
for unresolved_refs in self._unresolved_references_to.copy().values():
for ur in unresolved_refs:
yield ur
def get(self, mrid: str, type_: Type[T] = IdentifiedObject, default=_GET_DEFAULT,
generate_error: Callable[[str, str], str] = lambda mrid, typ: f"Failed to find {typ}[{mrid}]") -> T:
"""
Get an object associated with this service.
`mrid` The mRID of the `iec61970.base.core.identified_object.IdentifiedObject` to retrieve.
`type_` The `iec61970.base.core.identified_object.IdentifiedObject` subclass type of the object
with `mrid`. If None, will check all types stored in the service.
`default` The default to return if `mrid` can't be found in the service.
`generate_error` Function to call for an error message. Will be passed the mrid and _type (if set).
Returns The `iec61970.base.core.identified_object.IdentifiedObject` associated with `mrid`, or default
if it is set.
Raises `KeyError` if `mrid` was not found in the service with `_type` or if no objects of `_type` are
stored by the service and default was not set.
"""
if not mrid:
raise KeyError("You must specify an mRID to get. Empty/None is invalid.")
# This can be written much simpler than below but we want to avoid throwing any exceptions in this high frequency function
if type_ != IdentifiedObject:
objs = self._objects_by_type.get(type_)
if objs:
obj = objs.get(mrid)
if obj:
return obj
for c, objs in self._objects_by_type.items():
obj = objs.get(mrid)
if obj:
if isinstance(obj, type_):
return obj
else:
raise TypeError(f"Invalid type for {mrid}. Found {type(obj).__name__}, expected {type_.__name__}.")
if default is _GET_DEFAULT:
raise KeyError(generate_error(mrid, type_.__name__))
else:
return default
def __getitem__(self, mrid):
"""
Get an object associated with this service.
Note that you should use `get` directly where the type of the desired object is known.
`mrid` The mRID of the `iec61970.base.core.identified_object.IdentifiedObject` to retrieve.
Returns The `iec61970.base.core.identified_object.IdentifiedObject` associated with `mrid`.
Raises `KeyError` if `mrid` was not found in the service with `type`.
"""
return self.get(mrid)
def add(self, identified_object: IdentifiedObject) -> bool:
"""
Associate an object with this service.
`identified_object` The object to associate with this service.
Returns True if the object is associated with this service, False otherwise.
"""
mrid = identified_object.mrid
if not mrid:
return False
# TODO: Only allow supported types
objs = self._objects_by_type.get(identified_object.__class__, dict())
if mrid in objs:
return objs[mrid] is identified_object
# Check other types and make sure this mRID is unique
for obj_map in self._objects_by_type.values():
if mrid in obj_map:
return False
unresolved_refs = self._unresolved_references_to.get(mrid, None)
if unresolved_refs:
for ref in unresolved_refs:
ref.resolver.resolve(ref.from_ref, identified_object)
if ref.reverse_resolver:
ref.reverse_resolver.resolve(identified_object, ref.from_ref)
self._unresolved_references_from[ref.from_ref.mrid].remove(ref)
if not self._unresolved_references_from[ref.from_ref.mrid]:
del self._unresolved_references_from[ref.from_ref.mrid]
del self._unresolved_references_to[mrid]
objs[mrid] = identified_object
self._objects_by_type[identified_object.__class__] = objs
return True
def resolve_or_defer_reference(self, bound_resolver: BoundReferenceResolver, to_mrid: str) -> bool:
"""
Resolves a property reference between two types by looking up the `to_mrid` in the service and
using the provided `bound_resolver` to resolve the reference relationships (including any reverse relationship).
If the `to_mrid` object has not yet been added to the service, the reference resolution will be deferred until the
object with `to_mrid` is added to the service, which will then use the resolver from the `bound_resolver` at that
time to resolve the reference relationship.
`bound_resolver`
`to_mrid` The MRID of an object that is the subclass of the to_class of `bound_resolver`.
Returns true if the reference was resolved, otherwise false if it has been deferred.
"""
if not to_mrid:
return True
to_mrid = to_mrid
from_ = bound_resolver.from_obj
resolver = bound_resolver.resolver
reverse_resolver = bound_resolver.reverse_resolver
try:
# If to_mrid is present in the service, we resolve any references immediately.
# noinspection PyTypeChecker
to = self.get(to_mrid, resolver.to_class)
resolver.resolve(from_, to)
if reverse_resolver:
reverse_resolver.resolve(to, from_)
# Clean up any reverse resolvers now that the reference has been resolved
if from_.mrid in self._unresolved_references_to:
# noinspection PyArgumentList
to_remove = UnresolvedReference(from_ref=to, to_mrid=from_.mrid, resolver=reverse_resolver)
self._unresolved_references_to[from_.mrid].remove(to_remove)
self._unresolved_references_from[to_remove.from_ref.mrid].remove(to_remove)
if not self._unresolved_references_from[to_remove.from_ref.mrid]:
del self._unresolved_references_from[to_remove.from_ref.mrid]
if not self._unresolved_references_to[from_.mrid]:
del self._unresolved_references_to[from_.mrid]
return True
except KeyError:
# to_mrid didn't exist in the service, populate the reference caches for resolution when it is added.
urefs = self._unresolved_references_to.get(to_mrid, set())
# noinspection PyArgumentList
uref = UnresolvedReference(from_ref=from_, to_mrid=to_mrid, resolver=resolver, reverse_resolver=reverse_resolver)
urefs.add(uref)
self._unresolved_references_to[to_mrid] = urefs
rev_urefs = self._unresolved_references_from.get(from_.mrid, set())
rev_urefs.add(uref)
self._unresolved_references_from[from_.mrid] = rev_urefs
return False
def get_unresolved_reference_mrids_by_resolver(self,
bound_resolvers: Union[BoundReferenceResolver, Sized[BoundReferenceResolver]]) -> Generator[str, None, None]:
"""
Gets a set of MRIDs that are referenced by the from_obj held by `bound_resolver` that are unresolved.
`bound_resolver` The `BoundReferenceResolver` to retrieve unresolved references for.
Returns Set of mRIDs that have unresolved references.
"""
seen = set()
try:
len(bound_resolvers)
resolvers = bound_resolvers
except TypeError:
resolvers = [bound_resolvers]
for resolver in resolvers:
if resolver.from_obj.mrid not in self._unresolved_references_from:
continue
for ref in self._unresolved_references_from[resolver.from_obj.mrid]:
if ref.to_mrid not in seen and ref.resolver == resolver.resolver:
seen.add(ref.to_mrid)
yield ref.to_mrid
def get_unresolved_references_from(self, mrid: str) -> Generator[UnresolvedReference, None, None]:
"""
Get the `UnresolvedReference`s that `mrid` has to other objects.
`mrid` The mRID to get unresolved references for.
Returns a generator over the `UnresolvedReference`s that need to be resolved for `mrid`.
"""
if mrid in self._unresolved_references_from:
for ref in self._unresolved_references_from[mrid]:
yield ref
def get_unresolved_references_to(self, mrid: str) -> Generator[UnresolvedReference, None, None]:
"""
Get the UnresolvedReferences that other objects have to `mrid`.
`mrid` The mRID to fetch unresolved references for that are pointing to it.
Returns a generator over the `UnresolvedReference`s that need to be resolved for `mrid`.
"""
if mrid in self._unresolved_references_to:
for ref in self._unresolved_references_to[mrid]:
yield ref
def remove(self, identified_object: IdentifiedObject) -> bool:
"""
Disassociate an object from this service.
`identified_object` THe object to disassociate from the service.
Raises `KeyError` if `identified_object` or its type was not present in the service.
"""
del self._objects_by_type[identified_object.__class__][identified_object.mrid]
return True
def objects(self, obj_type: Optional[Type[T]] = None, exc_types: Optional[List[type]] = None) -> Generator[T, None, None]:
"""
Generator for the objects in this service of type `obj_type`.
`obj_type` The type of object to yield. If this is a base class it will yield all subclasses.
Returns Generator over
"""
if obj_type is None:
for typ, obj_map in self._objects_by_type.items():
if exc_types:
if typ in exc_types:
continue
for obj in obj_map.values():
yield obj
return
else:
try:
for obj in self._objects_by_type[obj_type].values():
yield obj
except KeyError:
for _type, object_map in self._objects_by_type.items():
if issubclass(_type, obj_type):
for obj in object_map.values():
yield obj
@property
def name_types(self) -> Generator[NameType, None, None]:
"""Associates the provided [nameType] with this service."""
for name_type in self._name_types.values():
yield name_type
def add_name_type(self, name_type: NameType) -> bool:
"""
Associates the provided `name_type` with this service.
param `name_type` the `NameType` to add to this service
return true if the object is associated with this service, false if an object already exists in the service with
the same name.
"""
if name_type.name in self._name_types:
return False
else:
self._name_types[name_type.name] = name_type
return True
def get_name_type(self, name: str) -> NameType:
"""
Gets the `NameType` for the provided type name associated with this service.
:raises KeyError: if `name` doesn't exist in this service.
"""
return self._name_types[name] | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/common/base_service.py | base_service.py |
from __future__ import annotations
from typing import Callable, Optional
from dataclassy import dataclass
from zepben.evolve import TransformerTankInfo, TransformerEndInfo, TransformerStarImpedance, NoLoadTest, ShortCircuitTest, OpenCircuitTest, ShuntCompensator, \
ShuntCompensatorInfo
from zepben.evolve.model.cim.iec61968.assetinfo.power_transformer_info import PowerTransformerInfo
from zepben.evolve.model.cim.iec61968.assetinfo.wire_info import WireInfo
from zepben.evolve.model.cim.iec61968.assets.asset import Asset
from zepben.evolve.model.cim.iec61968.assets.asset_organisation_role import AssetOrganisationRole
from zepben.evolve.model.cim.iec61968.assets.pole import Pole
from zepben.evolve.model.cim.iec61968.assets.streetlight import Streetlight
from zepben.evolve.model.cim.iec61968.common.location import Location
from zepben.evolve.model.cim.iec61968.common.organisation import Organisation
from zepben.evolve.model.cim.iec61968.common.organisation_role import OrganisationRole
from zepben.evolve.model.cim.iec61968.customers.customer import Customer
from zepben.evolve.model.cim.iec61968.customers.customer_agreement import CustomerAgreement
from zepben.evolve.model.cim.iec61968.customers.pricing_structure import PricingStructure
from zepben.evolve.model.cim.iec61968.customers.tariff import Tariff
from zepben.evolve.model.cim.iec61968.metering.metering import EndDevice, UsagePoint
from zepben.evolve.model.cim.iec61968.operations.operational_restriction import OperationalRestriction
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.auxiliary_equipment import AuxiliaryEquipment
from zepben.evolve.model.cim.iec61970.base.core.base_voltage import BaseVoltage
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
from zepben.evolve.model.cim.iec61970.base.core.connectivity_node import ConnectivityNode
from zepben.evolve.model.cim.iec61970.base.core.equipment import Equipment
from zepben.evolve.model.cim.iec61970.base.core.equipment_container import Feeder, EquipmentContainer
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.model.cim.iec61970.base.core.power_system_resource import PowerSystemResource
from zepben.evolve.model.cim.iec61970.base.core.regions import GeographicalRegion, SubGeographicalRegion
from zepben.evolve.model.cim.iec61970.base.core.substation import Substation
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.model.cim.iec61970.base.diagramlayout.diagram_layout import Diagram, DiagramObject
from zepben.evolve.model.cim.iec61970.base.meas.control import Control
from zepben.evolve.model.cim.iec61970.base.meas.measurement import Measurement
from zepben.evolve.model.cim.iec61970.base.scada.remote_control import RemoteControl
from zepben.evolve.model.cim.iec61970.base.scada.remote_source import RemoteSource
from zepben.evolve.model.cim.iec61970.base.wires.aclinesegment import AcLineSegment, Conductor
from zepben.evolve.model.cim.iec61970.base.wires.energy_consumer import EnergyConsumer, EnergyConsumerPhase
from zepben.evolve.model.cim.iec61970.base.wires.energy_source import EnergySource
from zepben.evolve.model.cim.iec61970.base.wires.energy_source_phase import EnergySourcePhase
from zepben.evolve.model.cim.iec61970.base.wires.generation.production.power_electronics_unit import PowerElectronicsUnit
from zepben.evolve.model.cim.iec61970.base.wires.per_length import PerLengthSequenceImpedance
from zepben.evolve.model.cim.iec61970.base.wires.power_electronics_connection import PowerElectronicsConnectionPhase, PowerElectronicsConnection
from zepben.evolve.model.cim.iec61970.base.wires.power_transformer import PowerTransformer, PowerTransformerEnd, RatioTapChanger, TransformerEnd
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.circuit import Circuit
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.loop import Loop
__all__ = [
"acls_to_plsi_resolver", "asset_to_asset_org_role_resolver", "asset_to_location_resolver", "pole_to_streetlight_resolver", "streetlight_to_pole_resolver",
"aux_equip_to_term_resolver", "cond_equip_to_bv_resolver", "cond_equip_to_terminal_resolver", "conductor_to_wire_info_resolver",
"conn_node_to_term_resolver", "control_to_remote_control_resolver", "cust_to_custagr_resolver", "custagr_to_cust_resolver", "custagr_to_ps_resolver",
"diag_to_diagobj_resolver", "diagobj_to_diag_resolver", "ed_to_up_resolver", "ed_to_loc_resolver", "ec_to_ecp_resolver", "ecp_to_ec_resolver",
"es_to_esp_resolver", "esp_to_es_resolver", "eq_to_curfeeder_resolver", "powertransformer_to_power_transformer_info_resolver", "eq_to_ec_resolver",
"eq_to_or_resolver", "eq_to_up_resolver", "ec_to_eq_resolver", "curfeeder_to_eq_resolver", "feeder_to_nes_resolver", "feeder_to_nht_resolver",
"gr_to_sgr_resolver", "meas_to_rs_resolver", "or_to_eq_resolver", "orgr_to_org_resolver", "psr_to_loc_resolver", "pt_to_pte_resolver", "pte_to_pt_resolver",
"ps_to_tariff_resolver", "rtc_to_te_resolver", "rc_to_cont_resolver", "rs_to_meas_resolver", "sgr_to_gr_resolver", "sgr_to_sub_resolver",
"sub_to_feeder_resolver", "sub_to_sgr_resolver", "sub_to_circuit_resolver", "sub_to_eloop_resolver", "sub_to_loop_resolver", "term_to_ce_resolver",
"term_to_cn_resolver", "te_to_term_resolver", "te_to_bv_resolver", "te_to_rtc_resolver", "up_to_ed_resolver", "up_to_eq_resolver", "up_to_loc_resolver",
"circuit_to_loop_resolver", "circuit_to_sub_resolver", "circuit_to_term_resolver", "loop_to_circuit_resolver", "loop_to_esub_resolver",
"loop_to_sub_resolver", "BoundReferenceResolver", "ReferenceResolver", "UnresolvedReference", "tei_to_tti_resolver", "tti_to_tei_resolver",
"tei_to_tsi_resolver", "tsi_to_tei_resolver", "te_to_tsi_resolver", "pti_to_tti_resolver", "peu_to_pec_resolver", "pec_to_peu_resolver",
"pecphase_to_pec_resolver", "pec_to_pecphase_resolver", "tei_to_ee_nlt_resolver", "tei_to_ee_sct_resolver", "tei_to_ge_sct_resolver",
"tei_to_oe_oct_resolver", "tei_to_ee_oct_resolver", "shunt_compensator_to_shunt_compensator_info_resolver",
]
@dataclass(frozen=True, eq=False, slots=True)
class ReferenceResolver(object):
from_class: type
to_class: type
resolve: Callable[[IdentifiedObject, IdentifiedObject], None]
def __eq__(self, other):
return self.from_class is other.from_class and self.to_class is other.to_class and self.resolve is other.resolve
def __ne__(self, other):
return self.from_class is not other.from_class or self.to_class is not other.to_class or self.resolve is not other.resolve
def __hash__(self):
return hash((type(self), self.from_class, self.to_class, self.resolve))
@dataclass(frozen=True, eq=False, slots=True)
class BoundReferenceResolver(object):
from_obj: IdentifiedObject
resolver: ReferenceResolver
reverse_resolver: Optional[ReferenceResolver]
def __eq__(self, other):
""" We only do a reference check for `from_obj` to avoid expensive equality checks on `IdentifiedObjects`. """
if self.reverse_resolver is None and other.reverse_resolver is None:
return self.from_obj is other.from_obj and self.resolver == other.resolver
elif self.reverse_resolver is not None and other.reverse_resolver is not None:
return self.from_obj is other.from_obj and self.resolver == other.resolver and self.reverse_resolver == other.reverse_resolver
elif self.reverse_resolver is None:
return False
else:
return False
def __ne__(self, other):
if self.reverse_resolver is None and other.reverse_resolver is None:
return self.from_obj is not other.from_obj or self.resolver != other.resolver
elif self.reverse_resolver is not None and other.reverse_resolver is not None:
return self.from_obj is not other.from_obj or self.resolver != other.resolver or self.reverse_resolver != other.reverse_resolver
elif self.reverse_resolver is None:
return True
else:
return True
def __hash__(self):
return hash((type(self), self.from_obj, self.resolver, self.reverse_resolver))
@dataclass(frozen=True, eq=False, slots=True)
class UnresolvedReference(object):
from_ref: IdentifiedObject
to_mrid: str
resolver: ReferenceResolver
reverse_resolver: Optional[ReferenceResolver] = None
def __eq__(self, other: UnresolvedReference):
# we don't check reverse resolver for equality, as it doesn't make sense to have a reverse resolver that is not the reverse of resolver
return self.from_ref.mrid == other.from_ref.mrid and self.to_mrid == other.to_mrid and self.resolver == other.resolver
def __ne__(self, other: UnresolvedReference):
return self.from_ref.mrid != other.from_ref.mrid or self.to_mrid != other.to_mrid or self.resolver != other.resolver
def __hash__(self):
return hash((type(self), self.from_ref.mrid, self.to_mrid, self.resolver))
def _resolve_ce_term(ce, t):
t.conducting_equipment = ce
ce.add_terminal(t)
def _resolve_pt_pte(pt, pte):
pte.power_transformer = pt
pt.add_end(pte)
def _resolve_diag_diagobj(diag, diag_obj):
diag_obj.diagram = diag
diag.add_diagram_object(diag_obj)
acls_to_plsi_resolver = ReferenceResolver(AcLineSegment, PerLengthSequenceImpedance, lambda t, r: setattr(t, 'per_length_sequence_impedance', r))
asset_to_asset_org_role_resolver = ReferenceResolver(Asset, AssetOrganisationRole, lambda t, r: t.add_organisation_role(r))
asset_to_location_resolver = ReferenceResolver(Asset, Location, lambda t, r: setattr(t, 'location', r))
pole_to_streetlight_resolver = ReferenceResolver(Pole, Streetlight, lambda t, r: t.add_streetlight(r))
streetlight_to_pole_resolver = ReferenceResolver(Streetlight, Pole, lambda t, r: setattr(t, 'pole', r))
aux_equip_to_term_resolver = ReferenceResolver(AuxiliaryEquipment, Terminal, lambda t, r: setattr(t, 'terminal', r))
cond_equip_to_bv_resolver = ReferenceResolver(ConductingEquipment, BaseVoltage, lambda t, r: setattr(t, 'base_voltage', r))
cond_equip_to_terminal_resolver = ReferenceResolver(ConductingEquipment, Terminal, _resolve_ce_term)
conductor_to_wire_info_resolver = ReferenceResolver(Conductor, WireInfo, lambda t, r: setattr(t, 'asset_info', r))
powertransformer_to_power_transformer_info_resolver = ReferenceResolver(PowerTransformer, PowerTransformerInfo, lambda t, r: setattr(t, 'asset_info', r))
shunt_compensator_to_shunt_compensator_info_resolver = ReferenceResolver(ShuntCompensator, ShuntCompensatorInfo, lambda t, r: setattr(t, 'asset_info', r))
tei_to_tti_resolver = ReferenceResolver(TransformerEndInfo, TransformerTankInfo, lambda t, r: setattr(t, 'transformer_tank_info', r))
tti_to_tei_resolver = ReferenceResolver(TransformerTankInfo, TransformerEndInfo, lambda t, r: t.add_transformer_end_info(r))
tei_to_tsi_resolver = ReferenceResolver(TransformerEndInfo, TransformerStarImpedance, lambda t, r: setattr(t, 'transformer_star_impedance', r))
tsi_to_tei_resolver = ReferenceResolver(TransformerStarImpedance, TransformerEndInfo, lambda t, r: setattr(t, 'transformer_end_info', r))
te_to_tsi_resolver = ReferenceResolver(TransformerEnd, TransformerStarImpedance, lambda t, r: setattr(t, 'star_impedance', r))
pti_to_tti_resolver = ReferenceResolver(PowerTransformerInfo, TransformerTankInfo, lambda t, r: t.add_transformer_tank_info(r))
conn_node_to_term_resolver = ReferenceResolver(ConnectivityNode, Terminal, lambda t, r: t.add_terminal(r))
control_to_remote_control_resolver = ReferenceResolver(Control, RemoteControl, lambda t, r: setattr(t, 'remote_control', r))
cust_to_custagr_resolver = ReferenceResolver(Customer, CustomerAgreement, lambda t, r: t.add_agreement(r))
custagr_to_cust_resolver = ReferenceResolver(CustomerAgreement, Customer, lambda t, r: setattr(t, 'customer', r))
custagr_to_ps_resolver = ReferenceResolver(CustomerAgreement, PricingStructure, lambda t, r: t.add_pricing_structure(r))
diag_to_diagobj_resolver = ReferenceResolver(Diagram, DiagramObject, _resolve_diag_diagobj)
diagobj_to_diag_resolver = ReferenceResolver(DiagramObject, Diagram, lambda t, r: setattr(t, 'diagram', r))
ed_to_up_resolver = ReferenceResolver(EndDevice, UsagePoint, lambda t, r: t.add_usage_point(r))
ed_to_loc_resolver = ReferenceResolver(EndDevice, Location, lambda t, r: setattr(t, 'service_location', r))
ec_to_ecp_resolver = ReferenceResolver(EnergyConsumer, EnergyConsumerPhase, lambda t, r: t.add_phase(r))
ecp_to_ec_resolver = ReferenceResolver(EnergyConsumerPhase, EnergyConsumer, lambda t, r: setattr(t, 'energy_consumer', r))
es_to_esp_resolver = ReferenceResolver(EnergySource, EnergySourcePhase, lambda t, r: t.add_phase(r))
esp_to_es_resolver = ReferenceResolver(EnergySourcePhase, EnergySource, lambda t, r: setattr(t, 'energy_source', r))
eq_to_curfeeder_resolver = ReferenceResolver(Equipment, Feeder, lambda t, r: t.add_current_feeder(r))
eq_to_ec_resolver = ReferenceResolver(Equipment, EquipmentContainer, lambda t, r: t.add_container(r))
eq_to_or_resolver = ReferenceResolver(Equipment, OperationalRestriction, lambda t, r: t.add_operational_restriction(r))
eq_to_up_resolver = ReferenceResolver(Equipment, UsagePoint, lambda t, r: t.add_usage_point(r))
ec_to_eq_resolver = ReferenceResolver(EquipmentContainer, Equipment, lambda t, r: t.add_equipment(r))
curfeeder_to_eq_resolver = ReferenceResolver(Feeder, Equipment, lambda t, r: t.add_equipment(r))
feeder_to_nes_resolver = ReferenceResolver(Feeder, Substation, lambda t, r: setattr(t, 'normal_energizing_substation', r))
feeder_to_nht_resolver = ReferenceResolver(Feeder, Terminal, lambda t, r: setattr(t, 'normal_head_terminal', r))
gr_to_sgr_resolver = ReferenceResolver(GeographicalRegion, SubGeographicalRegion, lambda t, r: t.add_sub_geographical_region(r))
meas_to_rs_resolver = ReferenceResolver(Measurement, RemoteSource, lambda t, r: setattr(t, 'remote_source', r))
or_to_eq_resolver = ReferenceResolver(OperationalRestriction, Equipment, lambda t, r: t.add_equipment(r))
orgr_to_org_resolver = ReferenceResolver(OrganisationRole, Organisation, lambda t, r: setattr(t, 'organisation', r))
psr_to_loc_resolver = ReferenceResolver(PowerSystemResource, Location, lambda t, r: setattr(t, 'location', r))
pt_to_pte_resolver = ReferenceResolver(PowerTransformer, PowerTransformerEnd, _resolve_pt_pte)
pte_to_pt_resolver = ReferenceResolver(PowerTransformerEnd, PowerTransformer, lambda t, r: setattr(t, 'power_transformer', r))
ps_to_tariff_resolver = ReferenceResolver(PricingStructure, Tariff, lambda t, r: t.add_tariff(r))
rtc_to_te_resolver = ReferenceResolver(RatioTapChanger, PowerTransformerEnd, lambda t, r: setattr(t, 'transformer_end', r))
rc_to_cont_resolver = ReferenceResolver(RemoteControl, Control, lambda t, r: setattr(t, 'control', r))
rs_to_meas_resolver = ReferenceResolver(RemoteSource, Measurement, lambda t, r: setattr(t, 'measurement', r))
sgr_to_gr_resolver = ReferenceResolver(SubGeographicalRegion, GeographicalRegion, lambda t, r: setattr(t, 'geographical_region', r))
sgr_to_sub_resolver = ReferenceResolver(SubGeographicalRegion, Substation, lambda t, r: t.add_substation(r))
sub_to_feeder_resolver = ReferenceResolver(Substation, Feeder, lambda t, r: t.add_feeder(r))
sub_to_sgr_resolver = ReferenceResolver(Substation, SubGeographicalRegion, lambda t, r: setattr(t, 'sub_geographical_region', r))
sub_to_circuit_resolver = ReferenceResolver(Substation, Circuit, lambda t, r: t.add_circuit(r))
sub_to_loop_resolver = ReferenceResolver(Substation, Loop, lambda t, r: t.add_loop(r))
sub_to_eloop_resolver = ReferenceResolver(Substation, Loop, lambda t, r: t.add_energized_loop(r))
term_to_ce_resolver = ReferenceResolver(Terminal, ConductingEquipment, lambda t, r: setattr(t, 'conducting_equipment', r))
term_to_cn_resolver = ReferenceResolver(Terminal, ConnectivityNode, lambda t, r: setattr(t, 'connectivity_node', r))
te_to_term_resolver = ReferenceResolver(TransformerEnd, Terminal, lambda t, r: setattr(t, 'terminal', r))
te_to_bv_resolver = ReferenceResolver(TransformerEnd, BaseVoltage, lambda t, r: setattr(t, 'base_voltage', r))
te_to_rtc_resolver = ReferenceResolver(TransformerEnd, RatioTapChanger, lambda t, r: setattr(t, 'ratio_tap_changer', r))
up_to_ed_resolver = ReferenceResolver(UsagePoint, EndDevice, lambda t, r: t.add_end_device(r))
up_to_eq_resolver = ReferenceResolver(UsagePoint, Equipment, lambda t, r: t.add_equipment(r))
up_to_loc_resolver = ReferenceResolver(UsagePoint, Location, lambda t, r: setattr(t, 'usage_point_location', r))
circuit_to_term_resolver = ReferenceResolver(Circuit, Terminal, lambda t, r: t.add_end_terminal(r))
circuit_to_loop_resolver = ReferenceResolver(Circuit, Loop, lambda t, r: setattr(t, 'loop', r))
circuit_to_sub_resolver = ReferenceResolver(Circuit, Substation, lambda t, r: t.add_end_substation(r))
loop_to_circuit_resolver = ReferenceResolver(Loop, Circuit, lambda t, r: t.add_circuit(r))
loop_to_sub_resolver = ReferenceResolver(Loop, Substation, lambda t, r: t.add_substation(r))
loop_to_esub_resolver = ReferenceResolver(Loop, Substation, lambda t, r: t.add_energizing_substation(r))
pec_to_pecphase_resolver = ReferenceResolver(PowerElectronicsConnection, PowerElectronicsConnectionPhase, lambda t, r: t.add_phase(r))
pecphase_to_pec_resolver = ReferenceResolver(PowerElectronicsConnectionPhase,
PowerElectronicsConnection,
lambda t, r: setattr(t, 'power_electronics_connection', r))
pec_to_peu_resolver = ReferenceResolver(PowerElectronicsConnection, PowerElectronicsUnit, lambda t, r: t.add_unit(r))
peu_to_pec_resolver = ReferenceResolver(PowerElectronicsUnit, PowerElectronicsConnection, lambda t, r: setattr(t, 'power_electronics_connection', r))
tei_to_ee_nlt_resolver = ReferenceResolver(TransformerEndInfo, NoLoadTest, lambda t, r: setattr(t, 'energised_end_no_load_tests', r))
tei_to_ee_sct_resolver = ReferenceResolver(TransformerEndInfo, ShortCircuitTest, lambda t, r: setattr(t, 'energised_end_short_circuit_tests', r))
tei_to_ge_sct_resolver = ReferenceResolver(TransformerEndInfo, ShortCircuitTest, lambda t, r: setattr(t, 'grounded_end_short_circuit_tests', r))
tei_to_oe_oct_resolver = ReferenceResolver(TransformerEndInfo, OpenCircuitTest, lambda t, r: setattr(t, 'open_end_open_circuit_tests', r))
tei_to_ee_oct_resolver = ReferenceResolver(TransformerEndInfo, OpenCircuitTest, lambda t, r: setattr(t, 'energised_end_open_circuit_tests', r)) | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/common/reference_resolvers.py | reference_resolvers.py |
from math import isnan
from types import MemberDescriptorType
from typing import get_type_hints, Dict, Type, Callable, Any, TypeVar, Optional, Union, List, Tuple
from zepben.evolve import BaseService, IdentifiedObject, Organisation, Document, OrganisationRole
from zepben.evolve.model.cim.iec61970.base.core.name import Name
from zepben.evolve.model.cim.iec61970.base.core.name_type import NameType
from zepben.evolve.services.common.difference import ObjectDifference, Difference, ValueDifference, ReferenceDifference, CollectionDifference, IndexedDifference
from zepben.evolve.services.common.translator.service_differences import ServiceDifferences
T = TypeVar("T")
class BaseServiceComparator:
def __init__(self):
def _is_valid_compare_func(func_name, func):
if not func_name.startswith("_compare_"):
return False
try:
type_hints = get_type_hints(func)
return ((len(type_hints) == 3)
and ("source" in type_hints)
and ("target" in type_hints)
and ("return" in type_hints)
and (type_hints["source"] == type_hints["target"])
and (issubclass(type_hints["return"], ObjectDifference))
)
except TypeError:
return False
def _find_comparisons_for_type(type_of: Type):
for k, v in type_of.__dict__.items():
if _is_valid_compare_func(k, v):
self._compare_by_type[get_type_hints(v)["source"]] = v
for base_of in type_of.__bases__:
_find_comparisons_for_type(base_of)
self._compare_by_type: Dict[Type, Callable[[Any, T, T], ObjectDifference]] = {}
_find_comparisons_for_type(type(self))
def compare_services(self, source: BaseService, target: BaseService, compare_name_types: bool = True) -> ServiceDifferences:
"""
Run the compare with the specified optional checks
:param source: The service to use as the source
:param target: The service to use as the target
:param compare_name_types: Optional parameter to suppress comparing name types
:return: The differences detected between the source and the target
"""
differences = ServiceDifferences(
lambda mrid: source.get(mrid, default=None),
lambda mrid: target.get(mrid, default=None),
lambda name: source.get_name_type(name),
lambda name: target.get_name_type(name)
)
for s in source.objects():
t = target.get(s.mrid, default=None)
if t:
source_type = type(s)
if source_type != type(t):
differences.add_to_missing_from_source(s.mrid)
differences.add_to_missing_from_target(s.mrid)
else:
diff = self._try_compare(source_type, s, t)
if diff.differences:
differences.add_modifications(s.mrid, diff)
else:
differences.add_to_missing_from_target(s.mrid)
for t in target.objects():
if t.mrid not in source:
differences.add_to_missing_from_source(t.mrid)
if compare_name_types:
for s in source.name_types:
try:
t = target.get_name_type(s.name)
difference = self._compare_name_type(s, t)
if difference.differences:
differences.add_modifications(s.name, difference)
except KeyError:
differences.add_to_missing_from_target(s.name)
for t in target.name_types:
try:
source.get_name_type(t.name)
except KeyError:
differences.add_to_missing_from_source(t.name)
return differences
def compare_objects(self, source: T, target: T) -> ObjectDifference:
"""
Compare the attributes of two objects. See :class:`ObjectDifference`.
:param source: the source object to compare
:param target: the target object to compare
:return: The differences detected between the source and the target
"""
source_type = type(source)
target_type = type(target)
if source_type != target_type:
raise ValueError(f"source and target must be of the same type. {source_type.__name__} vs {target_type.__name__}")
return self._try_compare(source_type, source, target)
def _try_compare(self, source_type: Type, s: T, t: T) -> ObjectDifference:
try:
compare = self._compare_by_type[source_type]
except KeyError:
raise AssertionError(f"INTERNAL ERROR: Attempted to compare {source_type.__name__} which is not registered with the comparator.")
return compare(self, s, t)
def _compare_organisation(self, source: Organisation, target: Organisation) -> ObjectDifference:
return self._compare_identified_object(ObjectDifference(source, target))
def _compare_identified_object(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(diff, IdentifiedObject.mrid, IdentifiedObject.name, IdentifiedObject.description)
self._compare_names(diff, IdentifiedObject.names)
return diff
def _compare_name_type(self, source: NameType, target: NameType) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, NameType.description)
def compare_names(s: Name, t: Name) -> bool:
return s.name == t.name and s.type.name == t.type.name and s.identified_object.mrid == t.identified_object.mrid
differences = CollectionDifference()
for s_name in source.names:
if not [t_name for t_name in target.names if compare_names(s_name, t_name)]:
differences.missing_from_target.append(s_name)
for t_name in target.names:
if not [s_name for s_name in source.names if compare_names(s_name, t_name)]:
differences.missing_from_source.append(t_name)
if differences.missing_from_source or differences.missing_from_target:
diff.differences[NameType.names.fget.__name__] = differences
return diff
def _compare_document(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_values(diff, Document.title, Document.created_date_time, Document.author_name, Document.type, Document.status, Document.comment)
return self._compare_identified_object(diff)
def _compare_organisation_role(self, diff: ObjectDifference) -> ObjectDifference:
self._compare_id_references(diff, OrganisationRole.organisation)
return self._compare_identified_object(diff)
def _compare_values(self, diff: ObjectDifference, *properties) -> ObjectDifference:
for it in properties:
if isinstance(it, property):
self._add_if_different(diff, it.fget.__name__, self._calculate_values_diff(it, diff))
else:
self._add_if_different(diff, it.__name__, self._calculate_values_diff(it, diff))
return diff
def _compare_floats(self, diff: ObjectDifference, *properties) -> ObjectDifference:
for it in properties:
if isinstance(it, property):
self._add_if_different(diff, it.fget.__name__, self._calculate_float_diff(it, diff))
else:
self._add_if_different(diff, it.__name__, self._calculate_float_diff(it, diff))
return diff
def _compare_id_references(self, diff: ObjectDifference, *properties) -> ObjectDifference:
for it in properties:
if isinstance(it, property):
self._add_if_different(diff, it.fget.__name__, self._calculate_id_reference_diff(it, diff))
else:
self._add_if_different(diff, it.__name__, self._calculate_id_reference_diff(it, diff))
return diff
def _compare_names(self, diff: ObjectDifference, *properties) -> ObjectDifference:
for it in properties:
if isinstance(it, property):
self._add_if_different(diff, it.fget.__name__, self.calculate_name_diff(it, diff))
else:
self._add_if_different(diff, it.__name__, self.calculate_name_diff(it, diff))
return diff
def _compare_id_reference_collections(self, diff: ObjectDifference, *properties) -> ObjectDifference:
for it in properties:
self._add_if_different(diff, it.fget.__name__, self._calculate_id_reference_collection_diff(it, diff))
return diff
def _compare_indexed_id_reference_collections(self, diff: ObjectDifference, *properties) -> ObjectDifference:
for it in properties:
self._add_if_different(diff, it.fget.__name__, self._calculate_indexed_id_reference_collection_diff(it, diff))
return diff
def _compare_indexed_value_collections(self, diff: ObjectDifference, *properties) -> ObjectDifference:
for it in properties:
self._add_if_different(diff, it.fget.__name__, self._calculate_indexed_value_collection_diff(it, diff))
return diff
@staticmethod
def _add_if_different(diff: ObjectDifference, name: str, difference: Optional[Difference]):
if difference:
diff.differences[name] = difference
@staticmethod
def _calculate_values_diff(prop: Union[MemberDescriptorType, property], diff: ObjectDifference) -> Optional[ValueDifference]:
if isinstance(prop, property):
s_val = getattr(diff.source, prop.fget.__name__) if diff.source else None
t_val = getattr(diff.target, prop.fget.__name__) if diff.target else None
else:
s_val = getattr(diff.source, prop.__name__) if diff.source else None
t_val = getattr(diff.target, prop.__name__) if diff.target else None
if (type(s_val) == float) or (type(t_val) == float):
raise TypeError(f"Using wrong comparator for {prop}, use _calculate_float_diff instead.")
if s_val == t_val:
return None
else:
return ValueDifference(s_val, t_val)
@staticmethod
def _calculate_float_diff(prop: Union[MemberDescriptorType, property], diff: ObjectDifference) -> Optional[ValueDifference]:
if isinstance(prop, property):
s_val = getattr(diff.source, prop.fget.__name__) if diff.source else None
t_val = getattr(diff.target, prop.fget.__name__) if diff.target else None
else:
s_val = getattr(diff.source, prop.__name__) if diff.source else None
t_val = getattr(diff.target, prop.__name__) if diff.target else None
if s_val == t_val:
return None
elif (s_val is not None) and (t_val is not None) and isnan(s_val) and isnan(t_val):
return None
else:
return ValueDifference(s_val, t_val)
@staticmethod
def _calculate_id_reference_diff(prop: Union[MemberDescriptorType, property], diff: ObjectDifference) -> Optional[ReferenceDifference]:
if isinstance(prop, property):
s_ref = getattr(diff.source, prop.fget.__name__) if diff.source else None
t_ref = getattr(diff.target, prop.fget.__name__) if diff.target else None
else:
s_ref = getattr(diff.source, prop.__name__) if diff.source else None
t_ref = getattr(diff.target, prop.__name__) if diff.target else None
if (s_ref is None) and (t_ref is None):
return None
elif (s_ref is not None) and (t_ref is not None) and (s_ref.mrid == t_ref.mrid):
return None
else:
return ReferenceDifference(s_ref, t_ref)
def calculate_name_diff(self, prop: property, diff: ObjectDifference) -> Optional[CollectionDifference]:
differences = CollectionDifference()
if isinstance(prop, property):
source_collection = list(getattr(diff.source, prop.fget.__name__)) if diff.source else None
target_collection = list(getattr(diff.target, prop.fget.__name__)) if diff.target else None
else:
source_collection = list(getattr(diff.source, prop.__name__)) if diff.source else None
target_collection = list(getattr(diff.target, prop.__name__)) if diff.target else None
source_name_type_names: List[Tuple[str, str]] = []
for source_io in source_collection:
source_name_type_names.append((source_io.type.name, source_io.name))
if not next((io for io in target_collection if (io.name == source_io.name) and (io.type.name == source_io.type.name)), None):
differences.missing_from_target.append(source_io)
for target_io in target_collection:
if not next((io for io in source_collection if (io.name == target_io.name) and (io.type.name == target_io.type.name)), None):
differences.missing_from_source.append(target_io)
return self._none_if_empty(differences)
def _calculate_id_reference_collection_diff(self, prop: property, diff: ObjectDifference) -> Optional[CollectionDifference]:
differences = CollectionDifference()
source_collection = list(getattr(diff.source, prop.fget.__name__))
target_collection = list(getattr(diff.target, prop.fget.__name__))
source_mrids = set()
for s_obj in source_collection:
source_mrids.add(s_obj.mrid)
t_obj = next((it for it in target_collection if it.mrid == s_obj.mrid), None)
if t_obj is None:
differences.missing_from_target.append(s_obj)
for it in target_collection:
if it.mrid not in source_mrids:
differences.missing_from_source.append(it)
return self._none_if_empty(differences)
def _calculate_indexed_id_reference_collection_diff(self, prop: property, diff: ObjectDifference) -> Optional[CollectionDifference]:
differences = CollectionDifference()
source_list = list(getattr(diff.source, prop.fget.__name__))
target_list = list(getattr(diff.target, prop.fget.__name__))
for index, s_obj in enumerate(source_list):
try:
t_obj = target_list[index]
except IndexError:
t_obj = None
if t_obj is None:
differences.missing_from_target.append(IndexedDifference(index, ReferenceDifference(s_obj, None)))
elif t_obj.mrid != s_obj.mrid:
differences.modifications.append(IndexedDifference(index, ReferenceDifference(s_obj, t_obj)))
for index in range(len(source_list), len(target_list)):
differences.missing_from_source.append(IndexedDifference(index, ReferenceDifference(None, target_list[index])))
return self._none_if_empty(differences)
def _calculate_indexed_value_collection_diff(self, prop: property, diff: ObjectDifference) -> Optional[CollectionDifference]:
differences = CollectionDifference()
source_list = list(getattr(diff.source, prop.fget.__name__))
target_list = list(getattr(diff.target, prop.fget.__name__))
for index, source_value in enumerate(source_list):
try:
target_value = target_list[index]
except IndexError:
target_value = None
if target_value is None:
differences.missing_from_target.append(IndexedDifference(index, ValueDifference(source_value, None)))
elif target_value != source_value:
differences.modifications.append(IndexedDifference(index, ValueDifference(source_value, target_value)))
for index in range(len(source_list), len(target_list)):
differences.missing_from_source.append(IndexedDifference(index, ValueDifference(None, target_list[index])))
return self._none_if_empty(differences)
@staticmethod
def _none_if_empty(diff: CollectionDifference):
if not diff.missing_from_source and not diff.missing_from_target and not diff.modifications:
return None
else:
return diff | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/common/base_service_comparator.py | base_service_comparator.py |
from abc import ABCMeta
from typing import Optional
from dataclassy import dataclass
# noinspection PyPackageRequirements
from google.protobuf.timestamp_pb2 import Timestamp as PBTimestamp
from zepben.protobuf.cim.iec61968.common.Document_pb2 import Document as PBDocument
from zepben.protobuf.cim.iec61968.common.OrganisationRole_pb2 import OrganisationRole as PBOrganisationRole
from zepben.protobuf.cim.iec61968.common.Organisation_pb2 import Organisation as PBOrganisation
from zepben.protobuf.cim.iec61970.base.core.IdentifiedObject_pb2 import IdentifiedObject as PBIdentifiedObject
from zepben.protobuf.cim.iec61970.base.core.NameType_pb2 import NameType as PBNameType
from zepben.protobuf.cim.iec61970.base.core.Name_pb2 import Name as PBName
from zepben.evolve import Document, IdentifiedObject, Organisation, OrganisationRole
from zepben.evolve.model.cim.iec61970.base.core.name_type import NameType
from zepben.evolve.services.common import resolver
from zepben.evolve.services.common.base_service import BaseService
__all__ = ["identified_object_to_cim", "document_to_cim", "organisation_to_cim", "organisation_role_to_cim", "BaseProtoToCim"]
###################
# IEC61968 COMMON #
###################
def document_to_cim(pb: PBDocument, cim: Document, service: BaseService):
cim.title = pb.title
cim.created_date_time = pb.createdDateTime.ToDatetime() if pb.createdDateTime != PBTimestamp() else None
cim.author_name = pb.authorName
cim.type = pb.type
cim.status = pb.status
cim.comment = pb.comment
identified_object_to_cim(pb.io, cim, service)
def organisation_to_cim(pb: PBOrganisation, service: BaseService) -> Optional[Organisation]:
cim = Organisation()
identified_object_to_cim(pb.io, cim, service)
return cim if service.add(cim) else None
def organisation_role_to_cim(pb: PBOrganisationRole, cim: OrganisationRole, service: BaseService):
service.resolve_or_defer_reference(resolver.organisation(cim), pb.organisationMRID)
identified_object_to_cim(pb.io, cim, service)
PBDocument.to_cim = document_to_cim
PBOrganisation.to_cim = organisation_to_cim
PBOrganisationRole.to_cim = organisation_role_to_cim
######################
# IEC61970 BASE CORE #
######################
def identified_object_to_cim(pb: PBIdentifiedObject, cim: IdentifiedObject, service: BaseService):
cim.mrid = pb.mRID
cim.name = pb.name
cim.description = pb.description
[cim.add_name(name_to_cim(name, cim, service)) for name in pb.names]
def name_to_cim(pb: PBName, io: IdentifiedObject, service: BaseService):
try:
nt = service.get_name_type(pb.type)
except KeyError:
# noinspection PyArgumentList
nt = NameType(pb.type)
service.add_name_type(nt)
return nt.get_or_add_name(pb.name, io)
def name_type_to_cim(pb: PBNameType, service: BaseService):
try:
nt = service.get_name_type(pb.name)
except KeyError:
# noinspection PyArgumentList
nt = NameType(pb.name)
service.add_name_type(nt)
nt.description = pb.description
return nt
PBIdentifiedObject.to_cim = identified_object_to_cim
PBName.to_cim = name_to_cim
PBNameType.to_cim = name_type_to_cim
@dataclass(slots=True)
class BaseProtoToCim(object, metaclass=ABCMeta):
service: BaseService
# Extensions
def _add_from_pb(service: BaseService, pb) -> Optional[IdentifiedObject]:
"""Must only be called by objects for which .to_cim() takes themselves and the network service."""
try:
return pb.to_cim(service)
except AttributeError as e:
raise TypeError(f"Type {pb.__class__.__name__} is not supported by {service.__class__.__name__}. (Error was: {e})")
BaseService.add_from_pb = _add_from_pb | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/common/translator/base_proto2cim.py | base_proto2cim.py |
from typing import Callable, Optional, Set, Dict, Generator, Tuple, Any, Iterable
from zepben.evolve import IdentifiedObject
from zepben.evolve.model.cim.iec61970.base.core.name_type import NameType
from zepben.evolve.services.common.difference import ObjectDifference
class ServiceDifferences(object):
def __init__(
self,
source_lookup: Callable[[str], Optional[IdentifiedObject]],
target_lookup: Callable[[str], Optional[IdentifiedObject]],
source_name_type_lookup: Callable[[str], Optional[NameType]],
target_name_type_lookup: Callable[[str], Optional[NameType]]
):
self._source_lookup = source_lookup
self._target_lookup = target_lookup
self._source_name_type_lookup = source_name_type_lookup
self._target_name_type_lookup = target_name_type_lookup
self._missing_from_target: Set[str] = set()
self._missing_from_source: Set[str] = set()
self._modifications: Dict[str, ObjectDifference] = {}
def missing_from_target(self) -> Generator[str, None, None]:
for it in self._missing_from_target:
yield it
def missing_from_source(self) -> Generator[str, None, None]:
for it in self._missing_from_source:
yield it
def modifications(self) -> Generator[Tuple[str, ObjectDifference], None, None]:
for k, v in self._modifications.items():
yield k, v
def add_to_missing_from_target(self, mrid: str):
self._missing_from_target.add(mrid)
def add_to_missing_from_source(self, mrid: str):
self._missing_from_source.add(mrid)
def add_modifications(self, mrid: str, difference: ObjectDifference):
self._modifications[mrid] = difference
def __str__(self) -> str:
return "Missing From Target:" + _indent_each(self._missing_from_target, self._source_lookup, self._source_name_type_lookup) + \
"\nMissing From Source:" + _indent_each(self._missing_from_source, self._target_lookup, self._target_name_type_lookup) + \
"\nModifications:" + ''.join(_indented_line("{!r}: {!r},".format(k, v)) for k, v in self._modifications.items())
def _indent_each(items: Iterable, obj_lookup, name_lookup) -> str:
return ''.join([_indented_line(_lookup(it, obj_lookup, name_lookup)) for it in items])
def _indented_line(line: Any) -> str:
return "\n " + str(line)
def _lookup(it, obj_lookup, name_lookup):
try:
s = obj_lookup(it)
if s:
return s
except KeyError:
pass
try:
s = name_lookup(it)
if s:
return s
except KeyError:
pass
return it | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/common/translator/service_differences.py | service_differences.py |
from google.protobuf.timestamp_pb2 import Timestamp as PBTimestamp
from zepben.protobuf.cim.iec61968.common.Document_pb2 import Document as PBDocument
from zepben.protobuf.cim.iec61968.common.OrganisationRole_pb2 import OrganisationRole as PBOrganisationRole
from zepben.protobuf.cim.iec61968.common.Organisation_pb2 import Organisation as PBOrganisation
from zepben.protobuf.cim.iec61970.base.core.IdentifiedObject_pb2 import IdentifiedObject as PBIdentifiedObject
from zepben.protobuf.cim.iec61970.base.core.NameType_pb2 import NameType as PBNameType
from zepben.protobuf.cim.iec61970.base.core.Name_pb2 import Name as PBName
from zepben.evolve.model.cim.iec61968.common.document import Document
from zepben.evolve.model.cim.iec61968.common.organisation import Organisation
from zepben.evolve.model.cim.iec61968.common.organisation_role import OrganisationRole
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.model.cim.iec61970.base.core.name import Name
from zepben.evolve.model.cim.iec61970.base.core.name_type import NameType
from zepben.evolve.services.common.translator.util import mrid_or_empty
__all__ = ["identified_object_to_pb", "document_to_pb", "organisation_role_to_pb", "organisation_to_pb"]
###################
# IEC61968 COMMON #
###################
def document_to_pb(cim: Document) -> PBDocument:
timestamp = PBTimestamp()
if cim.created_date_time:
timestamp.FromDatetime(cim.created_date_time)
return PBDocument(
io=identified_object_to_pb(cim),
title=cim.title,
createdDateTime=timestamp,
authorName=cim.author_name,
type=cim.type,
status=cim.status,
comment=cim.comment
)
def organisation_to_pb(cim: Organisation) -> PBOrganisation:
return PBOrganisation(io=identified_object_to_pb(cim))
def organisation_role_to_pb(cim: OrganisationRole) -> PBOrganisationRole:
return PBOrganisationRole(
io=identified_object_to_pb(cim),
organisationMRID=mrid_or_empty(cim.organisation)
)
Document.to_pb = document_to_pb
Organisation.to_pb = organisation_to_pb
OrganisationRole.to_pb = organisation_role_to_pb
######################
# IEC61970 BASE CORE #
######################
def identified_object_to_pb(cim: IdentifiedObject) -> PBIdentifiedObject:
return PBIdentifiedObject(
mRID=str(cim.mrid),
name=cim.name,
description=cim.description,
names=[name_to_pb(name) for name in cim.names]
)
def name_to_pb(cim: Name) -> PBName:
return PBName(
name=cim.name,
type=cim.type.name if cim.type else None
)
def name_type_to_pb(cim: NameType) -> PBNameType:
return PBNameType(
name=cim.name,
description=cim.description
)
IdentifiedObject.to_pb = identified_object_to_pb
Name.to_pb = name_to_pb
NameType.to_pb = name_type_to_pb | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/services/common/translator/base_cim2proto.py | base_cim2proto.py |
from __future__ import annotations
from collections import defaultdict
from dataclassy import dataclass
from zepben.evolve.exceptions import PhaseException
from zepben.evolve.model.cim.iec61970.base.core.phase_code import PhaseCode
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
__all__ = ["get_phase", "set_phase", "TracedPhases", "NominalPhasePath"]
BITS_TO_PHASE = defaultdict(lambda: SinglePhaseKind.NONE)
BITS_TO_PHASE[0b0001] = SinglePhaseKind.A
BITS_TO_PHASE[0b0010] = SinglePhaseKind.B
BITS_TO_PHASE[0b0100] = SinglePhaseKind.C
BITS_TO_PHASE[0b1000] = SinglePhaseKind.N
PHASE_TO_BITS = defaultdict(lambda: 0)
PHASE_TO_BITS[SinglePhaseKind.A] = 0b0001
PHASE_TO_BITS[SinglePhaseKind.B] = 0b0010
PHASE_TO_BITS[SinglePhaseKind.C] = 0b0100
PHASE_TO_BITS[SinglePhaseKind.N] = 0b1000
NOMINAL_PHASE_MASKS = [0x000f, 0x00f0, 0x0f00, 0xf000]
def _valid_phase_check(nominal_phase):
if nominal_phase == SinglePhaseKind.NONE or nominal_phase == SinglePhaseKind.INVALID:
raise ValueError(f"INTERNAL ERROR: Phase {nominal_phase.name} is invalid. Must not be NONE or INVALID.")
def get_phase(status: int, nominal_phase: SinglePhaseKind):
return BITS_TO_PHASE[(status >> _byte_selector(nominal_phase)) & 0x0f]
def set_phase(status: int, nominal_phase: SinglePhaseKind, traced_phase: SinglePhaseKind) -> int:
if traced_phase == SinglePhaseKind.NONE:
return status & ~NOMINAL_PHASE_MASKS[nominal_phase.mask_index]
else:
return (status & ~NOMINAL_PHASE_MASKS[nominal_phase.mask_index]) | _shifted_value(nominal_phase, traced_phase)
def _byte_selector(nominal_phase: SinglePhaseKind) -> int:
return nominal_phase.mask_index * 4
def _shifted_value(nominal_phase: SinglePhaseKind, traced_phase: SinglePhaseKind) -> int:
return PHASE_TO_BITS[traced_phase] << _byte_selector(nominal_phase)
#todo split file into correct packages
@dataclass(slots=True)
class NominalPhasePath(object):
"""
Defines how a nominal phase is wired through a connectivity node between two terminals
"""
from_phase: SinglePhaseKind
"""The nominal phase where the path comes from."""
to_phase: SinglePhaseKind
"""The nominal phase where the path goes to."""
@dataclass(slots=True)
class TracedPhases(object):
"""
Class that holds the traced phase statuses for the current and normal state of the network.
Traced phase status:
| integer |
| 16 bits |16 bits |
| current | normal |
See [TracedPhasesBitManipulation] for details on bit representation for normal and current status.
"""
phase_status: int = 0
"""
The underlying implementation value tracking the phase statuses for the current and normal state of the network.
It is primarily used for data serialisation and debugging within official evolve libraries and utilities.
NOTE: This property should be considered evolve internal and not for public use as the underlying
data structure to store the status could change at any time (and thus be a breaking change).
Use at your own risk.
"""
_NORMAL_MASK = 0x0000ffff
_CURRENT_MASK = 0xffff0000
_CURRENT_SHIFT = 16
def __str__(self):
def to_string(select_phase):
return ', '.join([select_phase(phs).short_name for phs in PhaseCode.ABCN.single_phases])
return f"TracedPhases(normal={{{to_string(self.normal)}}}, current={{{to_string(self.current)}}})"
def normal(self, nominal_phase: SinglePhaseKind) -> SinglePhaseKind:
"""
Get the phase that was traced in the normal state of the network on this nominal phase.
`nominal_phase` The nominal phase to check.
Returns The `zepben.protobuf.cim.iec61970.base.wires.SinglePhaseKind` traced in the normal state of the network for the nominal phase, or
SinglePhaseKind.NONE if the nominal phase is de-energised.
Raises `NominalPhaseException` if the nominal phase is invalid.
"""
_valid_phase_check(nominal_phase)
return get_phase(self.phase_status, nominal_phase)
def current(self, nominal_phase: SinglePhaseKind) -> SinglePhaseKind:
"""
Get the phase that was traced in the current state of the network on this nominal phase.
`nominal_phase` The nominal phase to check.
Returns The `zepben.protobuf.cim.iec61970.base.wires.SinglePhaseKind` traced in the current state of the network for the nominal phase, or
SinglePhaseKind.NONE if the nominal phase is de-energised.
Raises `NominalPhaseException` if the nominal phase is invalid.
"""
_valid_phase_check(nominal_phase)
return get_phase(self.phase_status >> self._CURRENT_SHIFT, nominal_phase)
def set_normal(self, nominal_phase: SinglePhaseKind, traced_phase: SinglePhaseKind) -> bool:
"""
Set the phase that was traced in the normal state of the network on this nominal phase.
`nominal_phase` The nominal phase to use.
`traced_phase` The traced phase to apply to the nominal phase.
Returns True if there was a change, otherwise False.
Raises `PhaseException` if phases cross. i.e. you try to apply more than one phase to a nominal phase.
Raises `NominalPhaseException` if the nominal phase is invalid.
"""
it = self.normal(nominal_phase)
if it == traced_phase:
return False
elif (it == SinglePhaseKind.NONE) or (traced_phase == SinglePhaseKind.NONE):
self.phase_status = (self.phase_status & self._CURRENT_MASK) | set_phase(self.phase_status, nominal_phase, traced_phase)
return True
else:
raise PhaseException("Crossing Phases.")
def set_current(self, nominal_phase: SinglePhaseKind, traced_phase: SinglePhaseKind) -> bool:
"""
Set the phase that was traced in the current state of the network on this nominal phase.
`nominal_phase` The nominal phase to use.
`traced_phase` The traced phase to apply to the nominal phase.
Returns True if there was a change, otherwise False.
Raises `PhaseException` if phases cross. i.e. you try to apply more than one phase to a nominal phase.
Raises `NominalPhaseException` if the nominal phase is invalid.
"""
it = self.current(nominal_phase)
if it == traced_phase:
return False
elif (it == SinglePhaseKind.NONE) or (traced_phase == SinglePhaseKind.NONE):
self.phase_status = (self.phase_status & self._NORMAL_MASK) | (
set_phase(self.phase_status >> self._CURRENT_SHIFT, nominal_phase, traced_phase) << self._CURRENT_SHIFT)
return True
else:
raise PhaseException("Crossing Phases.")
@staticmethod
def copy():
return TracedPhases() | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/model/phases.py | phases.py |
from enum import Enum
__all__ = ["UnitSymbol", "unit_symbol_from_id", "unit_symbol_from_cim_name"]
def unit_symbol_from_cim_name(value: str):
return _unitsymbol_by_cim_name[value]
def unit_symbol_from_id(value: int):
return _unitsymbol_members_by_id[value]
class UnitSymbol(Enum):
"""
The derived units defined for usage in the CIM. In some cases, the derived unit is equal to an SI unit. Whenever possible, the standard derived symbol is
used instead of the formula for the derived unit. For example, the unit symbol Farad is defined as “F” instead of “CPerV”. In cases where a standard
symbol does not exist for a derived unit, the formula for the unit is used as the unit symbol. For example, density does not have a standard symbol and
so it is represented as “kgPerm3”. With the exception of the “kg”, which is an SI unit, the unit symbols do not contain multipliers and therefore
represent the base derived unit to which a multiplier can be applied as a whole. Every unit symbol is treated as an unparseable text as if it were a
single-letter symbol. The meaning of each unit symbol is defined by the accompanying descriptive text and not by the text contents of the unit symbol. To
allow the widest possible range of serializations without requiring special character handling, several substitutions are made which deviate from the
format described in IEC 80000-1. The division symbol “/” is replaced by the letters “Per”. Exponents are written in plain text after the unit as “m3”
instead of being formatted as “m” with a superscript of 3 or introducing a symbol as in “m^3”. The degree symbol “°” is replaced with the letters “deg”.
Any clarification of the meaning for a substitution is included in the description for the unit symbol. Non-SI units are included in list of unit symbols
to allow sources of data to be correctly labelled with their non-SI units (for example, a GPS sensor that is reporting numbers that represent feet
instead of meters). This allows software to use the unit symbol information correctly convert and scale the raw data of those sources into SI-based
units. The integer values are used for harmonization with IEC 61850.
"""
NONE = (0, "none")
"""Dimension less quantity, e.g. count, per unit, etc."""
METRES = (1, "m")
"""Length in metres."""
KG = (2, "kg")
"""Mass in kilograms. Note: multiplier “k” is included in this unit symbol for compatibility with IEC 61850-7-3."""
SECONDS = (3, "s")
"""Time in seconds."""
A = (4, "A")
"""Current in amperes."""
K = (5, "K")
"""Temperature in kelvins."""
MOL = (6, "mol")
"""Amount of substance in moles."""
CD = (7, "cd")
"""Luminous intensity in candelas."""
DEG = (8, "deg")
"""Plane angle in degrees."""
RAD = (9, "rad")
"""Plane angle in radians (m/m)."""
SR = (10, "sr")
"""Solid angle in steradians (m2/m2)."""
GY = (11, "Gy")
"""Absorbed dose in grays (J/kg)."""
BQ = (12, "Bq")
"""Radioactivity in becquerels (1/s)."""
DEGC = (13, "degC")
"""Relative temperature in degrees Celsius.In the SI unit system the symbol is °C. Electric charge is measured in coulomb that has the unit symbol C.
To distinguish degree Celsius from coulomb the symbol used in the UML is degC. The reason for not using °C is that the special character ° is difficult to
manage in software."""" """
SV = (14, "Sv")
"""Dose equivalent in sieverts (J/kg)."""
F = (15, "F")
"""Electric capacitance in farads (C/V)."""
C = (16, "C")
"""Electric charge in coulombs (A·s)."""
SIEMENS = (17, "S")
"""Conductance in siemens."""
HENRYS = (18, "H")
"""Electric inductance in henrys (Wb/A)."""
V = (19, "V")
"""Electric potential in volts (W/A)."""
OHM = (20, "ohm")
"""Electric resistance in ohms (V/A)."""
J = (21, "J")
"""Energy in joules (N·m = C·V = W·s)."""
N = (22, "N")
"""Force in newtons (kg·m/s²)."""
HZ = (23, "Hz")
"""Frequency in hertz (1/s)."""
LX = (24, "lx")
"""Illuminance in lux (lm/m²)."""
LM = (25, "lm")
"""Luminous flux in lumens (cd·sr)."""
WB = (26, "Wb")
"""Magnetic flux in webers (V·s)."""
T = (27, "T")
"""Magnetic flux density in teslas (Wb/m2)."""
W = (28, "W")
"""Real power in watts (J/s). Electrical power may have real and reactive components. The real portion of electrical power (I²R or VIcos(phi)),
is expressed in Watts. See also apparent power and reactive power."""
PA = (29, "Pa")
"""Pressure in pascals (N/m²). Note: the absolute or relative measurement of pressure is implied with this entry. See below for more explicit forms."""
M2 = (30, "m2")
"""Area in square metres (m²)."""
M3 = (31, "m3")
"""Volume in cubic metres (m³)."""
MPERS = (32, "mPers")
"""Velocity in metres per second (m/s)."""
MPERS2 = (33, "mPers2")
"""Acceleration in metres per second squared (m/s²)."""
M3PERS = (34, "m3Pers")
"""Volumetric flow rate in cubic metres per second (m³/s)."""
MPERM3 = (35, "mPerm3")
"""Fuel efficiency in metres per cubic metres (m/m³)."""
KGM = (36, "kgm")
"""Moment of mass in kilogram metres (kg·m) (first moment of mass).
Note: multiplier “k” is included in this unit symbol for compatibility with IEC 61850-7-3."""
KGPERM3 = (37, "kgPerm3")
"""Density in kilogram/cubic metres (kg/m³). Note: multiplier “k” is included in this unit symbol for compatibility with IEC 61850-7-3."""
M2PERS = (38, "m2Pers")
"""Viscosity in square metres / second (m²/s)."""
WPERMK = (39, "WPermK")
"""Thermal conductivity in watt/metres kelvin."""
JPERK = (40, "JPerK")
"""Heat capacity in joules/kelvin."""
PPM = (41, "ppm")
"""Concentration in parts per million."""
ROTPERS = (42, "rotPers")
"""Rotations per second (1/s). See also Hz (1/s)."""
RADPERS = (43, "radPers")
"""Angular velocity in radians per second (rad/s)."""
WPERM2 = (44, "WPerm2")
"""Heat flux density, irradiance, watts per square metre."""
JPERM2 = (45, "JPerm2")
"""Insulation energy density, joules per square metre or watt second per square metre."""
SPERM = (46, "SPerm")
"""Conductance per length (F/m)."""
KPERS = (47, "KPers")
"""Temperature change rate in kelvins per second."""
PAPERS = (48, "PaPers")
"""Pressure change rate in pascals per second."""
JPERKGK = (49, "JPerkgK")
"""Specific heat capacity, specific entropy, joules per kilogram Kelvin."""
VA = (50, "VA")
"""Apparent power in volt amperes. See also real power and reactive power."""
VAR = (51, "VAr")
"""
Reactive power in volt amperes reactive. The “reactive” or “imaginary” component of electrical power (VIsin(phi)). (See also real power and apparent power).
Note: Different meter designs use different methods to arrive at their results. Some meters may compute reactive power as an arithmetic value, while others
compute the value vectorially. The data consumer should determine the method in use and the suitability of the measurement for the intended purpose.
"""
COSPHI = (52, "cosPhi")
"""Power factor, dimensionless.
Note 1: This definition of power factor only holds for balanced systems. See the alternative definition under code 153.
Note 2 : Beware of differing sign conventions in use between the IEC and EEI. It is assumed that the data consumer understands the type of meter in use
and the sign convention in use by the utility."""
VS = (53, "Vs")
"""Volt seconds (Ws/A)."""
V2 = (54, "V2")
"""Volt squared (W²/A²)."""
AS = (55, "As")
"""Ampere seconds (A·s)."""
A2 = (56, "A2")
"""Amperes squared (A²)."""
A2S = (57, "A2s")
"""Ampere squared time in square amperes (A²s)."""
VAH = (58, "VAh")
"""Apparent energy in volt ampere hours."""
WH = (59, "Wh")
"""Real energy in watt hours."""
VARH = (60, "VArh")
"""Reactive energy in volt ampere reactive hours."""
VPERHZ = (61, "VPerHz")
"""Magnetic flux in volt per hertz."""
HZPERS = (62, "HzPers")
"""Rate of change of frequency in hertz per second."""
CHARACTER = (63, "character")
"""Number of characters."""
CHARPERS = (64, "charPers")
"""Data rate (baud) in characters per second."""
KGM2 = (65, "kgm2")
"""Moment of mass in kilogram square metres (kg·m²) (Second moment of mass, commonly called the moment of inertia). Note: multiplier “k” is included in
this unit symbol for compatibility with IEC 61850-7-3."""
DB = (66, "dB")
"""Sound pressure level in decibels. Note: multiplier “d” is included in this unit symbol for compatibility with IEC 61850-7-3."""
WPERS = (67, "WPers")
"""Ramp rate in watts per second."""
LPERS = (68, "lPers")
"""Volumetric flow rate in litres per second."""
DBM = (69, "dBm")
"""Power level (logarithmic ratio of signal strength , Bel-mW), normalized to 1mW.
Note: multiplier “d” is included in this unit symbol for compatibility with IEC 61850-7-3."""
HOURS = (70, "h")
"""Time in hours, hour = 60 min = 3600 s."""
MIN = (71, "min")
"""Time in minutes, minute = 60 s."""
Q = (72, "Q")
"""Quantity power, Q."""
QH = (73, "Qh")
"""Quantity energy, Qh."""
OHMM = (74, "ohmm")
"""Resistivity, ohm metres, (rho)."""
APERM = (75, "APerm")
"""A/m, magnetic field strength, amperes per metre."""
V2H = (76, "V2h")
"""Volt-squared hour, volt-squared-hours."""
A2H = (77, "A2h")
"""Ampere-squared hour, ampere-squared hour."""
AH = (78, "Ah")
"""Ampere-hours, ampere-hours."""
COUNT = (79, "count")
"""Amount of substance, Counter value."""
FT3 = (80, "ft3")
"""Volume, cubic feet."""
M3PERH = (81, "m3Perh")
"""Volumetric flow rate, cubic metres per hour."""
GAL = (82, "gal")
"""Volume in gallons, US gallon (1 gal = 231 in3 = 128 fl ounce)."""
BTU = (83, "Btu")
"""Energy, British Thermal Units."""
L = (84, "l")
"""Volume in litres, litre = dm3 = m3/1000."""
LPERH = (85, "lPerh")
"""Volumetric flow rate, litres per hour."""
LPERL = (86, "lPerl")
"""Concentration, The ratio of the volume of a solute divided by the volume of the solution.
Note: Users may need use a prefix such a ‘µ’ to express a quantity such as ‘µL/L’."""
GPERG = (87, "gPerg")
"""Concentration, The ratio of the mass of a solute divided by the mass of the solution.
Note: Users may need use a prefix such a ‘µ’ to express a quantity such as ‘µg/g’."""
MOLPERM3 = (88, "molPerm3")
"""Concentration, The amount of substance concentration, (c), the amount of solvent in moles divided by the volume of solution in m³."""
MOLPERMOL = (89, "molPermol")
"""Concentration, Molar fraction, the ratio of the molar amount of a solute divided by the molar amount of the solution."""
MOLPERKG = (90, "molPerkg")
"""Concentration, Molality, the amount of solute in moles and the amount of solvent in kilograms."""
SPERS = (91, "sPers")
"""Time, Ratio of time. Note: Users may need to supply a prefix such as ‘µ’ to show rates such as ‘µs/s’."""
HZPERHZ = (92, "HzPerHz")
"""Frequency, rate of frequency change. Note: Users may need to supply a prefix such as ‘m’ to show rates such as ‘mHz/Hz’."""
VPERV = (93, "VPerV")
"""Voltage, ratio of voltages. Note: Users may need to supply a prefix such as ‘m’ to show rates such as ‘mV/V’."""
APERA = (94, "APerA")
"""Current, ratio of amperages. Note: Users may need to supply a prefix such as ‘m’ to show rates such as ‘mA/A’."""
VPERVA = (95, "VPerVA")
"""Power factor, PF, the ratio of the active power to the apparent power.
Note: The sign convention used for power factor will differ between IEC meters and EEI (ANSI) meters.
It is assumed that the data consumers understand the type of meter being used and agree on the sign convention in use at any given utility."""
REV = (96, "rev")
"""Amount of rotation, revolutions."""
KAT = (97, "kat")
"""Catalytic activity, katal = mol / s."""
JPERKG = (98, "JPerkg")
"""Specific energy, Joules / kg."""
M3UNCOMPENSATED = (99, "m3Uncompensated")
"""Volume, cubic metres, with the value uncompensated for weather effects."""
M3COMPENSATED = (100, "m3Compensated")
"""Volume, cubic metres, with the value compensated for weather effects."""
WPERW = (101, "WPerW")
"""Signal Strength, ratio of power. Note: Users may need to supply a prefix such as ‘m’ to show rates such as ‘mW/W’."""
THERM = (102, "therm")
"""Energy, therms."""
ONEPERM = (103, "onePerm")
"""Wavenumber, reciprocal metres, (1/m)."""
M3PERKG = (104, "m3Perkg")
"""Specific volume, cubic metres per kilogram, v."""
PAS = (105, "Pas")
"""Dynamic viscosity, pascal seconds."""
NM = (106, "Nm")
"""Moment of force, newton metres."""
NPERM = (107, "NPerm")
"""Surface tension, newton per metre."""
RADPERS2 = (108, "radPers2")
"""Angular acceleration, radians per second squared."""
JPERM3 = (109, "JPerm3")
"""Energy density, joules per cubic metre."""
VPERM = (110, "VPerm")
"""Electric field strength, volts per metre."""
CPERM3 = (111, "CPerm3")
"""Electric charge density, coulombs per cubic metre."""
CPERM2 = (112, "CPerm2")
"""Surface charge density, coulombs per square metre."""
FPERM = (113, "FPerm")
"""Permittivity, farads per metre."""
HPERM = (114, "HPerm")
"""Permeability, henrys per metre."""
JPERMOL = (115, "JPermol")
"""Molar energy, joules per mole."""
JPERMOLK = (116, "JPermolK")
"""Molar entropy, molar heat capacity, joules per mole kelvin."""
CPERKG = (117, "CPerkg")
"""Exposure (x rays), coulombs per kilogram."""
GYPERS = (118, "GyPers")
"""Absorbed dose rate, grays per second."""
WPERSR = (119, "WPersr")
"""Radiant intensity, watts per steradian."""
WPERM2SR = (120, "WPerm2sr")
"""Radiance, watts per square metre steradian."""
KATPERM3 = (121, "katPerm3")
"""Catalytic activity concentration, katals per cubic metre."""
D = (122, "d")
"""Time in days, day = 24 h = 86400 s."""
ANGLEMIN = (123, "anglemin")
"""Plane angle, minutes."""
ANGLESEC = (124, "anglesec")
"""Plane angle, seconds."""
HA = (125, "ha")
"""Area, hectares."""
TONNE = (126, "tonne")
"""Mass in tons, “tonne” or “metric ton” (1000 kg = 1 Mg)."""
BAR = (127, "bar")
"""Pressure in bars, (1 bar = 100 kPa)."""
MMHG = (128, "mmHg")
"""Pressure, millimetres of mercury (1 mmHg is approximately 133.3 Pa)."""
MILES_NAUTICAL = (129, "M")
"""Length, nautical miles (1 M = 1852 m)."""
KN = (130, "kn")
"""Speed, knots (1 kn = 1852/3600) m/s."""
MX = (131, "Mx")
"""Magnetic flux, maxwells (1 Mx = 10-8 Wb)."""
G = (132, "G")
"""Magnetic flux density, gausses (1 G = 10-4 T)."""
OE = (133, "Oe")
"""Magnetic field in oersteds, (1 Oe = (103/4p) A/m)."""
VH = (134, "Vh")
"""Volt-hour, Volt hours."""
WPERA = (135, "WPerA")
"""Active power per current flow, watts per Ampere."""
ONEPERHZ = (136, "onePerHz")
"""Reciprocal of frequency (1/Hz)."""
VPERVAR = (137, "VPerVAr")
"""Power factor, PF, the ratio of the active power to the apparent power.
Note: The sign convention used for power factor will differ between IEC meters and EEI (ANSI) meters.
It is assumed that the data consumers understand the type of meter being used and agree on the sign convention in use at any given utility."""
OHMPERM = (138, "ohmPerm")
"""Electric resistance per length in ohms per metre ((V/A)/m)."""
KGPERJ = (139, "kgPerJ")
"""Weight per energy in kilograms per joule (kg/J). Note: multiplier “k” is included in this unit symbol for compatibility with IEC 61850-7-3."""
JPERS = (140, "JPers")
"""Energy rate in joules per second (J/s)."""
@property
def short_name(self):
return str(self)[11:]
@property
def name(self):
return self.value[1]
def id(self):
return self.value[0]
_unitsymbol_members_by_id = [us for us in UnitSymbol.__members__.values()]
_unitsymbol_by_cim_name = {str(us): us for us in UnitSymbol.__members__.values()} | zepben.evolve.test-ci-central | /zepben.evolve.test_ci_central-0.32.0-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/domain/unit_symbol.py | unit_symbol.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.