code
stringlengths 501
5.19M
| package
stringlengths 2
81
| path
stringlengths 9
304
| filename
stringlengths 4
145
|
|---|---|---|---|
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()
logger.info("Database saved.")
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 | /zepben.evolve-0.35.0b2-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_to_feeders().run(network_service)
logger.info("Equipment assigned to feeders.")
logger.info("Assigning equipment to LV feeders...")
tracing.assign_equipment_to_lv_feeders().run(network_service)
logger.info("Equipment assigned to LV 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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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, LvFeeder
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, LvFeeder, writer.save_lv_feeder)
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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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, TableLvFeeders, LvFeeder
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")
def save_lv_feeder(self, lv_feeder: LvFeeder) -> bool:
table = self.database_tables.get_table(TableLvFeeders)
insert = self.database_tables.get_insert(TableLvFeeders)
insert.add_value(table.normal_head_terminal_mrid.query_index, self._mrid_or_none(lv_feeder.normal_head_terminal))
return self._save_equipment_container(table, insert, lv_feeder, "lv_feeder")
# ************ 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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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(),
TableLvFeeders: TableLvFeeders(),
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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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__ = ["DuplicateMRIDException", "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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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, TableLvFeeders
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(TableLvFeeders, "lv feeders", reader.load_lv_feeder)
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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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, LvFeeder, TableLvFeeders
__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)
def load_lv_feeder(self, table: TableLvFeeders, rs: ResultSet, set_last_mrid: Callable[[str], str]) -> bool:
lv_feeder = LvFeeder(mrid=set_last_mrid(rs.get_string(table.mrid.query_index)))
lv_feeder.normal_head_terminal = self._ensure_get(rs.get_string(table.normal_head_terminal_mrid.query_index, None), Terminal)
return self._load_equipment_container(lv_feeder, table, rs) and self._add_or_throw(lv_feeder)
# ************ 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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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, IncludedEnergizingContainers, \
IncludedEnergizedContainers
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, LvFeeder
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],
include_energizing_containers: IncludedEnergizingContainers = IncludedEnergizingContainers.EXCLUDE_ENERGIZING_CONTAINERS,
include_energized_containers: IncludedEnergizedContainers = IncludedEnergizedContainers.EXCLUDE_ENERGIZED_CONTAINERS
) -> 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
- `container` - The :class:`EquipmentContainer` (or its mRID) to fetch equipment for.
- `include_energizing_containers` - The level of energizing containers to include equipment from.
- `include_energized_containers` - The level of energized containers to include equipment from.
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 object, accessible via `GrpcResult.thrown`.
Note the :class:`NetworkConsumerClient` warning in this case.
"""
return await self._get_equipment_for_container(container, include_energizing_containers, include_energized_containers)
async def get_equipment_for_containers(
self,
containers: Iterable[str],
include_energizing_containers: IncludedEnergizingContainers = IncludedEnergizingContainers.EXCLUDE_ENERGIZING_CONTAINERS,
include_energized_containers: IncludedEnergizedContainers = IncludedEnergizedContainers.EXCLUDE_ENERGIZED_CONTAINERS
):
"""
Retrieve the :class:`Equipment` for the :class:`EquipmentContainer`'s represented in `containers`
Exceptions that occur during retrieval will be caught and passed to all error handlers that have been registered against this client.
Parameters
- `containers` - The mRIDs of :class:`EquipmentContainer`'s to fetch equipment for.
- `include_energizing_containers` - The level of energizing containers to include equipment from.
- `include_energized_containers` - The level of energized containers to include equipment from.
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 object, accessible via `GrpcResult.thrown`.
Note the :class:`NetworkConsumerClient` warning in this case.
"""
return await self._get_equipment_for_containers(containers, include_energizing_containers, include_energized_containers)
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 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 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 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,
include_energizing_containers: IncludedEnergizingContainers = IncludedEnergizingContainers.EXCLUDE_ENERGIZING_CONTAINERS,
include_energized_containers: IncludedEnergizedContainers = IncludedEnergizedContainers.EXCLUDE_ENERGIZED_CONTAINERS
) -> 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
- `mrid` - The mRID of the :class:`EquipmentContainer` to fetch.
- `expected_class` - The expected type of the fetched container.
- `include_energizing_containers` - The level of energizing containers to include equipment from.
- `include_energized_containers` - The level of energized containers to include equipment from.
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, include_energizing_containers, include_energized_containers)
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 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 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 `NetworkService` from the server.
"""
return await self._retrieve_network()
async def _get_equipment_for_container(
self,
container: Union[str, EquipmentContainer],
include_energizing_containers: IncludedEnergizingContainers = IncludedEnergizingContainers.EXCLUDE_ENERGIZING_CONTAINERS,
include_energized_containers: IncludedEnergizedContainers = IncludedEnergizedContainers.EXCLUDE_ENERGIZED_CONTAINERS
) -> GrpcResult[MultiObjectResult]:
return await self._handle_multi_object_rpc(
lambda: self._process_equipment_for_container(container, include_energizing_containers, include_energized_containers)
)
async def _get_equipment_for_containers(
self,
containers: Iterable[str],
include_energizing_containers: IncludedEnergizingContainers = IncludedEnergizingContainers.EXCLUDE_ENERGIZING_CONTAINERS,
include_energized_containers: IncludedEnergizedContainers = IncludedEnergizedContainers.EXCLUDE_ENERGIZED_CONTAINERS
) -> GrpcResult[MultiObjectResult]:
return await self._handle_multi_object_rpc(
lambda: self._process_equipment_for_containers(containers, include_energizing_containers, include_energized_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,
include_energizing_containers: IncludedEnergizingContainers = IncludedEnergizingContainers.EXCLUDE_ENERGIZING_CONTAINERS,
include_energized_containers: IncludedEnergizedContainers = IncludedEnergizedContainers.EXCLUDE_ENERGIZED_CONTAINERS
) -> GrpcResult[MultiObjectResult]:
async def get_additional(it: EquipmentContainer, mor: MultiObjectResult) -> Optional[GrpcResult[MultiObjectResult]]:
result = await self._get_equipment_for_container(it, include_energizing_containers, include_energized_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, 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],
include_energizing_containers: IncludedEnergizingContainers,
include_energized_containers: IncludedEnergizedContainers
) -> AsyncGenerator[IdentifiedObject, None]:
mrid = it.mrid if isinstance(it, EquipmentContainer) else it
request = GetEquipmentForContainersRequest()
request.includeEnergizingContainers = include_energizing_containers
request.includeEnergizedContainers = include_energized_containers
responses = self._stub.getEquipmentForContainers(self._batch_send(request, [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],
include_energizing_containers: IncludedEnergizingContainers,
include_energized_containers: IncludedEnergizedContainers
) -> AsyncGenerator[IdentifiedObject, None]:
request = GetEquipmentForContainersRequest()
request.includeEnergizingContainers = include_energizing_containers
request.includeEnergizedContainers = include_energized_containers
responses = self._stub.getEquipmentForContainers(self._batch_send(request, 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,
container: Union[str, EquipmentContainer],
include_energizing_containers: IncludedEnergizingContainers = IncludedEnergizingContainers.EXCLUDE_ENERGIZING_CONTAINERS,
include_energized_containers: IncludedEnergizedContainers = IncludedEnergizedContainers.EXCLUDE_ENERGIZED_CONTAINERS
) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(super().get_equipment_for_container(container, include_energizing_containers, include_energized_containers))
def get_equipment_for_containers(
self,
containers: Iterable[str],
include_energizing_containers: IncludedEnergizingContainers = IncludedEnergizingContainers.EXCLUDE_ENERGIZING_CONTAINERS,
include_energized_containers: IncludedEnergizedContainers = IncludedEnergizedContainers.EXCLUDE_ENERGIZED_CONTAINERS
) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(
super().get_equipment_for_containers(containers, include_energizing_containers, include_energized_containers)
)
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,
include_energizing_containers: IncludedEnergizingContainers = IncludedEnergizingContainers.EXCLUDE_ENERGIZING_CONTAINERS,
include_energized_containers: IncludedEnergizedContainers = IncludedEnergizedContainers.EXCLUDE_ENERGIZED_CONTAINERS
) -> GrpcResult[MultiObjectResult]:
return get_event_loop().run_until_complete(
super().get_equipment_container(mrid, expected_class, include_energizing_containers, include_energized_containers)
)
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,
"lvFeeder": LvFeeder
} | zepben.evolve | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/streaming/get/diagram_consumer.py | diagram_consumer.py |
from abc import ABC
from typing import Optional
import grpc
from zepben.auth import ZepbenTokenFetcher
__all__ = ["GrpcChannelBuilder"]
from zepben.evolve.streaming.grpc.auth_token_plugin import AuthTokenPlugin
class GrpcChannelBuilder(ABC):
"""
Builder class for gRPC channels to connect to EWB's gRPC service.
"""
def __init__(self):
self._socket_address: str = "localhost:50051"
self._channel_credentials: Optional[grpc.ChannelCredentials] = None
def build(self) -> grpc.aio.Channel:
"""
Get the resulting :class:`grpc.aio.Channel` from this builder.
:return: A gRPC channel resulting from this builder.
"""
if self._channel_credentials:
return grpc.aio.secure_channel(self._socket_address, self._channel_credentials)
return grpc.aio.insecure_channel(self._socket_address)
def for_address(self, host: str, port: int) -> 'GrpcChannelBuilder':
"""
Specify the address for the gRPC channel.
:param host: The hostname hosting the gRPC service
:param port: The port of the gRPC service
:return: This builder
"""
self._socket_address = f"{host}:{port}"
return self
def make_secure(
self,
root_certificates: Optional[str] = None,
certificate_chain: Optional[str] = None,
private_key: Optional[str] = None
) -> 'GrpcChannelBuilder':
"""
Secures channel with SSL credentials.
:param root_certificates: The filename of the truststore to use when verifying the RPC service's SSL/TLS certificate
:param certificate_chain: The filename of the certificate chain to use for client authentication
:param private_key: The filename of the private key to use for client authentication
:return: This builder
"""
root_certificates_bytes = None
if root_certificates is not None:
with open(root_certificates, "rb") as f:
root_certificates_bytes = f.read()
certificate_chain_bytes = None
if certificate_chain is not None:
with open(certificate_chain, "rb") as f:
certificate_chain_bytes = f.read()
private_key_bytes = None
if private_key is not None:
with open(private_key, "rb") as f:
private_key_bytes = f.read()
return self.make_secure_with_bytes(root_certificates_bytes, certificate_chain_bytes, private_key_bytes)
def make_secure_with_bytes(
self,
root_certificates_bytes: Optional[bytes] = None,
certificate_chain_bytes: Optional[bytes] = None,
private_key_bytes: Optional[bytes] = None
) -> 'GrpcChannelBuilder':
"""
Secures channel with SSL credentials.
:param root_certificates_bytes: The bytestring truststore to use when verifying the RPC service's SSL/TLS certificate
:param certificate_chain_bytes: The bytestring certificate chain to use for client authentication
:param private_key_bytes: The bytestring private key to use for client authentication
:return: This builder
"""
self._channel_credentials = grpc.ssl_channel_credentials(root_certificates_bytes, private_key_bytes, certificate_chain_bytes)
return self
def with_token_fetcher(self, token_fetcher: ZepbenTokenFetcher) -> 'GrpcChannelBuilder':
"""
Authenticates calls for the gRPC channel using a :class:`ZepbenTokenFetcher`.
:param token_fetcher: The :class:`ZepbenTokenFetcher` to use to fetch access tokens.
:return: This builder
"""
if self._channel_credentials is None:
raise Exception("You must call make_secure before calling with_token_fetcher.")
self._channel_credentials = grpc.composite_channel_credentials(
self._channel_credentials,
grpc.metadata_call_credentials(AuthTokenPlugin(token_fetcher=token_fetcher))
)
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/streaming/grpc/grpc_channel_builder.py | grpc_channel_builder.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 | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/streaming/grpc/grpc.py | grpc.py |
from typing import Optional, Union
import grpc
from zepben.auth import ZepbenTokenFetcher, create_token_fetcher
from zepben.evolve import GrpcChannelBuilder
__all__ = ["connect_tls", "connect_insecure", "connect_with_password", "connect_with_secret"]
GRPC_READY_TIMEOUT = 20 # seconds
def connect_insecure(
host: str = "localhost",
rpc_port: int = 50051
) -> grpc.aio.Channel:
"""
Create a :class:`grpc.aio.Channel` that communicates with the gRPC service over plaintext.
:param host: The hostname where the gRPC service is hosted
:param rpc_port: The port of the gRPC service
:return: A plaintext connection to the gRPC service
"""
return GrpcChannelBuilder().for_address(host, rpc_port).build()
def connect_tls(
host: str = "localhost",
rpc_port: int = 50051,
ca_filename: Optional[str] = None
) -> grpc.aio.Channel:
"""
Create a :class:`grpc.aio.Channel` that communicates with the gRPC service using SSL/TLS transport security.
:param host: The hostname where the gRPC service is hosted
:param rpc_port: The port of the gRPC service
:param ca_filename: The filename of a truststore containing additional trusted root certificates. This parameter is optional
and defaults to null, in which case only the system CAs are used to verify certificates.
:return:An encrypted connection to the gRPC service
"""
return GrpcChannelBuilder().for_address(host, rpc_port).make_secure(root_certificates=ca_filename).build()
def connect_with_secret(
client_id: str,
client_secret: str,
host: str = "localhost",
rpc_port: int = 50051,
conf_address: Optional[str] = None,
verify_conf: Union[bool, str] = True,
verify_auth: Union[bool, str] = True,
ca_filename: Optional[str] = None,
**kwargs
) -> grpc.aio.Channel:
"""
Create a :class:`grpc.aio.Channel` that communicates with the gRPC service using SSL/TLS transport security and the OAuth client credentials flow.
The OAuth provider's domain and the "audience" parameter of the token request are fetched as JSON from a specified URL.
:param client_id: The client ID of the OAuth application to authenticate for
:param client_secret: The client secret of the OAuth application to authenticate for
:param host: The hostname where the gRPC service is hosted
:param rpc_port: The port of the gRPC service
:param conf_address: The address of the authentication configuration
:param verify_conf: Passed through to `requests.get()` when fetching the authentication configuration
:param verify_auth: Passed through to `requests.post()` when fetching access tokens
:param ca_filename: The filename of a truststore containing additional trusted root certificates. This parameter is optional
and defaults to null, in which case only the system CAs are used to verify certificates.
:param kwargs: If `audience: str` and `issuer_domain: str` are specified, `kwargs` will be used as parameters
to construct the :class:`ZepbenTokenFetcher` directly.
:return: An Auth0-authenticated, encrypted connection to the gRPC service. If the authentication configuration specifies that no authentication is
required, a non-authenticated, encrypted connection is returned instead.
"""
if {"audience", "issuer_domain"} <= kwargs.keys():
# noinspection PyArgumentList
token_fetcher = ZepbenTokenFetcher(**kwargs)
else:
token_fetcher = create_token_fetcher(
conf_address=conf_address or f"https://{host}/ewb/auth",
verify_conf=verify_conf,
verify_auth=verify_auth
)
if token_fetcher:
return _connect_with_secret_using_token_fetcher(token_fetcher, client_id, client_secret, host, rpc_port, ca_filename)
else:
return connect_tls(host, rpc_port, ca_filename)
def connect_with_password(
client_id: str,
username: str,
password: str,
host: str = "localhost",
rpc_port: int = 50051,
conf_address: Optional[str] = None,
verify_conf: Union[bool, str] = True,
verify_auth: Union[bool, str] = True,
ca_filename: Optional[str] = None,
**kwargs
) -> grpc.aio.Channel:
"""
Create a :class:`grpc.aio.Channel` that communicates with the gRPC service using SSL/TLS transport security and the OAuth password grant flow.
The OAuth provider's domain and the "audience" parameter of the token request are fetched as JSON from a specified URL.
:param client_id: The client ID of the OAuth application to authenticate for
:param username: The username of the user to authenticate with
:param password: The password of the user to authenticate with
:param host: The hostname where the gRPC service is hosted
:param rpc_port: The port of the gRPC service
:param conf_address: The address of the authentication configuration
:param verify_conf: Passed through to `requests.get()` when fetching the authentication configuration
:param verify_auth: Passed through to `requests.post()` when fetching access tokens
:param ca_filename: The filename of a truststore containing additional trusted root certificates. This parameter is optional
and defaults to null, in which case only the system CAs are used to verify certificates.
:param kwargs: If `audience: str` and `issuer_domain: str` are specified, `kwargs` will be used as parameters
to construct the :class:`ZepbenTokenFetcher` directly.
:return: An Auth0-authenticated, encrypted connection to the gRPC service. If the authentication configuration specifies that no authentication is
required, a non-authenticated, encrypted connection is returned instead.
"""
if {"audience", "issuer_domain"} <= kwargs.keys():
# noinspection PyArgumentList
token_fetcher = ZepbenTokenFetcher(**kwargs)
else:
token_fetcher = create_token_fetcher(
conf_address=conf_address or f"https://{host}/ewb/auth",
verify_conf=verify_conf,
verify_auth=verify_auth
)
if token_fetcher:
return _connect_with_password_using_token_fetcher(token_fetcher, client_id, username, password, host, rpc_port, ca_filename)
else:
return connect_tls(host, rpc_port, ca_filename)
def _connect_with_secret_using_token_fetcher(
token_fetcher: ZepbenTokenFetcher,
client_id: str,
client_secret: str,
host: str,
rpc_port: int,
ca_filename: Optional[str]
) -> grpc.aio.Channel:
token_fetcher.token_request_data["client_id"] = client_id
token_fetcher.token_request_data["client_secret"] = client_secret
token_fetcher.token_request_data["grant_type"] = "client_credentials"
return GrpcChannelBuilder().for_address(host, rpc_port).make_secure(root_certificates=ca_filename).with_token_fetcher(token_fetcher).build()
def _connect_with_password_using_token_fetcher(
token_fetcher: ZepbenTokenFetcher,
client_id: str,
username: str,
password: str,
host: str,
rpc_port: int,
ca_filename: Optional[str]
) -> grpc.aio.Channel:
token_fetcher.token_request_data["client_id"] = client_id
token_fetcher.token_request_data["username"] = username
token_fetcher.token_request_data["password"] = password
token_fetcher.token_request_data["grant_type"] = "password"
token_fetcher.token_request_data["scope"] = "offline_access"
return GrpcChannelBuilder().for_address(host, rpc_port).make_secure(root_certificates=ca_filename).with_token_fetcher(token_fetcher).build() | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/streaming/grpc/connect.py | connect.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 `Terminal`` to a `ConnectivityNode`
`terminal` The `Terminal` to connect.
`connectivity_node` The `ConnectivityNode` to connect ``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 `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 `PowerSystemResource` or a
`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 `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 `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 `Terminal` to the `ConnectivityNode` with mRID `connectivity_node_mrid`
`terminal` The `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 `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 `Terminal`s
Returns True if the `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 `Terminal`` from its `ConnectivityNode`. Will also remove the `ConnectivityNode` from this
`Network` if it no longer has any terminals.
`terminal` The `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 ``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 | /zepben.evolve-0.35.0b2-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, LvFeeder, CurrentTransformerInfo, PotentialTransformerInfo, CurrentTransformer, PotentialTransformer
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 infIEC61968 InfAssetInfo #
#####################################
def _compare_current_transformer_info(self, source: CurrentTransformerInfo, target: CurrentTransformerInfo) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(
diff,
CurrentTransformerInfo.accuracy_class,
CurrentTransformerInfo.core_count,
CurrentTransformerInfo.ct_class,
CurrentTransformerInfo.knee_point_voltage,
CurrentTransformerInfo.max_ratio,
CurrentTransformerInfo.nominal_ratio,
CurrentTransformerInfo.rated_current,
CurrentTransformerInfo.secondary_fls_rating,
CurrentTransformerInfo.usage
)
self._compare_floats(
diff,
CurrentTransformerInfo.accuracy_limit,
CurrentTransformerInfo.primary_ratio,
CurrentTransformerInfo.secondary_ratio
)
return self._compare_asset_info(diff)
def _compare_potential_transformer_info(self, source: PotentialTransformerInfo, target: PotentialTransformerInfo) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(
diff,
PotentialTransformerInfo.accuracy_class,
PotentialTransformerInfo.nominal_ratio,
PotentialTransformerInfo.pt_class,
PotentialTransformerInfo.rated_voltage,
)
self._compare_floats(
diff,
PotentialTransformerInfo.primary_ratio,
PotentialTransformerInfo.secondary_ratio
)
return self._compare_asset_info(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_current_transformer(self, source: CurrentTransformer, target: CurrentTransformer) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, CurrentTransformer.core_burden)
return self._compare_sensor(diff)
def _compare_fault_indicator(self, source: FaultIndicator, target: FaultIndicator) -> ObjectDifference:
return self._compare_auxiliary_equipment(ObjectDifference(source, target))
def _compare_potential_transformer(self, source: PotentialTransformer, target: PotentialTransformer) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_values(diff, PotentialTransformer.type)
return self._compare_sensor(diff)
def _compare_sensor(self, diff: ObjectDifference) -> ObjectDifference:
return self._compare_auxiliary_equipment(diff)
######################
# 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_containers)
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)
self._compare_id_reference_collections(diff, Feeder.normal_energized_lv_feeders)
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)
def _compare_lv_feeder(self, source: LvFeeder, target: LvFeeder) -> ObjectDifference:
diff = ObjectDifference(source, target)
self._compare_id_references(diff, LvFeeder.normal_head_terminal)
self._compare_id_reference_collections(diff, LvFeeder.normal_energizing_feeders)
if self._options.compare_feeder_equipment:
self._compare_id_reference_collections(diff, LvFeeder.current_equipment)
return self._compare_equipment_container(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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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.CurrentTransformerInfo_pb2 import CurrentTransformerInfo as PBCurrentTransformerInfo
from zepben.protobuf.cim.iec61968.infiec61968.infassetinfo.PotentialTransformerInfo_pb2 import PotentialTransformerInfo as PBPotentialTransformerInfo
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.infiec61968.infcommon.Ratio_pb2 import Ratio as PBRatio
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.CurrentTransformer_pb2 import CurrentTransformer as PBCurrentTransformer
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.FaultIndicator_pb2 import FaultIndicator as PBFaultIndicator
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.PotentialTransformer_pb2 import PotentialTransformer as PBPotentialTransformer
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.PotentialTransformerKind_pb2 import PotentialTransformerKind as PBPotentialTransformerKind
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.Sensor_pb2 import Sensor as PBSensor
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.cim.iec61970.infiec61970.feeder.LvFeeder_pb2 import LvFeeder as PBLvFeeder
from zepben.protobuf.network.model.FeederDirection_pb2 import FeederDirection as PBFeederDirection
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.power_transformer_info 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.assetinfo.transformer_test 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.infiec61968.infassetinfo.current_transformer_info import *
from zepben.evolve.model.cim.iec61968.infiec61968.infassetinfo.potential_transformer_info import *
from zepben.evolve.model.cim.iec61968.infiec61968.infcommon.ratio 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.auxiliaryequipment.current_transformer import *
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.potential_transformer import *
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.sensor 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.base.wires.transformer_star_impedance 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.cim.iec61970.infiec61970.feeder.lv_feeder 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", "lv_feeder_to_pb", "transformer_star_impedance_to_pb",
"current_transformer_info_to_pb", "potential_transformer_info_to_pb", "current_transformer_to_pb", "potential_transformer_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
StreetDetail.to_pb = street_detail_to_pb
TownDetail.to_pb = town_detail_to_pb
#####################################
# IEC61968 infIEC61968 InfAssetInfo #
#####################################
def current_transformer_info_to_pb(cim: CurrentTransformerInfo) -> PBCurrentTransformerInfo:
return PBCurrentTransformerInfo(
ai=asset_info_to_pb(cim),
accuracyClass=cim.accuracy_class,
accuracyLimit=from_nullable_float(cim.accuracy_limit),
coreCount=from_nullable_int(cim.core_count),
ctClass=cim.ct_class,
kneePointVoltage=from_nullable_int(cim.knee_point_voltage),
maxRatio=_get_or_none(ratio_to_pb, cim.max_ratio),
nominalRatio=_get_or_none(ratio_to_pb, cim.nominal_ratio),
primaryRatio=from_nullable_float(cim.primary_ratio),
ratedCurrent=from_nullable_int(cim.rated_current),
secondaryFlsRating=from_nullable_int(cim.secondary_fls_rating),
secondaryRatio=from_nullable_float(cim.secondary_ratio),
usage=cim.usage
)
def potential_transformer_info_to_pb(cim: PotentialTransformerInfo) -> PBPotentialTransformerInfo:
return PBPotentialTransformerInfo(
ai=asset_info_to_pb(cim),
accuracyClass=cim.accuracy_class,
nominalRatio=_get_or_none(ratio_to_pb, cim.nominal_ratio),
primaryRatio=from_nullable_float(cim.primary_ratio),
ptClass=cim.pt_class,
ratedVoltage=from_nullable_int(cim.rated_voltage),
secondaryRatio=from_nullable_float(cim.secondary_ratio)
)
CurrentTransformerInfo.to_pb = current_transformer_info_to_pb
PotentialTransformerInfo.to_pb = potential_transformer_info_to_pb
##################################
# IEC61968 infIEC61968 InfCommon #
##################################
def ratio_to_pb(cim: Ratio) -> PBRatio:
return PBRatio(denominator=cim.denominator, numerator=cim.numerator)
Ratio.to_pb = ratio_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, include_asset_info: bool = False) -> PBAuxiliaryEquipment:
return PBAuxiliaryEquipment(
eq=equipment_to_pb(cim, include_asset_info),
terminalMRID=mrid_or_empty(cim.terminal)
)
def current_transformer_to_pb(cim: CurrentTransformer) -> PBCurrentTransformer:
return PBCurrentTransformer(
sn=sensor_to_pb(cim, True),
coreBurden=from_nullable_int(cim.core_burden)
)
def fault_indicator_to_pb(cim: FaultIndicator) -> PBFaultIndicator:
return PBFaultIndicator(ae=auxiliary_equipment_to_pb(cim))
def potential_transformer_to_pb(cim: PotentialTransformer) -> PBPotentialTransformer:
return PBPotentialTransformer(
sn=sensor_to_pb(cim, True),
type=PBPotentialTransformerKind.Value(cim.type.short_name)
)
def sensor_to_pb(cim: Sensor, include_asset_info: bool = False) -> PBSensor:
return PBSensor(ae=auxiliary_equipment_to_pb(cim, include_asset_info))
AuxiliaryEquipment.to_pb = auxiliary_equipment_to_pb
CurrentTransformer.to_pb = current_transformer_to_pb
FaultIndicator.to_pb = fault_indicator_to_pb
PotentialTransformer.to_pb = potential_transformer_to_pb
Sensor.to_pb = sensor_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],
currentContainerMRIDs=[str(io.mrid) for io in cim.current_containers]
)
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),
normalEnergizedLvFeederMRIDs=[str(io.mrid) for io in cim.normal_energized_lv_feeders]
)
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]
)
def lv_feeder_to_pb(cim: LvFeeder) -> PBLvFeeder:
return PBLvFeeder(
ec=equipment_container_to_pb(cim),
normalHeadTerminalMRID=mrid_or_empty(cim.normal_head_terminal),
normalEnergizingFeederMRIDs=[str(io.mrid) for io in cim.normal_energizing_feeders]
)
Circuit.to_pb = circuit_to_pb
Loop.to_pb = loop_to_pb
LvFeeder.to_pb = lv_feeder_to_pb | zepben.evolve | /zepben.evolve-0.35.0b2-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.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.CurrentTransformerInfo_pb2 import CurrentTransformerInfo as PBCurrentTransformerInfo
from zepben.protobuf.cim.iec61968.infiec61968.infassetinfo.PotentialTransformerInfo_pb2 import PotentialTransformerInfo as PBPotentialTransformerInfo
from zepben.protobuf.cim.iec61968.infiec61968.infcommon.Ratio_pb2 import Ratio as PBRatio
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.CurrentTransformer_pb2 import CurrentTransformer as PBCurrentTransformer
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.FaultIndicator_pb2 import FaultIndicator as PBFaultIndicator
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.PotentialTransformer_pb2 import PotentialTransformer as PBPotentialTransformer
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.Sensor_pb2 import Sensor as PBSensor
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
from zepben.protobuf.cim.iec61970.infiec61970.feeder.LvFeeder_pb2 import LvFeeder as PBLvFeeder
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.power_transformer_info 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.assetinfo.transformer_test 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.infiec61968.infassetinfo.current_transformer_info import *
from zepben.evolve.model.cim.iec61968.infiec61968.infassetinfo.potential_transformer_info 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.iec61968.infiec61968.infcommon.ratio 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.auxiliaryequipment.current_transformer import *
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.potential_transformer import *
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.potential_transformer_kind import *
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.sensor 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.transformer_star_impedance 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.model.cim.iec61970.infiec61970.feeder.lv_feeder import *
from zepben.evolve.model.phases import TracedPhases
import zepben.evolve.services.common.resolver as resolver
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
from zepben.evolve.services.network.tracing.feeder.feeder_direction import FeederDirection
__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", "lv_feeder_to_cim", "current_transformer_info_to_cim",
"potential_transformer_info_to_cim", "current_transformer_to_cim", "potential_transformer_to_cim"
]
#######################
# IEC61968 ASSET INFO #
#######################
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
PBStreetAddress.to_cim = street_address_to_cim
PBStreetDetail.to_cim = street_detail_to_cim
PBTownDetail.to_cim = town_detail_to_cim
#####################################
# IEC61968 infIEC61968 InfAssetInfo #
#####################################
def current_transformer_info_to_cim(pb: PBCurrentTransformerInfo, network_service: NetworkService) -> Optional[CurrentTransformerInfo]:
cim = CurrentTransformerInfo(
mrid=pb.mrid(),
accuracy_class=str_or_none(pb.accuracyClass),
accuracy_limit=float_or_none(pb.accuracyLimit),
core_count=int_or_none(pb.coreCount),
ct_class=str_or_none(pb.ctClass),
knee_point_voltage=int_or_none(pb.kneePointVoltage),
max_ratio=ratio_to_cim(pb.maxRatio) if pb.HasField('maxRatio') else None,
nominal_ratio=ratio_to_cim(pb.nominalRatio) if pb.HasField('nominalRatio') else None,
primary_ratio=float_or_none(pb.primaryRatio),
rated_current=int_or_none(pb.ratedCurrent),
secondary_fls_rating=int_or_none(pb.secondaryFlsRating),
secondary_ratio=float_or_none(pb.secondaryRatio),
usage=str_or_none(pb.usage)
)
asset_info_to_cim(pb.ai, cim, network_service)
return cim if network_service.add(cim) else None
def potential_transformer_info_to_cim(pb: PBPotentialTransformerInfo, network_service: NetworkService) -> Optional[PotentialTransformerInfo]:
cim = PotentialTransformerInfo(
mrid=pb.mrid(),
accuracy_class=str_or_none(pb.accuracyClass),
nominal_ratio=ratio_to_cim(pb.nominalRatio) if pb.HasField('nominalRatio') else None,
primary_ratio=float_or_none(pb.primaryRatio),
pt_class=str_or_none(pb.ptClass),
rated_voltage=int_or_none(pb.ratedVoltage),
secondary_ratio=float_or_none(pb.secondaryRatio)
)
asset_info_to_cim(pb.ai, cim, network_service)
return cim if network_service.add(cim) else None
PBCurrentTransformerInfo.to_cim = current_transformer_info_to_cim
PBPotentialTransformerInfo.to_cim = potential_transformer_info_to_cim
##################################
# IEC61968 infIEC61968 InfCommon #
##################################
def ratio_to_cim(pb: PBRatio) -> Ratio:
return Ratio(pb.numerator, pb.denominator)
PBRatio.to_cim = ratio_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 current_transformer_to_cim(pb: PBCurrentTransformer, network_service: NetworkService) -> Optional[CurrentTransformer]:
cim = CurrentTransformer(mrid=pb.mrid(), core_burden=int_or_none(pb.coreBurden))
network_service.resolve_or_defer_reference(resolver.current_transformer_info(cim), pb.asset_info_mrid())
sensor_to_cim(pb.sn, cim, network_service)
return cim if network_service.add(cim) else None
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
def potential_transformer_to_cim(pb: PBPotentialTransformer, network_service: NetworkService) -> Optional[PotentialTransformer]:
cim = PotentialTransformer(mrid=pb.mrid(), type=PotentialTransformerKind(pb.type))
network_service.resolve_or_defer_reference(resolver.potential_transformer_info(cim), pb.asset_info_mrid())
sensor_to_cim(pb.sn, cim, network_service)
return cim if network_service.add(cim) else None
def sensor_to_cim(pb: PBSensor, cim: Sensor, network_service: NetworkService):
auxiliary_equipment_to_cim(pb.ae, cim, network_service)
PBAuxiliaryEquipment.to_cim = auxiliary_equipment_to_cim
PBCurrentTransformer.to_cim = current_transformer_to_cim
PBFaultIndicator.to_cim = fault_indicator_to_cim
PBPotentialTransformer.to_cim = potential_transformer_to_cim
PBSensor.to_cim = sensor_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.currentContainerMRIDs:
network_service.resolve_or_defer_reference(resolver.current_containers(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)
for mrid in pb.normalEnergizedLvFeederMRIDs:
network_service.resolve_or_defer_reference(resolver.normal_energized_lv_feeders(cim), mrid)
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_energized_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)
)
# Set end number before associating with power transformer to prevent incorrectly sorted cim.power_transformer.ends
transformer_end_to_cim(pb.te, cim, network_service)
network_service.resolve_or_defer_reference(resolver.power_transformer(cim), pb.powerTransformerMRID)
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.to_cim = 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
def lv_feeder_to_cim(pb: PBLvFeeder, network_service: NetworkService) -> Optional[LvFeeder]:
cim = LvFeeder(mrid=pb.mrid())
network_service.resolve_or_defer_reference(resolver.lv_feeder_normal_head_terminal(cim), pb.normalHeadTerminalMRID)
for mrid in pb.normalEnergizingFeederMRIDs:
network_service.resolve_or_defer_reference(resolver.normal_energizing_feeders(cim), mrid)
equipment_container_to_cim(pb.ec, cim, network_service)
return cim if network_service.add(cim) else None
PBCircuit.to_cim = circuit_to_cim
PBLoop.to_cim = loop_to_cim
PBLvFeeder.to_cim = lv_feeder_to_cim | zepben.evolve | /zepben.evolve-0.35.0b2-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.infiec61968.infassetinfo.CurrentTransformerInfo_pb2 import CurrentTransformerInfo
from zepben.protobuf.cim.iec61968.infiec61968.infassetinfo.PotentialTransformerInfo_pb2 import PotentialTransformerInfo
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.CurrentTransformer_pb2 import CurrentTransformer
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.FaultIndicator_pb2 import FaultIndicator
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.PotentialTransformer_pb2 import PotentialTransformer
from zepben.protobuf.cim.iec61970.base.auxiliaryequipment.Sensor_pb2 import Sensor
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
from zepben.protobuf.cim.iec61970.infiec61970.feeder.LvFeeder_pb2 import LvFeeder
__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()
CurrentTransformerInfo.mrid = lambda self: self.ai.mrid()
PotentialTransformerInfo.mrid = lambda self: self.ai.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()
CurrentTransformer.mrid = lambda self: self.sn.mrid()
FaultIndicator.mrid = lambda self: self.ae.mrid()
PotentialTransformer.mrid = lambda self: self.sn.mrid()
Sensor.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()
LvFeeder.mrid = lambda self: self.ec.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.asset_info_mrid()
Conductor.asset_info_mrid = lambda self: self.ce.asset_info_mrid()
CurrentTransformer.asset_info_mrid = lambda self: self.sn.ae.eq.asset_info_mrid()
Equipment.asset_info_mrid = lambda self: self.psr.assetInfoMRID
PotentialTransformer.asset_info_mrid = lambda self: self.sn.ae.eq.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 | /zepben.evolve-0.35.0b2-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, BasicTraversal
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")
tracing_logger = logging.getLogger("queue_next")
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 = BasicTraversal(queue_next=queue_next_equipment, start_item=cond_equip, step_actions=[log])
await trace.run()
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 | /zepben.evolve-0.35.0b2-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.services.network.tracing.connectivity.connected_equipment_trace import new_connected_equipment_trace, \
new_connected_equipment_breadth_trace, new_normal_connected_equipment_trace, new_current_connected_equipment_trace, \
new_normal_limited_connected_equipment_trace, new_current_limited_connected_equipment_trace
from zepben.evolve.services.network.tracing.connectivity.connected_equipment_traversal import ConnectedEquipmentTraversal
from zepben.evolve.services.network.tracing.connectivity.connectivity_trace import queue_next_connectivity_result_with_open_test
from zepben.evolve.services.network.tracing.connectivity.limited_connected_equipment_trace import LimitedConnectedEquipmentTrace
from zepben.evolve.services.network.tracing.feeder.assign_to_feeders import AssignToFeeders
from zepben.evolve.services.network.tracing.feeder.assign_to_lv_feeders import AssignToLvFeeders
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.find_swer_equipment import FindSwerEquipment
from zepben.evolve.services.network.tracing.phases.phase_inferrer import PhaseInferrer
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.basic_traversal import BasicTraversal
from zepben.evolve.services.network.tracing.traversals.queue import depth_first, breadth_first
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 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", "normal_limited_connected_equipment_trace",
"current_limited_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_to_feeders", "assign_equipment_to_lv_feeders",
"find_swer_equipment"]
# --- Helper functions that create depth-first/breadth-first traversals ---
def create_basic_depth_trace(queue_next: QueueNext[T]) -> BasicTraversal[T]:
"""
Create a `BasicTraversal` using the `queue_next` function and a depth first queue (LIFO).
:param queue_next: The function used to add items to the trace queue.
:return: The `BasicTraversal`
"""
# noinspection PyArgumentList
return BasicTraversal(queue_next, depth_first())
def create_basic_breadth_trace(queue_next: QueueNext[T]) -> BasicTraversal[T]:
"""
Create a `BasicTraversal` using the `queue_next` function and a breadth first queue (FIFO).
:param queue_next: The function used to add items to the trace queue.
:return: The `BasicTraversal`
"""
# noinspection PyArgumentList
return BasicTraversal(queue_next, breadth_first())
# --- Traversals for conducting equipment ---
def connected_equipment_trace() -> ConnectedEquipmentTraversal:
"""
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 new_connected_equipment_trace()
def connected_equipment_breadth_trace() -> ConnectedEquipmentTraversal:
"""
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 `ConnectedEquipmentTraversal` instance.
"""
return new_connected_equipment_breadth_trace()
def normal_connected_equipment_trace() -> ConnectedEquipmentTraversal:
"""
Creates a new traversal that traces equipment that are connected at normally open points.
:return: The new `ConnectedEquipmentTraversal` instance.
"""
return new_normal_connected_equipment_trace()
def current_connected_equipment_trace() -> ConnectedEquipmentTraversal:
"""
Creates a new traversal that traces equipment that are connected at currently open points.
:return: The new `ConnectedEquipmentTraversal` instance.
"""
return new_current_connected_equipment_trace()
def normal_limited_connected_equipment_trace() -> LimitedConnectedEquipmentTrace:
"""
Creates a new limited traversal that traces equipment that are connected stopping at normally open points. This ignores phases etc.
It is purely to trace equipment that are connected in any way.
The trace can be limited by the number of steps, or the feeder direction.
:return: The new `LimitedConnectedEquipmentTrace` instance.
"""
return new_normal_limited_connected_equipment_trace()
def current_limited_connected_equipment_trace() -> LimitedConnectedEquipmentTrace:
"""
Creates a new limited traversal that traces equipment that are connected stopping at normally open points. This ignores phases etc.
It is purely to trace equipment that are connected in any way.
The trace can be limited by the number of steps, or the feeder direction.
:return: The new `LimitedConnectedEquipmentTrace` instance.
"""
return new_current_limited_connected_equipment_trace()
# Traversals for connectivity results
def connectivity_trace() -> BasicTraversal[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() -> BasicTraversal[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() -> BasicTraversal[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() -> BasicTraversal[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() -> BasicTraversal[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() -> BasicTraversal[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() -> BasicTraversal[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() -> BasicTraversal[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() -> BasicTraversal[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() -> BasicTraversal[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() -> BasicTraversal[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. ---
#
# These are not really necessary, but can be useful if you want to use code completion to find the traces by importing this module under an alias. e.g.
#
# import zepben.evolve.services.network.tracing.tracing as tracing
# tracing.set_phases()
#
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_to_feeders() -> AssignToFeeders:
"""
Returns an instance of `AssignToFeeders` convenience class for assigning equipment
containers to feeders on a network.
@return A new `AssignToFeeders` instance.
"""
return AssignToFeeders()
def assign_equipment_to_lv_feeders() -> AssignToLvFeeders:
"""
Returns an instance of `zepben.evolve.services.network.tracing.feeder.assign_to_lv_feeders.AssignToLvFeeders` convenience class for assigning equipment
containers to feeders on a network.
"""
return AssignToLvFeeders()
# 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()
def find_swer_equipment() -> FindSwerEquipment:
"""
Returns an instance of `FindSwerEquipment` convenience class for finding swer equipment on a feeders or network.
"""
return FindSwerEquipment() | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/tracing.py | tracing.py |
from typing import Callable, Set, Union, Optional
from zepben.evolve import ConnectedEquipmentTraversal, ConductingEquipmentStep, NetworkService, ConductingEquipment, Feeder, PowerTransformer, Switch, \
new_normal_connected_equipment_trace
__all__ = ["FindSwerEquipment"]
class FindSwerEquipment:
"""
A class which can be used for finding the SWER equipment in a [NetworkService] or [Feeder].
"""
create_trace: Callable[[], ConnectedEquipmentTraversal]
def __init__(self, create_trace: Optional[Callable[[], ConnectedEquipmentTraversal]] = None) -> None:
super().__init__()
self.create_trace = create_trace or new_normal_connected_equipment_trace
async def find_all(self, network_service: NetworkService) -> Set[ConductingEquipment]:
"""
Find the `ConductingEquipment` on any `Feeder` in a `NetworkService` which is SWER. This will include any equipment on the LV network that is energised
via SWER.
:param network_service: The `NetworkService` to process.
:return: A `Set` of `ConductingEquipment` on any `Feeder` in `network_service` that is SWER, or energised via SWER.
"""
return {it for feeder in network_service.objects(Feeder) for it in await self.find_on_feeder(feeder)}
async def find_on_feeder(self, feeder: Feeder) -> Set[ConductingEquipment]:
"""
Find the `ConductingEquipment` on a `Feeder` which is SWER. This will include any equipment on the LV network that is energised via SWER.
:param feeder: The `Feeder` to process.
:return: A `Set` of `ConductingEquipment` on `feeder` that is SWER, or energised via SWER.
"""
to_process = [it for it in feeder.equipment if isinstance(it, PowerTransformer) and self._has_swer_terminal(it) and self._has_non_swer_terminal(it)]
# We will add all the SWER transformers to the swer_equipment list before starting any traces to prevent tracing though them by accident. In
# order to do this, we collect the sequence to a list to change the iteration order.
swer_equipment = set(to_process)
for it in to_process:
await self._trace_from(it, swer_equipment)
return swer_equipment
async def _trace_from(self, transformer: PowerTransformer, swer_equipment: Set[ConductingEquipment]):
# Trace from any SWER terminals.
await self._trace_swer_from(transformer, swer_equipment)
# Trace from any LV terminals.
await self._trace_lv_from(transformer, swer_equipment)
async def _trace_swer_from(self, transformer: PowerTransformer, swer_equipment: Set[ConductingEquipment]):
async def is_in_swer_equipment(step: ConductingEquipmentStep) -> bool:
return step.conducting_equipment in swer_equipment
async def has_no_swer_terminals(step: ConductingEquipmentStep) -> bool:
return not self._has_swer_terminal(step)
async def add_swer_equipment(step: ConductingEquipmentStep, is_stopping: bool):
# To make sure we include any open points on a SWER network (unlikely) we include stop equipment if it is a `Switch`.
if not is_stopping or isinstance(step.conducting_equipment, Switch):
swer_equipment.add(step.conducting_equipment)
trace = self.create_trace()
trace.add_stop_condition(is_in_swer_equipment)
trace.add_stop_condition(has_no_swer_terminals)
trace.add_step_action(add_swer_equipment)
# We start from the connected equipment to prevent tracing in the wrong direction, as we are using the connected equipment trace.
to_process = [ct.conducting_equipment for t in transformer.terminals for ct in t.connected_terminals() if
t.phases.num_phases == 1 and ct.conducting_equipment]
for it in to_process:
trace.reset()
await trace.run_from(it)
async def _trace_lv_from(self, transformer: PowerTransformer, swer_equipment: Set[ConductingEquipment]):
async def is_in_swer_equipment(step: ConductingEquipmentStep) -> bool:
return step.conducting_equipment in swer_equipment
async def add_swer_equipment(step: ConductingEquipmentStep, _: bool):
swer_equipment.add(step.conducting_equipment)
trace = self.create_trace()
trace.add_stop_condition(is_in_swer_equipment)
trace.add_step_action(add_swer_equipment)
# We start from the connected equipment to prevent tracing in the wrong direction, as we are using the connected equipment trace.
to_process = [ct.conducting_equipment for t in transformer.terminals for ct in t.connected_terminals() if
t.phases.num_phases > 1 and ct.conducting_equipment and 1 <= ct.conducting_equipment.base_voltage_value <= 1000]
for it in to_process:
trace.reset()
await trace.run_from(it)
@staticmethod
def _has_swer_terminal(item: Union[ConductingEquipmentStep, ConductingEquipment]) -> bool:
if isinstance(item, ConductingEquipmentStep):
item = item.conducting_equipment
return any(t.phases.num_phases == 1 for t in item.terminals)
@staticmethod
def _has_non_swer_terminal(ce: ConductingEquipment) -> bool:
return any(t.phases.num_phases > 1 for t in ce.terminals) | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/find_swer_equipment.py | find_swer_equipment.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.run(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.run(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 | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/find.py | find.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, BasicTraversal
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) -> BasicTraversal[PhaseStep]:
# noinspection PyArgumentList
return BasicTraversal(queue_next=_queue_next(open_test), process_queue=PriorityQueue(), tracker=PhaseStepTracker())
def new_downstream_phase_trace(open_test: OpenTest, active_direction: DirectionSelector) -> BasicTraversal[PhaseStep]:
# noinspection PyArgumentList
return BasicTraversal(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) -> BasicTraversal[PhaseStep]:
# noinspection PyArgumentList
return BasicTraversal(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: BasicTraversal[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: BasicTraversal[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: BasicTraversal[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: BasicTraversal[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: BasicTraversal[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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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.run()
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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 `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 | /zepben.evolve-0.35.0b2-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.run((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 | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/phases/remove_phases.py | remove_phases.py |
from __future__ import annotations
from typing import Callable, TypeVar
from zepben.evolve import Traversal, BasicTracker
from zepben.evolve.services.network.tracing.traversals.queue import Queue, depth_first
from zepben.evolve.services.network.tracing.traversals.tracker import Tracker
__all__ = ["BasicTraversal"]
T = TypeVar('T')
class BasicTraversal(Traversal[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.
The process queue, an instance of `Queue` is also supplied during construction. This gives the
flexibility for this trace to be backed by any type of queue: breadth, depth, priority etc.
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, BasicTraversal[T]], None]
"""A function that will be called at each step of the traversal to queue "adjacent" items."""
process_queue: Queue[T] = depth_first()
"""Dictates the type of search to be performed on the network graph. Breadth-first, Depth-first, and Priority based searches are possible."""
tracker: Tracker = BasicTracker()
"""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() | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/traversals/basic_traversal.py | basic_traversal.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 | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/traversals/queue.py | queue.py |
from __future__ import annotations
from abc import abstractmethod
from typing import List, Callable, Awaitable, TypeVar, Generic
from dataclassy import dataclass
from zepben.evolve.exceptions import TracingException
__all__ = ["Traversal"]
T = TypeVar('T')
@dataclass(slots=True)
class Traversal(Generic[T]):
"""
Base class that provides some common functionality for traversals. This includes things like registering callbacks
to be called at every step in the traversal as well as registering stop conditions that traversals can check for when
to stop following a path.
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 Traversal 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 item, as well as the `stopping` state (True if the trace is stopping after the current item, False otherwise). Thus, the signature of
each step action must be:
:func: action(it: T, is_stopping: bool) -> None
This base class does not actually provide any way to traverse the items. It needs to be implemented in
subclasses. See `BasicTraversal` for an example.
"""
start_item: T = None
"""The starting item for this `Traversal`"""
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]]) -> Traversal[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: Traversal[T]):
"""Copy the stop conditions from `other` to this `Traversal`."""
self.stop_conditions.extend(other.stop_conditions)
def copy_step_actions(self, other: Traversal[T]):
"""Copy the step actions from `other` to this `Traversal`."""
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 run(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:`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:`ConductingEquipment.get_connectivity`
`can_stop_on_start_item` Whether to
"""
raise NotImplementedError() | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/traversals/traversal.py | traversal.py |
from __future__ import annotations
from zepben.evolve import BasicTracker, Tracker
from zepben.evolve.services.network.tracing.traversals.queue import Queue
from zepben.evolve.services.network.tracing.traversals.traversal import Traversal
from typing import Callable, TypeVar, Optional
__all__ = ["BranchRecursiveTraversal"]
T = TypeVar('T')
class BranchRecursiveTraversal(Traversal[T]):
queue_next: Callable[[T, Traversal[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 = BasicTracker()
"""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.run()
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 | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/traversals/branch_recursive_tracing.py | branch_recursive_tracing.py |
from __future__ import annotations
from typing import TYPE_CHECKING, TypeVar
from zepben.evolve import BasicTraversal, depth_first, ConductingEquipmentStepTracker, breadth_first, ignore_open, normally_open, currently_open, \
ConductingEquipmentStep
from zepben.evolve.services.network.network_service import connected_equipment
from zepben.evolve.services.network.tracing.connectivity.connected_equipment_traversal import ConnectedEquipmentTraversal
from zepben.evolve.services.network.tracing.connectivity.limited_connected_equipment_trace import LimitedConnectedEquipmentTrace
if TYPE_CHECKING:
from zepben.evolve.types import OpenTest, QueueNext
T = TypeVar("T")
__all__ = ["new_connected_equipment_trace", "new_connected_equipment_breadth_trace", "new_normal_connected_equipment_trace",
"new_current_connected_equipment_trace", "new_normal_limited_connected_equipment_trace", "new_current_limited_connected_equipment_trace"]
def _queue_next(open_test: OpenTest) -> QueueNext[ConductingEquipmentStep]:
def queue_next(step: ConductingEquipmentStep, traversal: BasicTraversal[ConductingEquipmentStep]):
if (step.step != 0) and open_test(step.conducting_equipment, None):
return
for cr in connected_equipment(step.conducting_equipment):
if cr.to_equip:
# noinspection PyArgumentList
traversal.process_queue.put(ConductingEquipmentStep(cr.to_equip, step.step + 1))
return queue_next
def new_connected_equipment_trace() -> ConnectedEquipmentTraversal:
"""
:return: a traversal that traces equipment that are connected, ignoring open status.
"""
# noinspection PyArgumentList
return ConnectedEquipmentTraversal(queue_next=_queue_next(ignore_open), process_queue=depth_first(), tracker=ConductingEquipmentStepTracker())
def new_connected_equipment_breadth_trace() -> ConnectedEquipmentTraversal:
"""
:return: a traversal that traces equipment that are connected, ignoring open status.
"""
# noinspection PyArgumentList
return ConnectedEquipmentTraversal(queue_next=_queue_next(ignore_open), process_queue=breadth_first(), tracker=ConductingEquipmentStepTracker())
def new_normal_connected_equipment_trace() -> ConnectedEquipmentTraversal:
"""
:return: a traversal that traces equipment that are connected stopping at normally open points.
"""
# noinspection PyArgumentList
return ConnectedEquipmentTraversal(queue_next=_queue_next(normally_open), process_queue=depth_first(), tracker=ConductingEquipmentStepTracker())
def new_current_connected_equipment_trace() -> ConnectedEquipmentTraversal:
"""
:return: a traversal that traces equipment that are connected stopping at currently open points.
"""
# noinspection PyArgumentList
return ConnectedEquipmentTraversal(queue_next=_queue_next(currently_open), process_queue=depth_first(), tracker=ConductingEquipmentStepTracker())
def new_normal_limited_connected_equipment_trace() -> LimitedConnectedEquipmentTrace:
"""
:return: a limited connected equipment trace that traces equipment on the normal state of the network.
"""
# noinspection PyArgumentList
return LimitedConnectedEquipmentTrace(new_normal_connected_equipment_trace, lambda it: it.normal_feeder_direction)
def new_current_limited_connected_equipment_trace() -> LimitedConnectedEquipmentTrace:
"""
:return: a limited connected equipment trace that traces equipment on the current state of the network.
"""
# noinspection PyArgumentList
return LimitedConnectedEquipmentTrace(new_current_connected_equipment_trace, lambda it: it.current_feeder_direction) | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/connectivity/connected_equipment_trace.py | connected_equipment_trace.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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 `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 | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/connectivity/connectivity_result.py | connectivity_result.py |
from typing import Callable, List, Dict, Optional
from dataclassy import dataclass
from zepben.evolve import Terminal, FeederDirection, ConductingEquipment, ConductingEquipmentStep
from zepben.evolve.services.network.tracing.connectivity.connected_equipment_traversal import ConnectedEquipmentTraversal
@dataclass(slots=True)
class LimitedConnectedEquipmentTrace:
"""
A class for finding the connected equipment.
"""
create_traversal: Callable[[], ConnectedEquipmentTraversal]
"""
Get the `ConnectedEquipmentTraversal` used to traverse the network. Should be either `Tracing.normalConnectedEquipmentTrace` or
`Tracing.currentConnectedEquipmentTrace`, depending on the network state you want to trace.
"""
get_terminal_direction: Callable[[Terminal], FeederDirection]
"""
Used to get the `FeederDirection` of a `Terminal`. Should be either `Terminal.normalFeederDirection` or
`Terminal.currentFeederDirection`, depending on the network state you want to trace.
"""
async def run(
self,
starting_equipment: List[ConductingEquipment],
maximum_steps: int = 1,
feeder_direction: Optional[FeederDirection] = None
) -> Dict[ConductingEquipment, int]:
"""
Run the trace from the `starting_equipment`.
:param starting_equipment: The `ConductingEquipment` to start tracing from.
:param maximum_steps: The maximum number of steps to trace out [1..100]. Defaults to 1.
:param feeder_direction: The optional [FeederDirection] of the connected equipment you want to return. Default null (all).
:return:
"""
check_steps = maximum_steps if maximum_steps > 1 else 1
check_steps = check_steps if check_steps < 100 else 100
matching_equipment = await (self._run_with_direction(starting_equipment, check_steps, feeder_direction) if feeder_direction else
self._run_without_direction(starting_equipment, check_steps))
equipment_steps = {}
for me in matching_equipment:
dict.setdefault(equipment_steps, me.conducting_equipment, []).append(me.step)
return {k: min(v) for k, v in equipment_steps.items()}
async def _run_with_direction(
self,
starting_equipment: List[ConductingEquipment],
maximum_steps: int,
feeder_direction: FeederDirection
) -> List[ConductingEquipmentStep]:
# noinspection PyArgumentList
matching_equipment = [ConductingEquipmentStep(it) for it in starting_equipment]
to_process = [t for it in starting_equipment for t in it.terminals if self.get_terminal_direction(t) == feeder_direction]
to_process = [t.conducting_equipment for it in to_process for t in it.connected_terminals() if t.conducting_equipment is not None]
async def reached_last_step(it: ConductingEquipmentStep):
return it.step >= maximum_steps - 1
async def found_starting_equipment(it: ConductingEquipmentStep):
return it.conducting_equipment in starting_equipment
async def has_no_valid_terminals(it: ConductingEquipmentStep):
return not any(self.get_terminal_direction(t) == feeder_direction for t in it.conducting_equipment.terminals)
async def add_matching_equipment(it: ConductingEquipmentStep, _: bool):
# noinspection PyArgumentList
matching_equipment.append(ConductingEquipmentStep(it.conducting_equipment, it.step + 1))
for start in to_process:
traversal = self.create_traversal()
traversal.add_stop_condition(reached_last_step)
traversal.add_stop_condition(found_starting_equipment)
traversal.add_stop_condition(has_no_valid_terminals)
traversal.add_step_action(add_matching_equipment)
await traversal.run_from(start, False)
if feeder_direction in (FeederDirection.BOTH, FeederDirection.NONE):
return [it for it in matching_equipment if any(self.get_terminal_direction(t) == feeder_direction for t in it.conducting_equipment.terminals)]
else:
return matching_equipment
async def _run_without_direction(self, starting_equipment: List[ConductingEquipment], maximum_steps: int) -> List[ConductingEquipmentStep]:
matching_equipment = []
async def reached_last_step(it: ConductingEquipmentStep):
return it.step >= maximum_steps
async def add_matching_equipment(it: ConductingEquipmentStep, _: bool):
matching_equipment.append(it)
for start in starting_equipment:
traversal = self.create_traversal()
traversal.add_stop_condition(reached_last_step)
traversal.add_step_action(add_matching_equipment)
await traversal.run_from(start, False)
return matching_equipment | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/connectivity/limited_connected_equipment_trace.py | limited_connected_equipment_trace.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:
"""
A class that can be used to find the phase connectivity between terminals.
"""
_create_candidate_phases: Callable[[], XyCandidatePhasePaths]
def __init__(self, create_candidate_phases: Callable[[], XyCandidatePhasePaths] = XyCandidatePhasePaths):
self._create_candidate_phases = create_candidate_phases
def connected_terminals(
self,
terminal: Terminal,
phases: Optional[Iterable[SinglePhaseKind]] = None
) -> List[ConnectivityResult]:
"""
Find the terminals that are connected to `terminal`, and the phase paths between them.
:param terminal: The `Terminal` to find connectivity for.
:param phases: An `Iterable` of `SinglePhaseKind` to limit the included phase paths to check. Defaults to None (all phases).
:return: A `List` of `ConnectivityResult` defining the connected terminals, or an empty list if there are no connected terminals.
"""
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)
) 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.get(terminal.phases, None)
return paths and paths.get(connected_terminal.phases)
def _find_xy_phase_paths(self, terminal: Terminal, connected_terminal: Terminal) -> List[NominalPhasePath]:
xy_phases = _find_xy_phases(terminal)
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 in (PhaseCode.XY, PhaseCode.XYN):
return PhaseCode.XY
elif terminal.phases in (PhaseCode.X, PhaseCode.XN):
return PhaseCode.X
elif terminal.phases in (PhaseCode.Y, PhaseCode.YN):
return PhaseCode.Y
else:
return PhaseCode.NONE
def _find_primary_phases(terminal: Terminal):
if terminal.phases in (PhaseCode.ABC, PhaseCode.ABCN):
primary_phases = PhaseCode.ABC
elif terminal.phases in (PhaseCode.AB, PhaseCode.ABN):
primary_phases = PhaseCode.AB
elif terminal.phases in (PhaseCode.AC, PhaseCode.ACN):
primary_phases = PhaseCode.AC
elif terminal.phases in (PhaseCode.BC, PhaseCode.BCN):
primary_phases = PhaseCode.BC
elif terminal.phases in (PhaseCode.A, PhaseCode.AN):
primary_phases = PhaseCode.A
elif terminal.phases in (PhaseCode.B, PhaseCode.BN):
primary_phases = PhaseCode.B
elif terminal.phases in (PhaseCode.C, PhaseCode.CN):
primary_phases = PhaseCode.C
else:
primary_phases = PhaseCode.NONE
return primary_phases
def _is_not_none(phase_code: PhaseCode) -> bool:
return phase_code != PhaseCode.NONE | zepben.evolve | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 EquipmentContainer
from zepben.evolve.model.cim.iec61970.base.core.terminal import Terminal
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.lv_feeder import LvFeeder
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__ = ["AssignToLvFeeders"]
class AssignToLvFeeders:
"""
Convenience class that provides methods for assigning LV 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_lv_feeder: Optional[LvFeeder] = None # This will never be optional by the time it is used.
"""
The LV 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 LV feeder in the specified network.
:param network: The network containing the feeders to process
"""
lv_feeder_start_points = set()
for lv_feeder in network.objects(LvFeeder):
if lv_feeder.normal_head_terminal:
head_equipment = lv_feeder.normal_head_terminal.conducting_equipment
if head_equipment:
lv_feeder_start_points.add(head_equipment)
for feeder in head_equipment.normal_feeders:
lv_feeder.add_normal_energizing_feeder(feeder)
feeder.add_normal_energized_lv_feeder(lv_feeder)
self._configure_stop_conditions(self._normal_traversal, lv_feeder_start_points)
self._configure_stop_conditions(self._current_traversal, lv_feeder_start_points)
for lv_feeder in network.objects(LvFeeder):
await self.run_feeder(lv_feeder)
async def run_feeder(self, lv_feeder: LvFeeder):
"""
Assign equipment to the specified feeders by tracing from the head terminal.
:param lv_feeder: The feeder to trace.
"""
self._active_lv_feeder = lv_feeder
if not lv_feeder.normal_head_terminal:
return
await self._run_from_head_terminal(self._normal_traversal, lv_feeder.normal_head_terminal)
await self._run_from_head_terminal(self._current_traversal, lv_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.run()
def _configure_stop_conditions(self, traversal: Traversal, lv_feeder_start_points: Set[ConductingEquipment]):
traversal.clear_stop_conditions()
traversal.add_stop_condition(self._reached_equipment(lv_feeder_start_points))
traversal.add_stop_condition(self._reached_hv)
@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_hv(t: Terminal) -> bool:
ce = t.conducting_equipment
nominal_voltage = ce and ce.base_voltage and ce.base_voltage.nominal_voltage
return nominal_voltage is not None and nominal_voltage >= 1000
async def _process_normal(self, terminal: Terminal, is_stopping: bool):
# noinspection PyTypeChecker
self._process(terminal, ConductingEquipment.add_container, LvFeeder.add_equipment, is_stopping)
async def _process_current(self, terminal: Terminal, is_stopping: bool):
# noinspection PyTypeChecker
self._process(terminal, ConductingEquipment.add_current_container, LvFeeder.add_current_equipment, is_stopping)
def _process(
self,
terminal: Optional[Terminal],
assign_lv_feeder_to_equip: Callable[[ConductingEquipment, EquipmentContainer], Any],
assign_equip_to_lv_feeder: Callable[[EquipmentContainer, ConductingEquipment], Any],
is_stopping: bool
):
if is_stopping and self._reached_hv(terminal):
return
if terminal.conducting_equipment:
assign_lv_feeder_to_equip(terminal.conducting_equipment, self._active_lv_feeder)
assign_equip_to_lv_feeder(self._active_lv_feeder, terminal.conducting_equipment) | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/services/network/tracing/feeder/assign_to_lv_feeders.py | assign_to_lv_feeders.py |
from typing import Set, Callable, Optional, Awaitable, Any
from zepben.evolve import BasicTraversal
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
__all__ = ["AssignToFeeders"]
class AssignToFeeders:
"""
Convenience class that provides methods for assigning HV/MV 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[BasicTraversal[Terminal]] = None, _current_traversal: Optional[BasicTraversal[Terminal]] = None):
self._normal_traversal: BasicTraversal[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: BasicTraversal[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: BasicTraversal, 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.run()
def _configure_stop_conditions(self, traversal: BasicTraversal, 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)
traversal.add_stop_condition(self._reached_lv)
@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()
@staticmethod
async def _reached_lv(t: Terminal) -> bool:
ce = t.conducting_equipment
nominal_voltage = ce and ce.base_voltage and ce.base_voltage.nominal_voltage
return nominal_voltage is not None and nominal_voltage < 1000
async def _process_normal(self, terminal: Terminal, is_stopping: bool):
# noinspection PyTypeChecker
self._process(terminal, ConductingEquipment.add_container, Feeder.add_equipment, is_stopping)
async def _process_current(self, terminal: Terminal, is_stopping: bool):
# noinspection PyTypeChecker
self._process(terminal, ConductingEquipment.add_current_container, Feeder.add_current_equipment, is_stopping)
def _process(
self,
terminal: Optional[Terminal],
assign_feeder_to_equip: Callable[[ConductingEquipment, EquipmentContainer], Any],
assign_equip_to_feeder: Callable[[EquipmentContainer, ConductingEquipment], Any],
is_stopping: bool
):
if is_stopping and (self._reached_lv(terminal) or self._reached_substation_transformer(terminal)):
return
if terminal.conducting_equipment:
assign_feeder_to_equip(terminal.conducting_equipment, self._active_feeder)
assign_equip_to_feeder(self._active_feeder, terminal.conducting_equipment) | zepben.evolve | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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, BasicTracker, 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=BasicTracker(),
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=BasicTracker(),
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().run(t)
await self.current_traversal.reset().run(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 | /zepben.evolve-0.35.0b2-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, BasicTracker, 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=BasicTracker(),
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=BasicTracker(),
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().run(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 | /zepben.evolve-0.35.0b2-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, BasicTraversal
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.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) -> BasicTraversal[Terminal]:
# noinspection PyArgumentList
return BasicTraversal(queue_next=queue_next_terminal_if_closed(open_test), process_queue=LifoQueue(), tracker=AssociatedTerminalTracker())
def new_normal_trace() -> BasicTraversal[Terminal]:
return new_trace(normally_open)
def new_current_trace() -> BasicTraversal[Terminal]:
return new_trace(currently_open)
def get_associated_terminals(terminal: Terminal, exclude: Set[Terminal] = None) -> List[Terminal]:
"""
Gets all associated `Terminal`s for `terminal`.
Associated terminals include every other `Terminal` on `terminal`s `connectivity_node`.
`terminal` The `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, BasicTraversal[Terminal]], None]:
"""
Creates a queue next function based on the given `open_test` that given a `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 `Traversal`s `process_queue`.
"""
def queue_next(terminal: Terminal, traversal: BasicTraversal[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 | /zepben.evolve-0.35.0b2-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 `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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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, LvFeeder, PotentialTransformer, CurrentTransformer
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_containers",
"operational_restrictions",
"eq_usage_points", "ec_equipment", "ec_phases", "energy_consumer", "es_phases", "energy_source",
"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_energized_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", "normal_energized_lv_feeders",
"normal_energizing_feeders", "lv_feeder_normal_head_terminal", "normal_energizing_feeders"]
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_containers(equipment: Equipment) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(equipment, eq_to_curcontainer_resolver, ec_to_curequipment_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 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 normal_energized_lv_feeders(feeder: Feeder) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(feeder, feeder_to_nelvf_resolver, lvfeeder_to_nef_resolver)
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_energized_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 lv_feeder_normal_head_terminal(lv_feeder: LvFeeder) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(lv_feeder, lvfeeder_to_nht_resolver, None)
def normal_energizing_feeders(lv_feeder: LvFeeder) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(lv_feeder, lvfeeder_to_nef_resolver, feeder_to_nelvf_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)
def current_transformer_info(current_transformer: CurrentTransformer) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(current_transformer, ct_to_cti_resolver, None)
def potential_transformer_info(potential_transformer: PotentialTransformer) -> BoundReferenceResolver:
# noinspection PyArgumentList
return BoundReferenceResolver(potential_transformer, vt_to_vti_resolver, None) | zepben.evolve | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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.infiec61968.infassetinfo.current_transformer_info import CurrentTransformerInfo
from zepben.evolve.model.cim.iec61968.infiec61968.infassetinfo.potential_transformer_info import PotentialTransformerInfo
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.auxiliaryequipment.current_transformer import CurrentTransformer
from zepben.evolve.model.cim.iec61970.base.auxiliaryequipment.potential_transformer import PotentialTransformer
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
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.lv_feeder import LvFeeder
__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_curcontainer_resolver", "powertransformer_to_power_transformer_info_resolver", "eq_to_ec_resolver",
"eq_to_or_resolver", "eq_to_up_resolver", "ec_to_eq_resolver", "ec_to_curequipment_resolver", "feeder_to_nes_resolver", "feeder_to_nht_resolver",
"feeder_to_nelvf_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", "lvfeeder_to_nht_resolver",
"lvfeeder_to_nef_resolver", "ct_to_cti_resolver", "vt_to_vti_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_curcontainer_resolver = ReferenceResolver(Equipment, EquipmentContainer, lambda t, r: t.add_current_container(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))
ec_to_curequipment_resolver = ReferenceResolver(EquipmentContainer, Equipment, lambda t, r: t.add_current_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))
feeder_to_nelvf_resolver = ReferenceResolver(Feeder, LvFeeder, lambda t, r: t.add_normal_energized_lv_feeder(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))
lvfeeder_to_nht_resolver = ReferenceResolver(LvFeeder, Terminal, lambda t, r: setattr(t, 'normal_head_terminal', r))
lvfeeder_to_nef_resolver = ReferenceResolver(LvFeeder, Feeder, lambda t, r: t.add_normal_energizing_feeder(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))
# To avoid confusion with PowerTransformer shortened as "pt", PotentialTransformer is shortened to "vt".
ct_to_cti_resolver = ReferenceResolver(CurrentTransformer, CurrentTransformerInfo, lambda t, r: setattr(t, 'asset_info', r))
vt_to_vti_resolver = ReferenceResolver(PotentialTransformer, PotentialTransformerInfo, lambda t, r: setattr(t, 'asset_info', r)) | zepben.evolve | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-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 | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/domain/unit_symbol.py | unit_symbol.py |
from __future__ import annotations
from typing import List, Optional, Generator
from zepben.evolve.model.cim.iec61968.assetinfo.power_transformer_info import PowerTransformerInfo
from zepben.evolve.model.cim.iec61968.infiec61968.infassetinfo.transformer_construction_kind import TransformerConstructionKind
from zepben.evolve.model.cim.iec61968.infiec61968.infassetinfo.transformer_function_kind import TransformerFunctionKind
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.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.terminal import Terminal
from zepben.evolve.model.cim.iec61970.base.wires.transformer_star_impedance import TransformerStarImpedance
from zepben.evolve.model.cim.iec61970.base.wires.vector_group import VectorGroup
from zepben.evolve.model.cim.iec61970.base.wires.winding_connection import WindingConnection
from zepben.evolve.util import require, nlen, get_by_mrid, ngen, safe_remove
__all__ = ["TapChanger", "RatioTapChanger", "PowerTransformer", "PowerTransformerEnd", "TransformerEnd"]
class TapChanger(PowerSystemResource):
"""
Mechanism for changing transformer winding tap positions.
"""
control_enabled: bool = True
"""Specifies the regulation status of the equipment. True is regulating, false is not regulating."""
neutral_u: Optional[int] = None
"""Voltage at which the winding operates at the neutral tap setting."""
_high_step: Optional[int] = None
_low_step: Optional[int] = None
_neutral_step: Optional[int] = None
_normal_step: Optional[int] = None
_step: Optional[float] = None
def __init__(self, high_step: int = None, low_step: int = None, neutral_step: int = None, normal_step: int = None, step: float = None, **kwargs):
super(TapChanger, self).__init__(**kwargs)
if high_step is not None:
self._high_step = high_step
if low_step is not None:
self._low_step = low_step
if neutral_step is not None:
self._neutral_step = neutral_step
if normal_step is not None:
self._normal_step = normal_step
if step is not None:
self._step = step
self._validate_steps()
@property
def high_step(self):
"""Highest possible tap step position, advance from neutral. The attribute shall be greater than lowStep."""
return self._high_step
@high_step.setter
def high_step(self, val):
require((val is None) or (self._low_step is None) or (val > self._low_step),
lambda: f"High step [{val}] must be greater than low step [{self._low_step}]")
self._check_steps(self.low_step, val)
self._high_step = val
@property
def low_step(self):
"""Lowest possible tap step position, retard from neutral"""
return self._low_step
@low_step.setter
def low_step(self, val):
require((val is None) or (self._high_step is None) or (val < self._high_step),
lambda: f"Low step [{val}] must be less than high step [{self._high_step}]")
self._check_steps(val, self.high_step)
self._low_step = val
@property
def neutral_step(self):
"""The neutral tap step position for this winding. The attribute shall be equal or greater than lowStep and equal or less than highStep."""
return self._neutral_step
@neutral_step.setter
def neutral_step(self, val):
require(self._is_in_range(val), lambda: f"Neutral step [{val}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
self._neutral_step = val
@property
def normal_step(self):
"""
The tap step position used in "normal" network operation for this winding. For a "Fixed" tap changer indicates the current physical tap setting.
The attribute shall be equal or greater than lowStep and equal or less than highStep.
"""
return self._normal_step
@normal_step.setter
def normal_step(self, val):
require(self._is_in_range(val), lambda: f"Normal step [{val}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
self._normal_step = val
@property
def step(self):
"""
Tap changer position. Starting step for a steady state solution. Non integer values are allowed to support continuous tap variables.
The reasons for continuous value are to support study cases where no discrete tap changers has yet been designed, a solutions where a narrow voltage
band force the tap step to oscillate or accommodate for a continuous solution as input.
The attribute shall be equal or greater than lowStep and equal or less than highStep.
"""
return self._step
@step.setter
def step(self, val):
require(self._is_in_range(val), lambda: f"Step [{val}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
self._step = val
def _check_steps(self, low, high):
if low is not None:
require((self.step is None) or (low <= self.step), lambda: f"New value would invalidate current step of [{self.step}]")
require((self.normal_step is None) or (low <= self.normal_step), lambda: f"New value would invalidate current normal_step of [{self.normal_step}]")
require((self.neutral_step is None) or (low <= self.neutral_step),
lambda: f"New value would invalidate current neutral_step of [{self.neutral_step}]")
if high is not None:
require((self.step is None) or (self.step <= high), lambda: f"New value would invalidate current step of [{self.step}]")
require((self.normal_step is None) or (self.normal_step <= high), lambda: f"New value would invalidate current normal_step of [{self.normal_step}]")
require((self.neutral_step is None) or (self.neutral_step <= high),
lambda: f"New value would invalidate current neutral_step of [{self.neutral_step}]")
def _validate_steps(self):
require((self._high_step is None) or (self._low_step is None) or (self._high_step > self._low_step),
lambda: f"High step [{self._high_step}] must be greater than low step [{self._low_step}]")
require(self._is_in_range(self._neutral_step),
lambda: f"Neutral step [{self.neutral_step}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
require(self._is_in_range(self._normal_step),
lambda: f"Normal step [{self.normal_step}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
require(self._is_in_range(self._step), lambda: f"Step [{self._step}] must be between high step [{self._high_step}] and low step [{self._low_step}]")
def _is_in_range(self, val) -> bool:
if val is None:
return True
if self._low_step is not None:
if val < self._low_step:
return False
if self._high_step is not None:
if val > self._high_step:
return False
return True
class RatioTapChanger(TapChanger):
"""
A tap changer that changes the voltage ratio impacting the voltage magnitude but not the phase angle across the transformer.
Angle sign convention (general): Positive value indicates a positive phase shift from the winding where the tap is located to the other winding
(for a two-winding transformer).
"""
transformer_end: Optional[TransformerEnd] = None
"""`TransformerEnd` to which this ratio tap changer belongs."""
step_voltage_increment: Optional[float] = None
"""Tap step increment, in per cent of neutral voltage, per step position."""
class TransformerEnd(IdentifiedObject):
"""
A conducting connection point of a power transformer. It corresponds to a physical transformer winding terminal.
In earlier CIM versions, the TransformerWinding class served a similar purpose, but this class is more flexible
because it associates to terminal but is not a specialization of ConductingEquipment.
"""
grounded: bool = False
"""(for Yn and Zn connections) True if the neutral is solidly grounded."""
r_ground: Optional[float] = None
"""(for Yn and Zn connections) Resistance part of neutral impedance where 'grounded' is true"""
x_ground: Optional[float] = None
"""(for Yn and Zn connections) Reactive part of neutral impedance where 'grounded' is true"""
ratio_tap_changer: Optional[RatioTapChanger] = None
"""Ratio tap changer associated with this transformer end."""
terminal: Optional[Terminal] = None
"""The terminal of the transformer that this end is associated with"""
base_voltage: Optional[BaseVoltage] = None
"""Base voltage of the transformer end. This is essential for PU calculation."""
end_number: int = 0
"""Number for this transformer end, corresponding to the end’s order in the power transformer vector group or phase angle clock number.
Highest voltage winding should be 1. Each end within a power transformer should have a unique subsequent end number.
Note the transformer end number need not match the terminal sequence number."""
star_impedance: Optional[TransformerStarImpedance] = None
"""(accurate for 2- or 3-winding transformers only) Pi-model impedances of this transformer end. By convention, for a two winding transformer, the full
values of the transformer should be entered on the high voltage end (endNumber=1)."""
class PowerTransformerEnd(TransformerEnd):
"""
A PowerTransformerEnd is associated with each Terminal of a PowerTransformer.
The impedance values r, r0, x, and x0 of a PowerTransformerEnd represents a star equivalent as follows
1) for a two Terminal PowerTransformer the high voltage PowerTransformerEnd has non zero values on r, r0, x, and x0
while the low voltage PowerTransformerEnd has zero values for r, r0, x, and x0.
2) for a three Terminal PowerTransformer the three PowerTransformerEnds represents a star equivalent with each leg
in the star represented by r, r0, x, and x0 values.
3) For a three Terminal transformer each PowerTransformerEnd shall have g, g0, b and b0 values corresponding the no load losses
distributed on the three PowerTransformerEnds. The total no load loss shunt impedances may also be placed at one of the
PowerTransformerEnds, preferably the end numbered 1, having the shunt values on end 1 is the preferred way.
4) for a PowerTransformer with more than three Terminals the PowerTransformerEnd impedance values cannot be used.
Instead use the TransformerMeshImpedance or split the transformer into multiple PowerTransformers.
"""
_power_transformer: Optional[PowerTransformer] = None
"""The power transformer of this power transformer end."""
rated_s: Optional[int] = None
"""Normal apparent power rating. The attribute shall be a positive value. For a two-winding transformer the values for the high and low voltage sides
shall be identical."""
rated_u: Optional[int] = None
"""Rated voltage: phase-phase for three-phase windings, and either phase-phase or phase-neutral for single-phase windings. A high voltage side, as given by
TransformerEnd.endNumber, shall have a ratedU that is greater or equal than ratedU for the lower voltage sides."""
r: Optional[float] = None
"""Resistance (star-phases) of the transformer end. The attribute shall be equal or greater than zero for non-equivalent transformers."""
x: Optional[float] = None
"""Positive sequence series reactance (star-phases) of the transformer end."""
r0: Optional[float] = None
"""Zero sequence series resistance (star-phases) of the transformer end."""
x0: Optional[float] = None
"""Zero sequence series reactance of the transformer end."""
g: Optional[float] = None
"""Magnetizing branch conductance."""
g0: Optional[float] = None
"""Zero sequence magnetizing branch conductance (star-phases)."""
b: Optional[float] = None
"""Magnetizing branch susceptance (B mag). The value can be positive or negative."""
b0: Optional[float] = None
"""Zero sequence magnetizing branch susceptance."""
connection_kind: WindingConnection = WindingConnection.UNKNOWN_WINDING
"""Kind of `zepben.protobuf.cim.iec61970.base.wires.winding_connection.WindingConnection` for this end."""
phase_angle_clock: Optional[int] = None
"""Terminal voltage phase angle displacement where 360 degrees are represented with clock hours. The valid values are 0 to 11. For example, for the
secondary side end of a transformer with vector group code of 'Dyn11', specify the connection kind as wye with neutral and specify the phase angle of the
clock as 11. The clock value of the transformer end number specified as 1, is assumed to be zero."""
def __init__(self, power_transformer: PowerTransformer = None, **kwargs):
super(PowerTransformerEnd, self).__init__(**kwargs)
if power_transformer:
self.power_transformer = power_transformer
@property
def power_transformer(self):
"""The power transformer of this power transformer end."""
return self._power_transformer
@power_transformer.setter
def power_transformer(self, pt):
if self._power_transformer is None or self._power_transformer is pt:
self._power_transformer = pt
else:
raise ValueError(f"power_transformer for {str(self)} has already been set to {self._power_transformer}, cannot reset this field to {pt}")
@property
def nominal_voltage(self):
return self.base_voltage.nominal_voltage if self.base_voltage else self.rated_u
class PowerTransformer(ConductingEquipment):
"""
An electrical device consisting of two or more coupled windings, with or without a magnetic core, for introducing
mutual coupling between electric circuits.
Transformers can be used to control voltage and phase shift (active power flow). A power transformer may be composed of separate transformer tanks that
need not be identical. A power transformer can be modeled with or without tanks and is intended for use in both balanced and unbalanced representations.
A power transformer typically has two terminals, but may have one (grounding), three or more terminals.
The inherited association ConductingEquipment.BaseVoltage should not be used.
The association from TransformerEnd to BaseVoltage should be used instead.
Attributes -
vector_group : `zepben.protobuf.cim.iec61970.base.wires.VectorGroup` of the transformer for protective relaying.
power_transformer_ends :
"""
vector_group: VectorGroup = VectorGroup.UNKNOWN
"""
Vector group of the transformer for protective relaying, e.g., Dyn1. For unbalanced transformers, this may not be simply
determined from the constituent winding connections and phase angle displacements.
The vectorGroup string consists of the following components in the order listed: high voltage winding connection, mid
voltage winding connection(for three winding transformers), phase displacement clock number from 0 to 11, low voltage
winding connection phase displacement clock number from 0 to 11. The winding connections are D(delta), Y(wye),
YN(wye with neutral), Z(zigzag), ZN(zigzag with neutral), A(auto transformer). Upper case means the high voltage,
lower case mid or low.The high voltage winding always has clock position 0 and is not included in the vector group
string. Some examples: YNy0(two winding wye to wye with no phase displacement), YNd11(two winding wye to delta with
330 degrees phase displacement), YNyn0d5(three winding transformer wye with neutral high voltage, wye with neutral mid
voltage and no phase displacement, delta low voltage with 150 degrees displacement).
Phase displacement is defined as the angular difference between the phasors representing the voltages between the
neutral point(real or imaginary) and the corresponding terminals of two windings, a positive sequence voltage system
being applied to the high-voltage terminals, following each other in alphabetical sequence if they are lettered, or in
numerical sequence if they are numbered: the phasors are assumed to rotate in a counter-clockwise sense.
"""
_power_transformer_ends: Optional[List[PowerTransformerEnd]] = None
transformer_utilisation: Optional[float] = None
"""
The fraction of the transformer’s normal capacity (nameplate rating) that is in use. It may be expressed as the
result of the calculation S/Sn, where S = Load on Transformer (in VA), Sn = Transformer Nameplate Rating (in VA).
"""
construction_kind: TransformerConstructionKind = TransformerConstructionKind.unknown
"""
The construction kind of this transformer.
"""
function: TransformerFunctionKind = TransformerFunctionKind.other
"""
The function of this transformer.
"""
def __init__(self, power_transformer_ends: List[PowerTransformerEnd] = None, **kwargs):
super(PowerTransformer, self).__init__(**kwargs)
if power_transformer_ends:
for end in power_transformer_ends:
if end.power_transformer is None:
end.power_transformer = self
self.add_end(end)
def num_ends(self):
"""
Get the number of `PowerTransformerEnd`s for this `PowerTransformer`.
"""
return nlen(self._power_transformer_ends)
@property
def ends(self) -> Generator[PowerTransformerEnd, None, None]:
"""The `PowerTransformerEnd`s for this `PowerTransformer`."""
return ngen(self._power_transformer_ends)
@property
def power_transformer_info(self) -> Optional[PowerTransformerInfo]:
"""The `PowerTransformerInfo` for this `PowerTransformer`"""
return self.asset_info
@power_transformer_info.setter
def power_transformer_info(self, pti: Optional[PowerTransformerInfo]):
"""
Set the `PowerTransformerInfo` for this `PowerTransformer`
`pti` The `PowerTransformerInfo` to associate with this `PowerTransformer`
"""
self.asset_info = pti
def get_base_voltage(self, terminal: Terminal = None):
if terminal is None:
return self.base_voltage
for end in self.ends:
if end.terminal is terminal:
return end.base_voltage
else:
return None
def get_end_by_mrid(self, mrid: str) -> PowerTransformerEnd:
"""
Get the `PowerTransformerEnd` for this `PowerTransformer` identified by `mrid`
`mrid` the mRID of the required `PowerTransformerEnd`
Returns The `PowerTransformerEnd` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._power_transformer_ends, mrid)
def get_end_by_num(self, end_number: int) -> PowerTransformerEnd:
"""
Get the `PowerTransformerEnd` on this `PowerTransformer` by its `end_number`.
`end_number` The `end_number` of the `PowerTransformerEnd` in relation to this `PowerTransformer`s VectorGroup.
Returns The `PowerTransformerEnd` referred to by `end_number`
Raises IndexError if no `PowerTransformerEnd` was found with end_number `end_number`.
"""
if self._power_transformer_ends:
for end in self._power_transformer_ends:
if end.end_number == end_number:
return end
raise IndexError(f"No TransformerEnd with end_number {end_number} was found in PowerTransformer {str(self)}")
def get_end_by_terminal(self, terminal: Terminal) -> PowerTransformerEnd:
"""
Get the `PowerTransformerEnd` on this `PowerTransformer` by its `terminal`.
`terminal` The `terminal` to find a `PowerTransformerEnd` for.
Returns The `PowerTransformerEnd` connected to the specified `terminal`
Raises IndexError if no `PowerTransformerEnd` connected to `terminal` was found on this `PowerTransformer`.
"""
if self._power_transformer_ends:
for end in self._power_transformer_ends:
if end.terminal is terminal:
return end
raise IndexError(f"No TransformerEnd with terminal {terminal} was found in PowerTransformer {str(self)}")
def add_end(self, end: PowerTransformerEnd) -> PowerTransformer:
"""
Associate a `PowerTransformerEnd` with this `PowerTransformer`. If `end.end_number` == 0, the end will be assigned an end_number of
`self.num_ends() + 1`.
`end` the `PowerTransformerEnd` to associate with this `PowerTransformer`.
Returns A reference to this `PowerTransformer` to allow fluent use.
Raises `ValueError` if another `PowerTransformerEnd` with the same `mrid` already exists for this `PowerTransformer`.
"""
if self._validate_end(end):
return self
if end.end_number == 0:
end.end_number = self.num_ends() + 1
self._power_transformer_ends = list() if self._power_transformer_ends is None else self._power_transformer_ends
self._power_transformer_ends.append(end)
self._power_transformer_ends.sort(key=lambda t: t.end_number)
return self
def remove_end(self, end: PowerTransformerEnd) -> PowerTransformer:
"""
`end` the `PowerTransformerEnd` to disassociate from this `PowerTransformer`.
Raises `ValueError` if `end` was not associated with this `PowerTransformer`.
Returns A reference to this `PowerTransformer` to allow fluent use.
"""
self._power_transformer_ends = safe_remove(self._power_transformer_ends, end)
return self
def clear_ends(self) -> PowerTransformer:
"""
Clear all `PowerTransformerEnd`s.
Returns A reference to this `PowerTransformer` to allow fluent use.
"""
self._power_transformer_ends.clear()
return self
def _validate_end(self, end: PowerTransformerEnd) -> bool:
"""
Validate an end against this `PowerTransformer`'s `PowerTransformerEnd`s.
`end` The `PowerTransformerEnd` to validate.
Returns True if `end` is already associated with this `PowerTransformer`, otherwise False.
Raises `ValueError` if `end.power_transformer` is not this `PowerTransformer`, or if this `PowerTransformer` has a different `PowerTransformerEnd`
with the same mRID.
"""
if self._validate_reference(end, self.get_end_by_mrid, "A PowerTransformerEnd"):
return True
if self._validate_reference_by_sn(end.end_number, end, self.get_end_by_num, "A PowerTransformerEnd", "end_number"):
return True
if not end.power_transformer:
end.power_transformer = self
require(end.power_transformer is self,
lambda: f"PowerTransformerEnd {end} references another PowerTransformer {end.power_transformer}, expected {str(self)}.")
return False | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/wires/power_transformer.py | power_transformer.py |
from __future__ import annotations
from typing import List, Optional, Generator
from zepben.evolve.model.cim.iec61970.base.wires.energy_connection import EnergyConnection
from zepben.evolve.model.cim.iec61970.base.wires.energy_source_phase import EnergySourcePhase
from zepben.evolve.util import nlen, get_by_mrid, ngen, safe_remove
__all__ = ["EnergySource"]
class EnergySource(EnergyConnection):
"""
A generic equivalent for an energy supplier on a transmission or distribution voltage level.
"""
_energy_source_phases: Optional[List[EnergySourcePhase]] = None
active_power: Optional[float] = None
"""
High voltage source active injection. Load sign convention is used, i.e. positive sign means flow out from a node. Starting value
for steady state solutions
"""
reactive_power: Optional[float] = None
"""High voltage source reactive injection. Load sign convention is used, i.e. positive sign means flow out from a node.
Starting value for steady state solutions."""
voltage_angle: Optional[float] = None
"""Phase angle of a-phase open circuit."""
voltage_magnitude: Optional[float] = None
"""Phase-to-phase open circuit voltage magnitude."""
p_max: Optional[float] = None
"""
This is the maximum active power that can be produced by the source. Load sign convention is used, i.e. positive sign means flow out from a
TopologicalNode (bus) into the conducting equipment.
"""
p_min: Optional[float] = None
"""
This is the minimum active power that can be produced by the source. Load sign convention is used, i.e. positive sign means flow out from a
TopologicalNode (bus) into the conducting equipment.
"""
r: Optional[float] = None
"""Positive sequence Thevenin resistance."""
r0: Optional[float] = None
"""Zero sequence Thevenin resistance."""
rn: Optional[float] = None
"""Negative sequence Thevenin resistance."""
x: Optional[float] = None
"""Positive sequence Thevenin reactance."""
x0: Optional[float] = None
"""Zero sequence Thevenin reactance."""
xn: Optional[float] = None
"""Negative sequence Thevenin reactance."""
is_external_grid: bool = False
"""
True if this energy source represents the higher-level power grid connection to an external grid
that normally is modelled as the slack bus for power flow calculations.
"""
r_min: Optional[float] = None
"""Minimum positive sequence Thevenin resistance."""
rn_min: Optional[float] = None
"""Minimum negative sequence Thevenin resistance."""
r0_min: Optional[float] = None
"""Minimum zero sequence Thevenin resistance."""
x_min: Optional[float] = None
"""Minimum positive sequence Thevenin reactance."""
xn_min: Optional[float] = None
"""Minimum negative sequence Thevenin reactance."""
x0_min: Optional[float] = None
"""Minimum zero sequence Thevenin reactance."""
r_max: Optional[float] = None
"""Maximum positive sequence Thevenin resistance."""
rn_max: Optional[float] = None
"""Maximum negative sequence Thevenin resistance."""
r0_max: Optional[float] = None
"""Maximum zero sequence Thevenin resistance."""
x_max: Optional[float] = None
"""Maximum positive sequence Thevenin reactance."""
xn_max: Optional[float] = None
"""Maximum negative sequence Thevenin reactance."""
x0_max: Optional[float] = None
"""Maximum zero sequence Thevenin reactance."""
def __init__(self, energy_source_phases: List[EnergySourcePhase] = None, **kwargs):
super(EnergySource, self).__init__(**kwargs)
if energy_source_phases:
for phase in energy_source_phases:
self.add_phase(phase)
@property
def phases(self) -> Generator[EnergySourcePhase, None, None]:
"""
The `EnergySourcePhase`s for this `EnergySource`.
"""
return ngen(self._energy_source_phases)
def has_phases(self):
"""
Check if this source has any associated `EnergySourcePhase`s
Returns True if there is at least one `EnergySourcePhase`, otherwise False
"""
return nlen(self._energy_source_phases) > 0
def num_phases(self):
"""Return the number of `EnergySourcePhase`s associated with this `EnergySource`"""
return nlen(self._energy_source_phases)
def get_phase(self, mrid: str) -> EnergySourcePhase:
"""
Get the `EnergySourcePhase` for this `EnergySource` identified by `mrid`
`mrid` the mRID of the required `EnergySourcePhase`
Returns The `EnergySourcePhase` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._energy_source_phases, mrid)
def add_phase(self, phase: EnergySourcePhase) -> EnergySource:
"""
Associate an `EnergySourcePhase` with this `EnergySource`
`phase` the `EnergySourcePhase` to associate with this `EnergySource`.
Returns A reference to this `EnergySource` to allow fluent use.
Raises `ValueError` if another `EnergySourcePhase` with the same `mrid` already exists for this `EnergySource`.
"""
if self._validate_reference(phase, self.get_phase, "An EnergySourcePhase"):
return self
self._energy_source_phases = list() if self._energy_source_phases is None else self._energy_source_phases
self._energy_source_phases.append(phase)
return self
def remove_phase(self, phase: EnergySourcePhase) -> EnergySource:
"""
Disassociate an `phase` from this `EnergySource`
`phase` the `EnergySourcePhase` to disassociate from this `EnergySource`.
Returns A reference to this `EnergySource` to allow fluent use.
Raises `ValueError` if `phase` was not associated with this `EnergySource`.
"""
self._energy_source_phases = safe_remove(self._energy_source_phases, phase)
return self
def clear_phases(self) -> EnergySource:
"""
Clear all phases.
Returns A reference to this `EnergySource` to allow fluent use.
"""
self._energy_source_phases = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/wires/energy_source.py | energy_source.py |
from __future__ import annotations
from typing import Optional, Generator, List
from zepben.evolve.model.cim.iec61970.base.core.power_system_resource import PowerSystemResource
from zepben.evolve.model.cim.iec61970.base.wires.energy_connection import EnergyConnection
from zepben.evolve.model.cim.iec61970.base.wires.phase_shunt_connection_kind import PhaseShuntConnectionKind
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
__all__ = ["EnergyConsumer", "EnergyConsumerPhase"]
from zepben.evolve.util import nlen, get_by_mrid, ngen, safe_remove
class EnergyConsumerPhase(PowerSystemResource):
"""A single phase of an energy consumer."""
_energy_consumer: Optional[EnergyConsumer] = None
phase: SinglePhaseKind = SinglePhaseKind.X
"""Phase of this energy consumer component. If the energy consumer is wye connected, the connection is from the indicated phase to the central ground or
neutral point. If the energy consumer is delta connected, the phase indicates an energy consumer connected from the indicated phase to the next
logical non-neutral phase. """
p: Optional[float] = None
"""Active power of the load. Load sign convention is used, i.e. positive sign means flow out from a node. For voltage dependent loads the value is at
rated voltage. Starting value for a steady state solution."""
q: Optional[float] = None
"""Reactive power of the load. Load sign convention is used, i.e. positive sign means flow out from a node. For voltage dependent loads the value is at
rated voltage. Starting value for a steady state solution."""
p_fixed: Optional[float] = None
"""Active power of the load that is a fixed quantity. Load sign convention is used, i.e. positive sign means flow out from a node."""
q_fixed: Optional[float] = None
"""Reactive power of the load that is a fixed quantity. Load sign convention is used, i.e. positive sign means flow out from a node."""
def __init__(self, energy_consumer: EnergyConsumer = None, **kwargs):
super(EnergyConsumerPhase, self).__init__(**kwargs)
if energy_consumer:
self.energy_consumer = energy_consumer
@property
def energy_consumer(self):
"""The `EnergyConsumer` that has this phase."""
return self._energy_consumer
@energy_consumer.setter
def energy_consumer(self, ec):
if self._energy_consumer is None or self._energy_consumer is ec:
self._energy_consumer = ec
else:
raise ValueError(f"energy_consumer for {str(self)} has already been set to {self._energy_consumer}, cannot reset this field to {ec}")
class EnergyConsumer(EnergyConnection):
"""Generic user of energy - a point of consumption on the power system phases. May also represent a pro-sumer with negative p/q values. """
_energy_consumer_phases: Optional[List[EnergyConsumerPhase]] = None
"""The individual phase models for this energy consumer."""
customer_count: Optional[int] = None
"""Number of individual customers represented by this demand."""
grounded: bool = False
"""Used for Yn and Zn connections. True if the neutral is solidly grounded."""
phase_connection: PhaseShuntConnectionKind = PhaseShuntConnectionKind.D
"""`zepben.protobuf.cim.iec61970.base.wires.phase_shunt_connection_kind.PhaseShuntConnectionKind` - The type of phase connection,
such as wye, delta, I (single phase)."""
p: Optional[float] = None
"""Active power of the load. Load sign convention is used, i.e. positive sign means flow out from a node. For voltage dependent loads the value is at
rated voltage. Starting value for a steady state solution."""
p_fixed: Optional[float] = None
"""Active power of the load that is a fixed quantity. Load sign convention is used, i.e. positive sign means flow out from a node."""
q: Optional[float] = None
"""Reactive power of the load. Load sign convention is used, i.e. positive sign means flow out from a node. For voltage dependent loads the value is at
rated voltage. Starting value for a steady state solution."""
q_fixed: Optional[float] = None
"""Power of the load that is a fixed quantity. Load sign convention is used, i.e. positive sign means flow out from a node."""
def __init__(self, energy_consumer_phases: List[EnergyConsumerPhase] = None, **kwargs):
super(EnergyConsumer, self).__init__(**kwargs)
if energy_consumer_phases:
for phase in energy_consumer_phases:
self.add_phase(phase)
def has_phases(self):
"""
Check if this consumer has any associated `EnergyConsumerPhases`
Returns True if there is at least one `EnergyConsumerPhase`, otherwise False
"""
return nlen(self._energy_consumer_phases) > 0
def num_phases(self):
"""Get the number of `EnergySourcePhase`s for this `EnergyConsumer`."""
return nlen(self._energy_consumer_phases)
@property
def phases(self) -> Generator[EnergyConsumerPhase, None, None]:
"""The individual phase models for this energy consumer."""
return ngen(self._energy_consumer_phases)
def get_phase(self, mrid: str) -> EnergyConsumerPhase:
"""
Get the `EnergyConsumerPhase` for this `EnergyConsumer` identified by `mrid`
`mrid` The mRID of the required `EnergyConsumerPhase`
Returns The `EnergyConsumerPhase` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._energy_consumer_phases, mrid)
def add_phase(self, phase: EnergyConsumerPhase) -> EnergyConsumer:
"""
Associate an `EnergyConsumerPhase` with this `EnergyConsumer`
`phase` the `EnergyConsumerPhase` to associate with this `EnergyConsumer`.
Returns A reference to this `EnergyConsumer` to allow fluent use.
Raises `ValueError` if another `EnergyConsumerPhase` with the same `mrid` already exists for this `EnergyConsumer`.
"""
if self._validate_reference(phase, self.get_phase, "An EnergyConsumerPhase"):
return self
self._energy_consumer_phases = list() if self._energy_consumer_phases is None else self._energy_consumer_phases
self._energy_consumer_phases.append(phase)
return self
def remove_phase(self, phase: EnergyConsumerPhase) -> EnergyConsumer:
"""
Disassociate `phase` from this `OperationalRestriction`.
`phase` the `EnergyConsumerPhase` to disassociate with this `EnergyConsumer`.
Raises `KeyError` if `phase` was not associated with this `EnergyConsumer`.
Returns A reference to this `EnergyConsumer` to allow fluent use.
Raises `ValueError` if `phase` was not associated with this `EnergyConsumer`.
"""
self._energy_consumer_phases = safe_remove(self._energy_consumer_phases, phase)
return self
def clear_phases(self) -> EnergyConsumer:
"""
Clear all phases.
Returns A reference to this `EnergyConsumer` to allow fluent use.
"""
self._energy_consumer_phases = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/wires/energy_consumer.py | energy_consumer.py |
from typing import Optional
from zepben.evolve import ShuntCompensatorInfo
from zepben.evolve.model.cim.iec61970.base.wires.energy_connection import RegulatingCondEq
from zepben.evolve.model.cim.iec61970.base.wires.phase_shunt_connection_kind import PhaseShuntConnectionKind
__all__ = ["ShuntCompensator", "LinearShuntCompensator"]
class ShuntCompensator(RegulatingCondEq):
"""
A shunt capacitor or reactor or switchable bank of shunt capacitors or reactors. A section of a shunt compensator
is an individual capacitor or reactor. A negative value for reactivePerSection indicates that the compensator is
a reactor. ShuntCompensator is a single terminal device. Ground is implied.
"""
grounded: bool = False
"""Used for Yn and Zn connections. True if the neutral is solidly grounded. nom_u : The voltage at which the nominal reactive power may be calculated.
This should normally be within 10% of the voltage at which the capacitor is connected to the network."""
nom_u: Optional[int] = None
"""The voltage at which the nominal reactive power may be calculated. This should normally be within 10% of the voltage at which the capacitor is connected
to the network."""
phase_connection: PhaseShuntConnectionKind = PhaseShuntConnectionKind.UNKNOWN
"""The type of phase connection, such as wye or delta."""
sections: Optional[float] = None
"""
Shunt compensator sections in use. Starting value for steady state solution. Non integer values are allowed to support continuous variables. The
reasons for continuous value are to support study cases where no discrete shunt compensator's has yet been designed, a solutions where a narrow voltage
band force the sections to oscillate or accommodate for a continuous solution as input.
For `LinearShuntCompensator` the value shall be between zero and `ShuntCompensator.maximumSections`. At value zero the shunt compensator conductance and
admittance is zero. Linear interpolation of conductance and admittance between the previous and next integer section is applied in case of non-integer
values.
For `NonlinearShuntCompensator`s shall only be set to one of the NonlinearShuntCompensatorPoint.sectionNumber. There is no interpolation between
NonlinearShuntCompensatorPoint-s.
"""
@property
def shunt_compensator_info(self) -> Optional[ShuntCompensatorInfo]:
"""The `ShuntCompensatorInfo` for this `ShuntCompensator`"""
return self.asset_info
@shunt_compensator_info.setter
def shunt_compensator_info(self, sci: Optional[ShuntCompensatorInfo]):
"""
Set the `ShuntCompensatorInfo` for this `ShuntCompensator`
`sci` The `ShuntCompensatorInfo` for this `ShuntCompensator`
"""
self.asset_info = sci
class LinearShuntCompensator(ShuntCompensator):
"""A linear shunt compensator has banks or sections with equal admittance values."""
b0_per_section: Optional[float] = None
"""Zero sequence shunt (charging) susceptance per section"""
b_per_section: Optional[float] = None
"""Positive sequence shunt (charging) susceptance per section"""
g0_per_section: Optional[float] = None
"""Zero sequence shunt (charging) conductance per section"""
g_per_section: Optional[float] = None
"""Positive sequence shunt (charging) conductance per section""" | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/wires/shunt_compensator.py | shunt_compensator.py |
from typing import Optional
from zepben.evolve.model.cim.iec61968.assetinfo.wire_info import CableInfo, WireInfo
from zepben.evolve.model.cim.iec61970.base.core.conducting_equipment import ConductingEquipment
from zepben.evolve.model.cim.iec61970.base.wires.per_length import PerLengthSequenceImpedance
__all__ = ["AcLineSegment", "Conductor"]
class Conductor(ConductingEquipment):
"""
Combination of conducting material with consistent electrical characteristics, building a single electrical
system, used to carry current between points in the power system.
"""
length: Optional[float] = None
"""Segment length for calculating line section capabilities."""
@property
def wire_info(self):
"""The `WireInfo` for this `Conductor`"""
return self.asset_info
@wire_info.setter
def wire_info(self, wi: Optional[WireInfo]):
"""
Set the `WireInfo` for this `Conductor`
`wi` The `WireInfo` for this `Conductor`
"""
self.asset_info = wi
def is_underground(self):
"""
Returns True if this `Conductor` is underground.
"""
return isinstance(self.wire_info, CableInfo)
class AcLineSegment(Conductor):
"""
A wire or combination of wires, with consistent electrical characteristics, building a single electrical system,
used to carry alternating current between points in the power system.
For symmetrical, transposed 3ph lines, it is sufficient to use attributes of the line segment, which describe
impedances and admittances for the entire length of the segment. Additionally impedances can be computed by
using length and associated per length impedances.
The BaseVoltage at the two ends of ACLineSegments in a Line shall have the same BaseVoltage.nominalVoltage.
However, boundary lines may have slightly different BaseVoltage.nominalVoltages and variation is allowed.
Larger voltage difference in general requires use of an equivalent branch.
"""
per_length_sequence_impedance: Optional[PerLengthSequenceImpedance] = None
"""A `zepben.evolve.PerLengthSequenceImpedance` describing this ACLineSegment""" | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/wires/aclinesegment.py | aclinesegment.py |
from __future__ import annotations
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
__all__ = ["Switch", "Breaker", "Disconnector", "Jumper", "Fuse", "ProtectedSwitch", "Recloser", "LoadBreakSwitch"]
from zepben.evolve.util import require
def _calculate_open_state(current_state: int, is_open: bool, phase: SinglePhaseKind = None) -> int:
require(phase != SinglePhaseKind.NONE and phase != SinglePhaseKind.INVALID,
lambda: f"Invalid phase {phase} specified")
if phase is None:
return 0b1111 if is_open else 0
else:
return current_state | phase.bit_mask if is_open else current_state & ~phase.bit_mask
def _check_open(current_state: int, phase: SinglePhaseKind = None) -> bool:
require(phase != SinglePhaseKind.NONE and phase != SinglePhaseKind.INVALID,
lambda: f"Invalid phase {phase} specified")
if phase is None:
return current_state != 0
else:
return (current_state & phase.bit_mask) != 0
class Switch(ConductingEquipment):
"""
A generic device designed to close, or open, or both, one or more electric circuits.
All switches are two terminal devices including grounding switches.
NOTE: The normal and currently open properties are implemented as an integer rather than a boolean to allow for the caching of
measurement values if the switch is operating un-ganged. These values will cache the latest values from the measurement
value for each phase of the switch.
"""
_open: int = 0
"""Tells if the switch is considered open when used as input to topology processing."""
_normally_open: int = 0
"""The attribute is used in cases when no Measurement for the status value is present. If the Switch has a status measurement the Discrete.normalValue
is expected to match with the Switch.normalOpen."""
def is_normally_open(self, phase: SinglePhaseKind = None):
"""
Check if the switch is normally open on `phase`.
`phase` The `single_phase_kind.SinglePhaseKind` to check the normal status. A `phase` of `None` (default) checks if any phase is open.
Returns True if `phase` is open in its normal state, False if it is closed
"""
return _check_open(self._normally_open, phase)
def get_normal_state(self) -> int:
"""
Get the underlying normal open states. Stored as 4 bits, 1 per phase.
"""
return self._normally_open
def is_open(self, phase: SinglePhaseKind = None):
"""
Check if the switch is currently open on `phase`.
`phase` The `SinglePhaseKind` to check the current status. A `phase` of `None` (default) checks
if any phase is open.
Returns True if `phase` is open in its current state, False if it is closed
"""
return _check_open(self._open, phase)
def get_state(self) -> int:
"""
The attribute tells if the switch is considered open when used as input to topology processing.
Get the underlying open states. Stored as 4 bits, 1 per phase.
"""
return self._open
def set_normally_open(self, is_normally_open: bool, phase: SinglePhaseKind = None) -> Switch:
"""
`is_normally_open` indicates if the phase(s) should be opened.
`phase` the phase to set the normal status. If set to None will default to all phases.
Returns This `Switch` to be used fluently.
"""
self._normally_open = _calculate_open_state(self._normally_open, is_normally_open, phase)
return self
def set_open(self, is_open: bool, phase: SinglePhaseKind = None) -> Switch:
"""
`is_open` indicates if the phase(s) should be opened.
`phase` the phase to set the current status. If set to None will default to all phases.
Returns This `Switch` to be used fluently.
"""
self._open = _calculate_open_state(self._open, is_open, phase)
return self
class ProtectedSwitch(Switch):
"""
A ProtectedSwitch is a switching device that can be operated by ProtectionEquipment.
"""
pass
class Breaker(ProtectedSwitch):
"""
A mechanical switching device capable of making, carrying, and breaking currents under normal circuit conditions
and also making, carrying for a specified time, and breaking currents under specified abnormal circuit conditions
e.g. those of short circuit.
"""
def is_substation_breaker(self):
"""Convenience function for detecting if this breaker is part of a substation. Returns true if this Breaker is associated with a Substation."""
return self.num_substations() > 0
class Disconnector(Switch):
"""
A manually operated or motor operated mechanical switching device used for changing the connections in a circuit,
or for isolating a circuit or equipment from a source of power. It is required to open or close circuits when
negligible current is broken or made.
"""
pass
class Fuse(Switch):
"""
An overcurrent protective device with a circuit opening fusible part that is heated and severed by the passage of
overcurrent through it. A fuse is considered a switching device because it breaks current.
"""
pass
class Jumper(Switch):
"""
A short section of conductor with negligible impedance which can be manually removed and replaced if the circuit is de-energized.
Note that zero-impedance branches can potentially be modeled by other equipment types.
"""
pass
class Recloser(ProtectedSwitch):
"""
Pole-mounted fault interrupter with built-in phase and ground relays, current transformer (CT), and supplemental controls.
"""
pass
class LoadBreakSwitch(ProtectedSwitch):
"""A mechanical switching device capable of making, carrying, and breaking currents under normal operating
conditions. """
pass | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/wires/switch.py | switch.py |
from __future__ import annotations
from typing import Optional, List, Generator, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import PowerElectronicsUnit
from zepben.evolve.model.cim.iec61970.base.core.power_system_resource import PowerSystemResource
from zepben.evolve.model.cim.iec61970.base.wires.energy_connection import RegulatingCondEq
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
from zepben.evolve.util import ngen, nlen, get_by_mrid, safe_remove
__all__ = ["PowerElectronicsConnection", "PowerElectronicsConnectionPhase"]
class PowerElectronicsConnectionPhase(PowerSystemResource):
"""A single phase of a power electronics connection."""
power_electronics_connection: Optional[PowerElectronicsConnection] = None
"""The power electronics connection to which the phase belongs."""
p: Optional[float] = None
"""Active power injection. Load sign convention is used, i.e. positive sign means flow into the equipment from the network."""
phase: SinglePhaseKind = SinglePhaseKind.X
"""
Phase of this energy producer component. If the energy producer is wye connected, the connection is from the indicated phase to the central
ground or neutral point. If the energy producer is delta connected, the phase indicates an energy producer connected from the indicated phase to the next
logical non-neutral phase.
"""
q: Optional[float] = None
"""Reactive power injection. Load sign convention is used, i.e. positive sign means flow into the equipment from the network."""
class PowerElectronicsConnection(RegulatingCondEq):
"""
A connection to the AC network for energy production or consumption that uses power electronics rather than rotating machines.
"""
max_i_fault: Optional[int] = None
"""Maximum fault current this device will contribute, in per-unit of rated current, before the converter protection will trip or bypass."""
p: Optional[float] = None
"""Active power injection. Load sign convention is used, i.e. positive sign means flow out from a node. Starting value for a steady state solution."""
q: Optional[float] = None
"""Reactive power injection. Load sign convention is used, i.e. positive sign means flow out from a node. Starting value for a steady state solution."""
max_q: Optional[float] = None
"""Maximum reactive power limit. This is the maximum (nameplate) limit for the unit."""
min_q: Optional[float] = None
"""Minimum reactive power limit for the unit. This is the minimum (nameplate) limit for the unit."""
rated_s: Optional[int] = None
"""Nameplate apparent power rating for the unit. The attribute shall have a positive value."""
rated_u: Optional[int] = None
"""Rated voltage (nameplate data, Ur in IEC 60909-0). It is primarily used for short circuit data exchange according to IEC 60909.
The attribute shall be a positive value."""
_power_electronics_units: Optional[List[PowerElectronicsUnit]] = None
"""An AC network connection may have several power electronics units connecting through it."""
_power_electronics_connection_phases: Optional[List[PowerElectronicsConnectionPhase]] = None
"""The individual units models for the power electronics connection."""
def __init__(self, power_electronics_units: List[PowerElectronicsUnit] = None,
power_electronics_connection_phases: List[PowerElectronicsConnectionPhase] = None, **kwargs):
super(PowerElectronicsConnection, self).__init__(**kwargs)
if power_electronics_units:
for unit in power_electronics_units:
self.add_unit(unit)
if power_electronics_connection_phases:
for phase in power_electronics_connection_phases:
self.add_phase(phase)
@property
def units(self) -> Generator[PowerElectronicsUnit, None, None]:
"""
The `PowerElectronicsUnit`s for this `PowerElectronicsConnection`.
"""
return ngen(self._power_electronics_units)
@property
def phases(self) -> Generator[PowerElectronicsConnectionPhase, None, None]:
"""
The `PowerElectronicsConnectionPhase`s for this `PowerElectronicsConnection`.
"""
return ngen(self._power_electronics_connection_phases)
def has_units(self):
"""
Check if this connection has any associated `PowerElectronicsUnit`s
Returns True if there is at least one `PowerElectronicsUnit`, otherwise False
"""
return nlen(self._power_electronics_units) > 0
def num_units(self):
"""Return the number of `PowerElectronicsUnit`s associated with this `PowerElectronicsConnection`"""
return nlen(self._power_electronics_units)
def get_unit(self, mrid: str) -> PowerElectronicsUnit:
"""
Get the `PowerElectronicsUnit` for this
`PowerElectronicsConnection` identified by `mrid`
`mrid` the mRID of the required `PowerElectronicsUnit`
Returns The `PowerElectronicsUnit` with the specified `mrid`
if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._power_electronics_units, mrid)
def add_unit(self, unit: PowerElectronicsUnit) -> PowerElectronicsConnection:
"""
Associate an `PowerElectronicsUnit` with this
`PowerElectronicsConnection`
`unit` the `PowerElectronicsUnit` to associate with this `PowerElectronicsConnection`.
Returns A reference to this `PowerElectronicsConnection` to allow fluent use.
Raises `ValueError` if another `PowerElectronicsUnit` with the same `mrid` already exists for this `PowerElectronicsConnection`.
"""
if self._validate_reference(unit, self.get_unit, "A PowerElectronicsUnit"):
return self
self._power_electronics_units = list() if self._power_electronics_units is None else self._power_electronics_units
self._power_electronics_units.append(unit)
return self
def remove_unit(self, unit: PowerElectronicsUnit) -> PowerElectronicsConnection:
"""
Disassociate `unit` from this `PowerElectronicsConnection`
`unit` the `PowerElectronicsUnit` to disassociate from this `PowerElectronicsConnection`.
Returns A reference to this `PowerElectronicsConnection` to allow fluent use.
Raises `ValueError` if `unit` was not associated with this `PowerElectronicsConnection`.
"""
self._power_electronics_units = safe_remove(self._power_electronics_units, unit)
return self
def clear_units(self) -> PowerElectronicsConnection:
"""
Clear all units.
Returns A reference to this `PowerElectronicsConnection` to allow fluent use.
"""
self._power_electronics_units = None
return self
def has_phases(self):
"""
Check if this connection has any associated `PowerElectronicsConnectionPhase`s
Returns True if there is at least one `PowerElectronicsConnectionPhase`, otherwise False
"""
return nlen(self._power_electronics_connection_phases) > 0
def num_phases(self):
"""Return the number of `PowerElectronicsConnectionPhase`s associated with this `PowerElectronicsConnection`"""
return nlen(self._power_electronics_connection_phases)
def get_phase(self, mrid: str) -> PowerElectronicsConnectionPhase:
"""
Get the `PowerElectronicsConnectionPhase` for this `PowerElectronicsConnection` identified by `mrid`
`mrid` the mRID of the required `PowerElectronicsConnectionPhase`
Returns The `PowerElectronicsConnectionPhase` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._power_electronics_connection_phases, mrid)
def add_phase(self, phase: PowerElectronicsConnectionPhase) -> PowerElectronicsConnection:
"""
Associate a `PowerElectronicsConnectionPhase` with this `PowerElectronicsConnection`
`phase` the `PowerElectronicsConnectionPhase` to associate with this `PowerElectronicsConnection`.
Returns A reference to this `PowerElectronicsConnection` to allow fluent use.
Raises `ValueError` if another `PowerElectronicsConnectionPhase` with the same `mrid` already exists for this `PowerElectronicsConnection`.
"""
if self._validate_reference(phase, self.get_phase, "A PowerElectronicsConnectionPhase"):
return self
self._power_electronics_connection_phases = list() if self._power_electronics_connection_phases is None else self._power_electronics_connection_phases
self._power_electronics_connection_phases.append(phase)
return self
def remove_phase(self, phase: PowerElectronicsConnectionPhase) -> PowerElectronicsConnection:
"""
Disassociate `phase` from this `PowerElectronicsConnection`
`phase` the `PowerElectronicsConnectionPhase` to disassociate from this `PowerElectronicsConnection`.
Returns A reference to this `PowerElectronicsConnection` to allow fluent use.
Raises `ValueError` if `phase` was not associated with this `PowerElectronicsConnection`.
"""
self._power_electronics_connection_phases = safe_remove(self._power_electronics_connection_phases, phase)
return self
def clear_phases(self) -> PowerElectronicsConnection:
"""
Clear all phases.
Returns A reference to this `PowerElectronicsConnection` to allow fluent use.
"""
self._power_electronics_connection_phases = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/wires/power_electronics_connection.py | power_electronics_connection.py |
from __future__ import annotations
from typing import List, Optional, Dict, Generator
from dataclassy import dataclass
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.model.cim.iec61970.base.diagramlayout.diagram_style import DiagramStyle
from zepben.evolve.model.cim.iec61970.base.diagramlayout.orientation_kind import OrientationKind
from zepben.evolve.util import nlen, require, ngen, safe_remove, safe_remove_by_id
__all__ = ["DiagramObjectPoint", "Diagram", "DiagramObject"]
@dataclass(slots=True)
class DiagramObjectPoint(object):
"""
A point in a given space defined by 3 coordinates and associated to a diagram object. The coordinates may be positive
or negative as the origin does not have to be in the corner of a diagram.
"""
x_position: float
"""The X coordinate of this point."""
y_position: float
"""The Y coordinate of this point."""
def __str__(self):
return f"x:{self.x_position}|y:{self.y_position}"
class DiagramObject(IdentifiedObject):
"""
An object that defines one or more points in a given space. This object can be associated with anything
that specializes IdentifiedObject. For single line diagrams such objects typically include such items as
analog values, breakers, disconnectors, power transformers, and transmission lines.
"""
_diagram: Optional[Diagram] = None
"""A diagram object is part of a diagram."""
identified_object_mrid: Optional[str] = None
"""The domain object to which this diagram object is associated."""
style: Optional[str] = None
"""A diagram object has a style associated that provides a reference for the style used in the originating system."""
rotation: float = 0.0
"""Sets the angle of rotation of the diagram object. Zero degrees is pointing to the top of the diagram. Rotation is clockwise."""
_diagram_object_points: Optional[List[DiagramObjectPoint]] = None
def __init__(self, diagram: Diagram = None, diagram_object_points: List[DiagramObjectPoint] = None, **kwargs):
super(DiagramObject, self).__init__(**kwargs)
if diagram:
self.diagram = diagram
if diagram_object_points:
for point in diagram_object_points:
self.add_point(point)
@property
def diagram(self):
return self._diagram
@diagram.setter
def diagram(self, diag):
if self._diagram is None or self._diagram is diag:
self._diagram = diag
else:
raise ValueError(f"diagram for {str(self)} has already been set to {self._diagram}, cannot reset this field to {diag}")
def num_points(self):
"""
Returns the number of `DiagramObjectPoint`s associated with this `DiagramObject`
"""
return nlen(self._diagram_object_points)
@property
def points(self) -> Generator[DiagramObjectPoint, None, None]:
"""
The `DiagramObjectPoint`s for this `DiagramObject`.
"""
return ngen(self._diagram_object_points)
def get_point(self, sequence_number: int) -> DiagramObjectPoint:
"""
Get the `DiagramObjectPoint` for this `DiagramObject` represented by `sequence_number` .
A diagram object can have 0 or more points to reflect its layout position, routing (for polylines) or boundary (for polygons).
Index in the underlying points collection corresponds to the sequence number
`sequence_number` The sequence number of the `DiagramObjectPoint` to get.
Returns The `DiagramObjectPoint` identified by `sequence_number`
Raises IndexError if this `DiagramObject` didn't contain `sequence_number` points.
"""
if self._diagram_object_points is not None:
return self._diagram_object_points[sequence_number]
else:
raise IndexError(sequence_number)
def __getitem__(self, item: int) -> DiagramObjectPoint:
return self.get_point(item)
def add_point(self, point: DiagramObjectPoint) -> DiagramObject:
"""
Associate a `DiagramObjectPoint` with this `DiagramObject`, assigning it a sequence_number of `num_points`.
`point` The `DiagramObjectPoint` to associate with this `DiagramObject`.
Returns A reference to this `DiagramObject` to allow fluent use.
"""
return self.insert_point(point)
def insert_point(self, point: DiagramObjectPoint, sequence_number: int = None) -> DiagramObject:
"""
Associate a `DiagramObjectPoint` with this `DiagramObject`
`point` The `DiagramObjectPoint` to associate with this `DiagramObject`.
`sequence_number` The sequence number of the `DiagramObjectPoint`.
Returns A reference to this `DiagramObject` 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 DiagramObjectPoint 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._diagram_object_points = list() if self._diagram_object_points is None else self._diagram_object_points
self._diagram_object_points.insert(sequence_number, point)
return self
def __setitem__(self, key, value):
self.insert_point(value, key)
def remove_point(self, point: DiagramObjectPoint) -> DiagramObject:
"""
Disassociate `point` from this `DiagramObject`
`point` The `DiagramObjectPoint` to disassociate from this `DiagramObject`.
Returns A reference to this `DiagramObject` to allow fluent use.
Raises `ValueError` if `point` was not associated with this `DiagramObject`.
"""
self._diagram_object_points = safe_remove(self._diagram_object_points, point)
return self
def clear_points(self) -> DiagramObject:
"""
Clear all points.
Returns A reference to this `DiagramObject` to allow fluent use.
"""
self._diagram_object_points = None
return self
class Diagram(IdentifiedObject):
"""
The diagram being exchanged. The coordinate system is a standard Cartesian coordinate system and the orientation
attribute defines the orientation.
"""
diagram_style: DiagramStyle = DiagramStyle.SCHEMATIC
"""A Diagram may have a DiagramStyle."""
orientation_kind: OrientationKind = OrientationKind.POSITIVE
"""Coordinate system orientation of the diagram."""
_diagram_objects: Optional[Dict[str, DiagramObject]] = None
def __init__(self, diagram_objects: List[DiagramObject] = None, **kwargs):
super(Diagram, self).__init__(**kwargs)
if diagram_objects:
for obj in diagram_objects:
self.add_diagram_object(obj)
def num_diagram_objects(self):
"""
Returns The number of `DiagramObject`s associated with this `Diagram`
"""
return nlen(self._diagram_objects)
@property
def diagram_objects(self) -> Generator[DiagramObject, None, None]:
"""
The diagram objects belonging to this diagram.
"""
return ngen(self._diagram_objects.values() if self._diagram_objects is not None else None)
def get_diagram_object(self, mrid: str) -> DiagramObject:
"""
Get the `DiagramObject` for this `Diagram` identified by `mrid`
`mrid` the mRID of the required `DiagramObject`
Returns The `DiagramObject` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
if not self._diagram_objects:
raise KeyError(mrid)
try:
return self._diagram_objects[mrid]
except AttributeError:
raise KeyError(mrid)
def add_diagram_object(self, diagram_object: DiagramObject) -> Diagram:
"""
Associate a `DiagramObject` with this `Diagram`.
`diagram_object` the `DiagramObject` to associate with this `Diagram`.
Returns The previous `DiagramObject` stored by `diagram_object`s mrid, otherwise `diagram_object` is returned
if there was no previous value.
Raises `ValueError` if another `DiagramObject` with the same `mrid` already exists for this `Diagram`, or if `diagram_object.diagram` is not this
`Diagram`.
"""
if not diagram_object.diagram:
diagram_object.diagram = self
require(diagram_object.diagram is self, lambda: f"{str(diagram_object)} references another Diagram "
f"{str(diagram_object.diagram)}, expected {str(self)}.")
if self._validate_reference(diagram_object, self.get_diagram_object, "A DiagramObject"):
return self
self._diagram_objects = dict() if self._diagram_objects is None else self._diagram_objects
self._diagram_objects[diagram_object.mrid] = diagram_object
return self
def remove_diagram_object(self, diagram_object: DiagramObject) -> Diagram:
"""
Disassociate `diagram_object` from this `Diagram`
`diagram_object` the `DiagramObject` to disassociate with this `Diagram`.
Returns A reference to this `Diagram` to allow fluent use.
Raises `KeyError` if `diagram_object` was not associated with this `Diagram`.
"""
self._diagram_objects = safe_remove_by_id(self._diagram_objects, diagram_object)
return self
def clear_diagram_objects(self) -> Diagram:
"""
Clear all `DiagramObject`s.
Returns A reference to this `Diagram` to allow fluent use.
"""
self._diagram_objects = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/diagramlayout/diagram_layout.py | diagram_layout.py |
from __future__ import annotations
from typing import Optional, Generator, List, TYPE_CHECKING, TypeVar, Type
if TYPE_CHECKING:
from zepben.evolve import UsagePoint, EquipmentContainer, OperationalRestriction
TEquipmentContainer = TypeVar("TEquipmentContainer", bound=EquipmentContainer)
from zepben.evolve.model.cim.iec61970.base.core.equipment_container import Feeder, Site
from zepben.evolve.model.cim.iec61970.base.core.power_system_resource import PowerSystemResource
from zepben.evolve.model.cim.iec61970.base.core.substation import Substation
from zepben.evolve.model.cim.iec61970.infiec61970.feeder.lv_feeder import LvFeeder
from zepben.evolve.util import nlen, get_by_mrid, ngen, safe_remove
__all__ = ['Equipment']
class Equipment(PowerSystemResource):
"""
Abstract class, should only be used through subclasses.
Any part of a power system that is a physical device, electronic or mechanical.
"""
in_service: bool = True
"""If True, the equipment is in service."""
normally_in_service: bool = True
"""If True, the equipment is _normally_ in service."""
_usage_points: Optional[List[UsagePoint]] = None
_equipment_containers: Optional[List[EquipmentContainer]] = None
_operational_restrictions: Optional[List[OperationalRestriction]] = None
_current_containers: Optional[List[EquipmentContainer]] = None
def __init__(self, usage_points: List[UsagePoint] = None, equipment_containers: List[EquipmentContainer] = None,
operational_restrictions: List[OperationalRestriction] = None, current_containers: List[EquipmentContainer] = None, **kwargs):
super(Equipment, self).__init__(**kwargs)
if usage_points:
for up in usage_points:
self.add_usage_point(up)
if equipment_containers:
for container in equipment_containers:
self.add_container(container)
if operational_restrictions:
for restriction in operational_restrictions:
self.add_operational_restriction(restriction)
if current_containers:
for cf in current_containers:
self.add_current_container(cf)
@property
def sites(self) -> Generator[Site, None, None]:
"""
The `Site`s this equipment belongs to.
"""
return ngen(_of_type(self._equipment_containers, Site))
@property
def normal_feeders(self) -> Generator[Feeder, None, None]:
"""
The normal `Feeder`s this equipment belongs to.
"""
return ngen(_of_type(self._equipment_containers, Feeder))
@property
def normal_lv_feeders(self) -> Generator[LvFeeder, None, None]:
"""
The normal `LvFeeder`s this equipment belongs to.
"""
return ngen(_of_type(self._equipment_containers, LvFeeder))
@property
def substations(self) -> Generator[Substation, None, None]:
"""
The `Substation`s this equipment belongs to.
"""
return ngen(_of_type(self._equipment_containers, Substation))
@property
def current_feeders(self) -> Generator[Feeder, None, None]:
"""
The current `Feeder`s this equipment belongs to.
"""
return ngen(_of_type(self._current_containers, Feeder))
@property
def current_lv_feeders(self) -> Generator[LvFeeder, None, None]:
"""
The current `LvFeeder`s this equipment belongs to.
"""
return ngen(_of_type(self._current_containers, LvFeeder))
@property
def containers(self) -> Generator[EquipmentContainer, None, None]:
"""
The `EquipmentContainer`s this equipment belongs to.
"""
return ngen(self._equipment_containers)
def num_containers(self) -> int:
"""
Returns The number of `EquipmentContainer`s associated with this `Equipment`
"""
return nlen(self._equipment_containers)
def num_substations(self) -> int:
"""
Returns The number of `zepben.evolve.cim.iec61970.base.core.substation.Substation`s associated with this `Equipment`
"""
return len(_of_type(self._equipment_containers, Substation))
def num_sites(self) -> int:
"""
Returns The number of `Site`s associated with this `Equipment`
"""
return len(_of_type(self._equipment_containers, Site))
def num_normal_feeders(self) -> int:
"""
Returns The number of normal `Feeder`s associated with this `Equipment`
"""
return len(_of_type(self._equipment_containers, Feeder))
def num_usage_points(self) -> int:
"""
Returns The number of `UsagePoint`s associated with this `Equipment`
"""
return nlen(self._usage_points)
def num_current_containers(self) -> int:
"""
Returns The number of `EquipmentContainer`s associated with this `Equipment`
"""
return nlen(self._current_containers)
def num_operational_restrictions(self) -> int:
"""
Returns The number of `OperationalRestriction`s associated with this `Equipment`
"""
return nlen(self._operational_restrictions)
def get_container(self, mrid: str) -> EquipmentContainer:
"""
Get the `EquipmentContainer` for this `Equipment` identified by `mrid`
`mrid` The mRID of the required `EquipmentContainer`
Returns The `EquipmentContainer` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._equipment_containers, mrid)
def add_container(self, ec: EquipmentContainer) -> Equipment:
"""
Associate an `EquipmentContainer` with this `Equipment`
`ec` The `EquipmentContainer` to associate with this `Equipment`.
Returns A reference to this `Equipment` to allow fluent use.
Raises `ValueError` if another `EquipmentContainer` with the same `mrid` already exists for this `Equipment`.
"""
if self._validate_reference(ec, self.get_container, "An EquipmentContainer"):
return self
self._equipment_containers = list() if self._equipment_containers is None else self._equipment_containers
self._equipment_containers.append(ec)
return self
def remove_container(self, ec: EquipmentContainer) -> Equipment:
"""
Disassociate `ec` from this `Equipment`.
`ec` The `EquipmentContainer` to disassociate from this `Equipment`.
Returns A reference to this `Equipment` to allow fluent use.
Raises `ValueError` if `ec` was not associated with this `Equipment`.
"""
self._equipment_containers = safe_remove(self._equipment_containers, ec)
return self
def clear_containers(self) -> Equipment:
"""
Clear all equipment.
Returns A reference to this `Equipment` to allow fluent use.
"""
self._equipment_containers = None
return self
@property
def current_containers(self) -> Generator[EquipmentContainer, None, None]:
"""
The `EquipmentContainer`s this equipment belongs to in the current state of the network.
"""
return ngen(self._current_containers)
def get_current_container(self, mrid: str) -> EquipmentContainer:
"""
Get the `EquipmentContainer` for this `Equipment` in the current state of the network, identified by `mrid`
`mrid` The mRID of the required `EquipmentContainer`
Returns The `EquipmentContainer` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._current_containers, mrid)
def add_current_container(self, equipment_container: EquipmentContainer) -> Equipment:
"""
Associate `equipment_container` with this `Equipment` in the current state of the network.
`equipment_container` The `EquipmentContainer` to associate with this `Equipment`.
Returns A reference to this `Equipment` to allow fluent use.
Raises `ValueError` if another `EquipmentContainer` with the same `mrid` already exists for this `Equipment`.
"""
if self._validate_reference(equipment_container, self.get_current_container, "A current EquipmentContainer"):
return self
self._current_containers = list() if self._current_containers is None else self._current_containers
self._current_containers.append(equipment_container)
return self
def remove_current_container(self, equipment_container: EquipmentContainer) -> Equipment:
"""
Disassociate `equipment_container` from this `Equipment` in the current state of the network.
`equipment_container` The `EquipmentContainer` to disassociate from this `Equipment`.
Returns A reference to this `Equipment` to allow fluent use.
Raises `ValueError` if `equipment_container` was not associated with this `Equipment`.
"""
self._current_containers = safe_remove(self._current_containers, equipment_container)
return self
def clear_current_containers(self) -> Equipment:
"""
Clear all current `EquipmentContainer`s in the current state of the network.
Returns A reference to this `Equipment` to allow fluent use.
"""
self._current_containers = None
return self
@property
def usage_points(self) -> Generator[UsagePoint, None, None]:
"""
The `UsagePoint`s for this equipment.
"""
return ngen(self._usage_points)
def get_usage_point(self, mrid: str) -> UsagePoint:
"""
Get the `UsagePoint` for this `Equipment` 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) -> Equipment:
"""
Associate `up` with this `Equipment`.
`up` the `UsagePoint` to associate with this `Equipment`.
Returns A reference to this `Equipment` to allow fluent use.
Raises `ValueError` if another `UsagePoint` with the same `mrid` already exists for this `Equipment`.
"""
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) -> Equipment:
"""
Disassociate `up` from this `Equipment`.
`up` The `UsagePoint` to disassociate from this `Equipment`.
Returns A reference to this `Equipment` to allow fluent use.
Raises `ValueError` if `up` was not associated with this `Equipment`.
"""
self._usage_points = safe_remove(self._usage_points, up)
return self
def clear_usage_points(self) -> Equipment:
"""
Clear all usage_points.
Returns A reference to this `Equipment` to allow fluent use.
"""
self._usage_points = None
return self
@property
def operational_restrictions(self) -> Generator[OperationalRestriction, None, None]:
"""
The `OperationalRestriction`s that this equipment is associated with.
"""
return ngen(self._operational_restrictions)
def get_operational_restriction(self, mrid: str) -> OperationalRestriction:
"""
Get the `OperationalRestriction` for this `Equipment` identified by `mrid`
`mrid` The mRID of the required `OperationalRestriction`
Returns The `OperationalRestriction` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._operational_restrictions, mrid)
def add_operational_restriction(self, op: OperationalRestriction) -> Equipment:
"""
Associate `op` with this `Equipment`.
`op` The `OperationalRestriction` to associate with this `Equipment`.
Returns A reference to this `Equipment` to allow fluent use.
Raises `ValueError` if another `OperationalRestriction` with the same `mrid` already exists for this `Equipment`.
"""
if self._validate_reference(op, self.get_operational_restriction, "An OperationalRestriction"):
return self
self._operational_restrictions = list() if self._operational_restrictions is None else self._operational_restrictions
self._operational_restrictions.append(op)
return self
def remove_operational_restriction(self, op: OperationalRestriction) -> Equipment:
"""
Disassociate `up` from this `Equipment`.
`op` The `OperationalRestriction` to disassociate from this `Equipment`.
Returns A reference to this `Equipment` to allow fluent use.
Raises `ValueError` if `op` was not associated with this `Equipment`.
"""
self._operational_restrictions = safe_remove(self._operational_restrictions, op)
return self
def clear_operational_restrictions(self) -> Equipment:
"""
Clear all `OperationalRestrictions`.
Returns A reference to this `Equipment` to allow fluent use.
"""
self._operational_restrictions = None
return self
def _of_type(containers: Optional[List[EquipmentContainer]], ectype: Type[TEquipmentContainer]) -> List[TEquipmentContainer]:
if containers:
return [ec for ec in containers if isinstance(ec, ectype)]
else:
return [] | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/equipment.py | equipment.py |
from __future__ import annotations
from typing import Optional, Generator
from typing import TYPE_CHECKING
from weakref import ref, ReferenceType
from zepben.evolve.services.network.tracing.phases.phase_status import NormalPhases, CurrentPhases
from zepben.evolve.services.network.tracing.feeder.feeder_direction import FeederDirection
if TYPE_CHECKING:
from zepben.evolve import ConnectivityNode, ConductingEquipment, PhaseStatus
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.model.cim.iec61970.base.core.phase_code import PhaseCode
from zepben.evolve.model.phases import TracedPhases
__all__ = ["AcDcTerminal", "Terminal"]
class AcDcTerminal(IdentifiedObject):
"""
An electrical connection point (AC or DC) to a piece of conducting equipment. Terminals are connected at physical
connection points called connectivity nodes.
"""
pass
class Terminal(AcDcTerminal):
"""
An AC electrical connection point to a piece of conducting equipment. Terminals are connected at physical connection points called connectivity nodes.
"""
_conducting_equipment: Optional[ConductingEquipment] = None
"""The conducting equipment of the terminal. Conducting equipment have terminals that may be connected to other conducting equipment terminals via
connectivity nodes."""
phases: PhaseCode = PhaseCode.ABC
"""Represents the normal network phasing condition. If the attribute is missing three phases (ABC) shall be assumed."""
sequence_number: int = 0
"""The orientation of the terminal connections for a multiple terminal conducting equipment. The sequence numbering starts with 1 and additional
terminals should follow in increasing order. The first terminal is the "starting point" for a two terminal branch."""
normal_feeder_direction: FeederDirection = FeederDirection.NONE
""" Stores the direction of the feeder head relative to this [Terminal] in the normal state of the network.
"""
current_feeder_direction: FeederDirection = FeederDirection.NONE
""" Stores the direction of the feeder head relative to this [Terminal] in the current state of the network.
"""
traced_phases: TracedPhases = TracedPhases()
"""the phase object representing the traced phases in both the normal and current network. If properly configured you would expect the normal state phases
to match those in `phases`"""
_cn: Optional[ReferenceType] = None
"""This is a weak reference to the connectivity node so if a Network object goes out of scope, holding a single conducting equipment
reference does not cause everything connected to it in the network to stay in memory."""
def __init__(self, conducting_equipment: ConductingEquipment = None, connectivity_node: ConnectivityNode = None, **kwargs):
super(Terminal, self).__init__(**kwargs)
if conducting_equipment:
self.conducting_equipment = conducting_equipment
# We set the connectivity node to itself if the name parameter is not used to make sure the positional argument is wrapped in a reference.
if connectivity_node:
self.connectivity_node = connectivity_node
else:
self.connectivity_node = self._cn
@property
def conducting_equipment(self):
"""
The conducting equipment of the terminal. Conducting equipment have terminals that may be connected to other conducting equipment terminals via
connectivity nodes.
"""
return self._conducting_equipment
@conducting_equipment.setter
def conducting_equipment(self, ce):
if self._conducting_equipment is None or self._conducting_equipment is ce:
self._conducting_equipment = ce
else:
raise ValueError(f"conducting_equipment for {str(self)} has already been set to {self._conducting_equipment}, cannot reset this field to {ce}")
@property
def connectivity_node(self) -> Optional[ConnectivityNode]:
if self._cn:
return self._cn()
else:
return None
@connectivity_node.setter
def connectivity_node(self, cn: Optional[ConnectivityNode]):
if cn:
self._cn = ref(cn)
else:
self._cn = None
@property
def connected(self) -> bool:
if self.connectivity_node:
return True
return False
@property
def connectivity_node_id(self):
return self.connectivity_node.mrid if self.connectivity_node is not None else None
def __repr__(self):
return f"Terminal{{{self.mrid}}}"
def get_switch(self):
"""
Get any associated switch for this Terminal
Returns Switch if present in this terminals ConnectivityNode, else None
"""
return self.connectivity_node.get_switch()
@property
def base_voltage(self):
return self.conducting_equipment.get_base_voltage(self)
def connected_terminals(self) -> Generator[Terminal]:
"""
Get the terminals that are connected to this `Terminal`.
:return: A `Generator` of terminals that are connected to this `Terminal`.
"""
for t in self.connectivity_node.terminals if self.connectivity_node else []:
if t is not self:
yield t
def other_terminals(self) -> Generator[Terminal]:
"""
* Get the terminals that share the same `ConductingEquipment` as this `Terminal`.
*
:return: A `Generator` of terminals that share the same `ConductingEquipment` as this `Terminal`.
"""
for t in self.conducting_equipment.terminals:
if t is not self:
yield t
@property
def normal_phases(self) -> PhaseStatus:
"""
Convenience method for accessing the normal phases.
:return: The [PhaseStatus] for the terminal in the normal state of the network.
"""
return NormalPhases(self)
@property
def current_phases(self) -> PhaseStatus:
"""
Convenience method for accessing the current phases.
:return: The `PhaseStatus` for the terminal in the normal state of the network.
"""
return CurrentPhases(self)
def connect(self, connectivity_node: ConnectivityNode):
self.connectivity_node = connectivity_node
def disconnect(self):
self.connectivity_node = None | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/terminal.py | terminal.py |
from __future__ import annotations
from typing import Optional, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Substation
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__ = ["GeographicalRegion", "SubGeographicalRegion"]
class GeographicalRegion(IdentifiedObject):
"""
A geographical region of a power system network phases.
"""
_sub_geographical_regions: Optional[List[SubGeographicalRegion]] = None
def __init__(self, sub_geographical_regions: List[SubGeographicalRegion] = None, **kwargs):
super(GeographicalRegion, self).__init__(**kwargs)
if sub_geographical_regions:
for sgr in sub_geographical_regions:
self.add_sub_geographical_region(sgr)
def num_sub_geographical_regions(self) -> int:
"""
Returns The number of `SubGeographicalRegion`s associated with this `GeographicalRegion`
"""
return nlen(self._sub_geographical_regions)
@property
def sub_geographical_regions(self) -> Generator[SubGeographicalRegion, None, None]:
"""
The `SubGeographicalRegion`s of this `GeographicalRegion`.
"""
return ngen(self._sub_geographical_regions)
def get_sub_geographical_region(self, mrid: str) -> SubGeographicalRegion:
"""
Get the `SubGeographicalRegion` for this `GeographicalRegion` identified by `mrid`
`mrid` The mRID of the required `SubGeographicalRegion`
Returns The `SubGeographicalRegion` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._sub_geographical_regions, mrid)
def add_sub_geographical_region(self, sub_geographical_region: SubGeographicalRegion) -> GeographicalRegion:
"""
Associate a `SubGeographicalRegion` with this `GeographicalRegion`
`sub_geographical_region` The `SubGeographicalRegion` to associate with this `GeographicalRegion`.
Returns A reference to this `GeographicalRegion` to allow fluent use.
Raises `ValueError` if another `SubGeographicalRegion` with the same `mrid` already exists for this `GeographicalRegion`.
"""
if self._validate_reference(sub_geographical_region, self.get_sub_geographical_region, "A SubGeographicalRegion"):
return self
self._sub_geographical_regions = list() if self._sub_geographical_regions is None else self._sub_geographical_regions
self._sub_geographical_regions.append(sub_geographical_region)
return self
def remove_sub_geographical_region(self, sub_geographical_region: SubGeographicalRegion) -> GeographicalRegion:
"""
Disassociate `sub_geographical_region` from this `GeographicalRegion`
`sub_geographical_region` The `SubGeographicalRegion` to disassociate from this `GeographicalRegion`.
Returns A reference to this `GeographicalRegion` to allow fluent use.
Raises `ValueError` if `sub_geographical_region` was not associated with this `GeographicalRegion`.
"""
self._sub_geographical_regions = safe_remove(self._sub_geographical_regions, sub_geographical_region)
return self
def clear_sub_geographical_regions(self) -> GeographicalRegion:
"""
Clear all SubGeographicalRegions.
Returns A reference to this `GeographicalRegion` to allow fluent use.
"""
self._sub_geographical_regions = None
return self
class SubGeographicalRegion(IdentifiedObject):
"""
A subset of a geographical region of a power system network model.
"""
geographical_region: Optional[GeographicalRegion] = None
"""The geographical region to which this sub-geographical region is within."""
_substations: Optional[List[Substation]] = None
def __init__(self, substations: List[Substation] = None, **kwargs):
super(SubGeographicalRegion, self).__init__(**kwargs)
if substations:
for sub in substations:
self.add_substation(sub)
def num_substations(self) -> int:
"""
Returns The number of `Substation`s associated with this `SubGeographicalRegion`
"""
return nlen(self._substations)
@property
def substations(self) -> Generator[Substation, None, None]:
"""
All substations belonging to this sub geographical region.
"""
return ngen(self._substations)
def get_substation(self, mrid: str) -> Substation:
"""
Get the `Substation` for this `SubGeographicalRegion` 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) -> SubGeographicalRegion:
"""
Associate a `Substation` with this `GeographicalRegion`
`substation` the `Substation` to associate with this `SubGeographicalRegion`.
Returns A reference to this `SubGeographicalRegion` to allow fluent use.
Raises `ValueError` if another `Substation` with the same `mrid` already exists for this
`GeographicalRegion`.
"""
if self._validate_reference(substation, self.get_substation, "A 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) -> SubGeographicalRegion:
"""
Disassociate `substation` from this `GeographicalRegion`
`substation` The `Substation` to disassociate from this `SubGeographicalRegion`.
Returns A reference to this `SubGeographicalRegion` to allow fluent use.
Raises `ValueError` if `substation` was not associated with this `SubGeographicalRegion`.
"""
self._substations = safe_remove(self._substations, substation)
return self
def clear_substations(self) -> SubGeographicalRegion:
"""
Clear all `Substations`.
Returns A reference to this `SubGeographicalRegion` to allow fluent use.
"""
self._substations = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/regions.py | regions.py |
from __future__ import annotations
from typing import Optional, Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Loop, Circuit, Feeder
from zepben.evolve.model.cim.iec61970.base.core.equipment_container import EquipmentContainer
from zepben.evolve.model.cim.iec61970.base.core.regions import SubGeographicalRegion
from zepben.evolve.util import nlen, get_by_mrid, ngen, safe_remove
__all__ = ["Substation"]
class Substation(EquipmentContainer):
"""
A collection of equipment for purposes other than generation or utilization, through which electric energy in bulk
is passed for the purposes of switching or modifying its characteristics.
"""
sub_geographical_region: Optional[SubGeographicalRegion] = None
"""The SubGeographicalRegion containing the substation."""
_normal_energized_feeders: Optional[List[Feeder]] = None
_loops: Optional[List[Loop]] = None
_energized_loops: Optional[List[Loop]] = None
_circuits: Optional[List[Circuit]] = None
def __init__(self, normal_energized_feeders: List[Feeder] = None, loops: List[Loop] = None, energized_loops: List[Loop] = None,
circuits: List[Circuit] = None, **kwargs):
super(Substation, self).__init__(**kwargs)
if normal_energized_feeders:
for feeder in normal_energized_feeders:
self.add_feeder(feeder)
if loops:
for loop in loops:
self.add_loop(loop)
if energized_loops:
for loop in energized_loops:
self.add_energized_loop(loop)
if circuits:
for circuit in circuits:
self.add_circuit(circuit)
@property
def circuits(self) -> Generator[Circuit, None, None]:
"""
The `Circuit`s originating from this substation.
"""
return ngen(self._circuits)
@property
def loops(self) -> Generator[Loop, None, None]:
"""
The `Loop` originating from this substation.
"""
return ngen(self._loops)
@property
def energized_loops(self) -> Generator[Loop, None, None]:
"""
The `Loop`s originating from this substation that are energised.
"""
return ngen(self._energized_loops)
@property
def feeders(self) -> Generator[Feeder, None, None]:
"""
The normal energized feeders of the substation. Also used for naming purposes.
"""
return ngen(self._normal_energized_feeders)
def num_feeders(self):
"""
Returns The number of `Feeder`s associated with this `Substation`
"""
return nlen(self._normal_energized_feeders)
def get_feeder(self, mrid: str) -> Feeder:
"""
Get the `Feeder` for this `Substation` identified by `mrid`
`mrid` The mRID of the required `Feeder`
Returns The `Feeder` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._normal_energized_feeders, mrid)
def add_feeder(self, feeder: Feeder) -> Substation:
"""
Associate a `Feeder` with this `Substation`
`feeder` The `Feeder` to associate with this `Substation`.
Returns A reference to this `Substation` to allow fluent use.
Raises `ValueError` if another `Feeder` with the same `mrid` already exists for this `Substation`.
"""
if self._validate_reference(feeder, self.get_feeder, "A Feeder"):
return self
self._normal_energized_feeders = list() if self._normal_energized_feeders is None else self._normal_energized_feeders
self._normal_energized_feeders.append(feeder)
return self
def remove_feeder(self, feeder: Feeder) -> Substation:
"""
Disassociate `feeder` from this `Substation`
`feeder` The `Feeder` to disassociate from this `Substation`.
Returns A reference to this `Substation` to allow fluent use.
Raises `ValueError` if `feeder` was not associated with this `Substation`.
"""
self._normal_energized_feeders = safe_remove(self._normal_energized_feeders, feeder)
return self
def clear_feeders(self) -> Substation:
"""
Clear all current `Feeder`s.
Returns A reference to this `Substation` to allow fluent use.
"""
self._normal_energized_feeders = None
return self
def num_loops(self):
"""
Returns The number of `Loop`s associated with this `Substation`
"""
return nlen(self._loops)
def get_loop(self, mrid: str) -> Loop:
"""
Get the `Loop` for this `Substation` identified by `mrid`
`mrid` The mRID of the required `Loop`
Returns The `Loop` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._loops, mrid)
def add_loop(self, loop: Loop) -> Substation:
"""
Associate a `Loop` with this `Substation`
`loop` The `Loop` to associate with this `Substation`.
Returns A reference to this `Substation` to allow fluent use.
Raises `ValueError` if another `Loop` with the same `mrid` already exists for this `Substation`.
"""
if self._validate_reference(loop, self.get_loop, "A Loop"):
return self
self._loops = list() if self._loops is None else self._loops
self._loops.append(loop)
return self
def remove_loop(self, loop: Loop) -> Substation:
"""
Disassociate `loop` from this `Substation`
`loop` The `Loop` to disassociate from this `Substation`.
Returns A reference to this `Substation` to allow fluent use.
Raises `ValueError` if `loop` was not associated with this `Substation`.
"""
self._loops = safe_remove(self._loops, loop)
return self
def clear_loops(self) -> Substation:
"""
Clear all current `Loop`s.
Returns A reference to this `Substation` to allow fluent use.
"""
self._loops = None
return self
def num_energized_loops(self):
"""
Returns The number of `Loop`s associated with this `Substation`
"""
return nlen(self._energized_loops)
def get_energized_loop(self, mrid: str) -> Loop:
"""
Get the `Loop` for this `Substation` identified by `mrid`
`mrid` The mRID of the required `Loop`
Returns The `Loop` with the specified `mrid` if it exists
Raises `KeyError` if `mrid` wasn't present.
"""
return get_by_mrid(self._energized_loops, mrid)
def add_energized_loop(self, loop: Loop) -> Substation:
"""
Associate a `Loop` with this `Substation`
`loop` The `Loop` to associate with this `Substation`.
Returns A reference to this `Substation` to allow fluent use.
Raises `ValueError` if another `Loop` with the same `mrid` already exists for this `Substation`.
"""
if self._validate_reference(loop, self.get_energized_loop, "A Loop"):
return self
self._energized_loops = list() if self._energized_loops is None else self._energized_loops
self._energized_loops.append(loop)
return self
def remove_energized_loop(self, loop: Loop) -> Substation:
"""
Disassociate `loop` from this `Substation`
`loop` The `Loop` to disassociate from this `Substation`.
Returns A reference to this `Substation` to allow fluent use.
Raises `ValueError` if `loop` was not associated with this `Substation`.
"""
self._energized_loops = safe_remove(self._energized_loops, loop)
return self
def clear_energized_loops(self) -> Substation:
"""
Clear all current `Loop`s.
Returns A reference to this `Substation` to allow fluent use.
"""
self._energized_loops = None
return self
def num_circuits(self):
"""
Returns The number of `Circuit`s associated with this `Substation`
"""
return nlen(self._circuits)
def get_circuit(self, mrid: str) -> Circuit:
"""
Get the `Circuit` for this `Substation` 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) -> Substation:
"""
Associate a `Circuit` with this `Substation`
`circuit` The `Circuit` to associate with this `Substation`.
Returns A reference to this `Substation` to allow fluent use.
Raises `ValueError` if another `Circuit` with the same `mrid` already exists for this `Substation`.
"""
if self._validate_reference(circuit, self.get_circuit, "A 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) -> Substation:
"""
Disassociate `circuit` from this `Substation`
`circuit` The `Circuit` to disassociate from this `Substation`.
Returns A reference to this `Substation` to allow fluent use.
Raises `ValueError` if `circuit` was not associated with this `Substation`.
"""
self._circuits = safe_remove(self._circuits, circuit)
return self
def clear_circuits(self) -> Substation:
"""
Clear all current `Circuit`s.
Returns A reference to this `Substation` to allow fluent use.
"""
self._circuits = None
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/substation.py | substation.py |
from enum import Enum, unique
from typing import List, Set
from zepben.evolve.model.cim.iec61970.base.wires.single_phase_kind import SinglePhaseKind
__all__ = ["PhaseCode", "phase_code_by_id", "phase_code_from_single_phases"]
def phase_code_by_id(value: int):
"""
Get a PhaseCode by its value
`value` ID of the PhaseCode from 0 as per the order of definition
Returns The PhaseCode
"""
return _PHASE_CODE_VALUES[value]
@unique
class PhaseCode(Enum):
"""
An unordered enumeration of phase identifiers. Allows designation of phases for both transmission and distribution equipment,
circuits and loads. The enumeration, by itself, does not describe how the phases are connected together or connected to ground.
Ground is not explicitly denoted as a phase.
Residential and small commercial loads are often served from single-phase, or split-phase, secondary circuits. For example of s12N,
phases 1 and 2 refer to hot wires that are 180 degrees out of phase, while N refers to the neutral wire. Through single-phase
transformer connections, these secondary circuits may be served from one or two of the primary phases A, B, and C. For three-phase
loads, use the A, B, C phase codes instead of s12N.
"""
NONE = (0, [SinglePhaseKind.NONE])
"""No phases specified"""
A = (1, [SinglePhaseKind.A])
"""Phase A"""
B = (2, [SinglePhaseKind.B])
"""Phase B"""
C = (3, [SinglePhaseKind.C])
"""Phase C"""
N = (4, [SinglePhaseKind.N])
"""Neutral Phase"""
AB = (5, [SinglePhaseKind.A, SinglePhaseKind.B])
"""Phases A and B"""
AC = (6, [SinglePhaseKind.A, SinglePhaseKind.C])
"""Phases A and C"""
AN = (7, [SinglePhaseKind.A, SinglePhaseKind.N])
"""Phases A and N"""
BC = (8, [SinglePhaseKind.B, SinglePhaseKind.C])
"""Phases B and C"""
BN = (9, [SinglePhaseKind.B, SinglePhaseKind.N])
"""Phases B and N"""
CN = (10, [SinglePhaseKind.C, SinglePhaseKind.N])
"""Phases C and N"""
ABC = (11, [SinglePhaseKind.A, SinglePhaseKind.B, SinglePhaseKind.C])
"""Phases A, B and C"""
ABN = (12, [SinglePhaseKind.A, SinglePhaseKind.B, SinglePhaseKind.N])
"""Phases A, B and neutral"""
ACN = (13, [SinglePhaseKind.A, SinglePhaseKind.C, SinglePhaseKind.N])
"""Phases A, C and neutral"""
BCN = (14, [SinglePhaseKind.B, SinglePhaseKind.C, SinglePhaseKind.N])
"""Phases B, C and neutral"""
ABCN = (15, [SinglePhaseKind.A, SinglePhaseKind.B, SinglePhaseKind.C, SinglePhaseKind.N])
"""Phases A, B, C and neutral"""
X = (16, [SinglePhaseKind.X])
"""Unknown non-neutral phase"""
XN = (17, [SinglePhaseKind.X, SinglePhaseKind.N])
"""Unknown non-neutral phase plus neutral"""
XY = (18, [SinglePhaseKind.X, SinglePhaseKind.Y])
"""Two Unknown non-neutral phases"""
XYN = (19, [SinglePhaseKind.X, SinglePhaseKind.Y, SinglePhaseKind.N])
"""Two Unknown non-neutral phases plus neutral"""
Y = (20, [SinglePhaseKind.Y])
"""Unknown non-neutral phase"""
YN = (21, [SinglePhaseKind.Y, SinglePhaseKind.N])
"""Unknown non-neutral phase plus neutral"""
# pylint: disable=invalid-name
s1 = (22, [SinglePhaseKind.s1])
"""Secondary phase 1"""
s1N = (23, [SinglePhaseKind.s1, SinglePhaseKind.N])
"""Secondary phase 1 plus neutral"""
s12 = (24, [SinglePhaseKind.s1, SinglePhaseKind.s2])
"""Secondary phase 1 and 2"""
s12N = (25, [SinglePhaseKind.s1, SinglePhaseKind.s2, SinglePhaseKind.N])
"""Secondary phases 1, 2, and neutral"""
s2 = (26, [SinglePhaseKind.s2])
"""Secondary phase 2"""
s2N = (27, [SinglePhaseKind.s2, SinglePhaseKind.N])
"""Secondary phase 2 plus neutral"""
# pylint: enable=invalid-name
@property
def short_name(self) -> str:
"""Get the name of this `PhaseCode` without the class qualifier"""
return str(self)[10:]
@property
def single_phases(self) -> List[SinglePhaseKind]:
"""Get the list of `SinglePhaseKind` that make up this `PhaseCode`"""
return self.value[1]
@property
def num_phases(self) -> int:
"""
Get the number of `SinglePhaseKind` that make up this `PhaseCode`. This is the same as the length of the `single_phases` in all cases except for NONE,
where the number of phases will be 0.
"""
return len(self.value[1]) if self != PhaseCode.NONE else 0
@property
def without_neutral(self) -> 'PhaseCode':
"""Get the equivalent `PhaseCode` without the `N` phase."""
if SinglePhaseKind.N not in self:
return self
else:
return phase_code_from_single_phases({it for it in self.single_phases if it != SinglePhaseKind.N})
def __iter__(self):
return PhaseCodeIter(self.single_phases)
def __contains__(self, item):
return item in self.single_phases
class PhaseCodeIter:
"""
An iterator that can be used to iterator over the `SinglePhaseKind` of a `PhaseCode`
"""
def __init__(self, single_phases: List[SinglePhaseKind]):
self._index = -1
self._single_phases = single_phases
def __iter__(self):
return self
def __next__(self):
self._index += 1
if self._index < len(self._single_phases):
return self._single_phases[self._index]
raise StopIteration
def phase_code_from_single_phases(single_phases: Set[SinglePhaseKind]) -> PhaseCode:
"""Get the `PhaseCode` that is made up of the set of `SinglePhaseKind`, or `PhaseCode.NONE` if it is not valid."""
return _PHASE_CODE_BY_PHASES.get(frozenset(single_phases), PhaseCode.NONE)
_PHASE_CODE_VALUES = list(PhaseCode.__members__.values())
# The IDE is detecting `it` as a `SinglePhaseKind` rather than a `PhaseCode`
# noinspection PyUnresolvedReferences
_PHASE_CODE_BY_PHASES = {frozenset(it.single_phases): it for it in PhaseCode} | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/phase_code.py | phase_code.py |
from __future__ import annotations
from typing import List, Optional, Generator, TYPE_CHECKING
from zepben.evolve.model.cim.iec61970.base.core.base_voltage import BaseVoltage
from zepben.evolve.model.cim.iec61970.base.core.equipment import Equipment
from zepben.evolve.util import get_by_mrid, require, ngen
if TYPE_CHECKING:
from zepben.evolve import Terminal
__all__ = ['ConductingEquipment']
class ConductingEquipment(Equipment):
"""
Abstract class, should only be used through subclasses.
The parts of the AC power system that are designed to carry current or that are conductively connected through
terminals.
ConductingEquipment are connected by `Terminal`'s which are in turn associated with
`ConnectivityNode`'s. Each `Terminal` is associated with
_exactly one_ `ConnectivityNode`, and through that `ConnectivityNode` can be linked with many other `Terminals` and `ConductingEquipment`.
"""
base_voltage: Optional[BaseVoltage] = None
"""
`BaseVoltage` of this `ConductingEquipment`. Use only when there is no voltage level container used and only one base voltage applies. For example, not
used for transformers.
"""
_terminals: List[Terminal] = []
def __init__(self, terminals: List[Terminal] = None, **kwargs):
super(ConductingEquipment, self).__init__(**kwargs)
if terminals:
for term in terminals:
if term.conducting_equipment is None:
term.conducting_equipment = self
self.add_terminal(term)
# pylint: disable=unused-argument
def get_base_voltage(self, terminal: Terminal = None):
"""
Get the `BaseVoltage` of this `ConductingEquipment`.
Note `terminal` is not used here, but this method can be overridden in child classes (e.g PowerTransformer).
`terminal` The `Terminal` to get the voltage at.
Returns thee BaseVoltage of this `ConductingEquipment` at `terminal`
"""
return self.base_voltage
# pylint: enable=unused-argument
@property
def base_voltage_value(self) -> int:
"""
:return: The value of the nominal voltage for the base voltage if there is one, otherwise 0.
"""
return self.base_voltage.nominal_voltage if self.base_voltage and self.base_voltage.nominal_voltage else 0
@property
def terminals(self) -> Generator[Terminal, None, None]:
"""
`ConductingEquipment` have `Terminal`s that may be connected to other `ConductingEquipment`
`Terminal`s via `ConnectivityNode`s.
"""
return ngen(self._terminals)
def num_terminals(self):
"""
Get the number of `Terminal`s for this `ConductingEquipment`.
"""
return len(self._terminals)
def get_terminal_by_mrid(self, mrid: str) -> Terminal:
"""
Get the `Terminal` for this `ConductingEquipment` 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._terminals, mrid)
def get_terminal_by_sn(self, sequence_number: int):
"""
Get the `Terminal` on this `ConductingEquipment` by its `sequence_number`.
`sequence_number` The `sequence_number` of the `Terminal` in relation to this `ConductingEquipment`.
Returns The `Terminal` on this `ConductingEquipment` with sequence number `sequence_number`
Raises IndexError if no `Terminal` was found with sequence_number `sequence_number`.
"""
for term in self._terminals:
if term.sequence_number == sequence_number:
return term
raise IndexError(f"No Terminal with sequence_number {sequence_number} was found in ConductingEquipment {str(self)}")
def __getitem__(self, item: int):
return self.get_terminal_by_sn(item)
def add_terminal(self, terminal: Terminal) -> ConductingEquipment:
"""
Associate `terminal` with this `ConductingEquipment`. If `terminal.sequence_number` == 0, the terminal will be assigned a sequence_number of
`self.num_terminals() + 1`.
`terminal` The `Terminal` to associate with this `ConductingEquipment`.
Returns A reference to this `ConductingEquipment` to allow fluent use.
Raises `ValueError` if another `Terminal` with the same `mrid` already exists for this `ConductingEquipment`.
"""
if self._validate_terminal(terminal):
return self
if terminal.sequence_number == 0:
terminal.sequence_number = self.num_terminals() + 1
self._terminals.append(terminal)
self._terminals.sort(key=lambda t: t.sequence_number)
return self
def remove_terminal(self, terminal: Terminal) -> ConductingEquipment:
"""
Disassociate `terminal` from this `ConductingEquipment`
`terminal` the `Terminal` to disassociate from this `ConductingEquipment`.
Returns A reference to this `ConductingEquipment` to allow fluent use.
Raises `ValueError` if `terminal` was not associated with this `ConductingEquipment`.
"""
self._terminals.remove(terminal)
return self
def clear_terminals(self) -> ConductingEquipment:
"""
Clear all terminals.
Returns A reference to this `ConductingEquipment` to allow fluent use.
"""
self._terminals.clear()
return self
def __repr__(self):
return (f"{super(ConductingEquipment, self).__repr__()}, in_service={self.in_service}, "
f"normally_in_service={self.normally_in_service}, location={self.location}"
)
def _validate_terminal(self, terminal: Terminal) -> bool:
"""
Validate a terminal against this `ConductingEquipment`'s `Terminal`s.
`terminal` The `Terminal` to validate.
Returns True if `Terminal`` is already associated with this `ConductingEquipment`, otherwise False.
Raises `ValueError` if `Terminal`s `conducting_equipment` is not this `ConductingEquipment`,
or if this `ConductingEquipment` has a different `Terminal` with the same mRID.
"""
if self._validate_reference(terminal, self.get_terminal_by_mrid, "A Terminal"):
return True
if self._validate_reference_by_sn(terminal.sequence_number, terminal, self.get_terminal_by_sn, "A Terminal"):
return True
if not terminal.conducting_equipment:
terminal.conducting_equipment = self
require(terminal.conducting_equipment is self,
lambda: f"Terminal {terminal} references another piece of conducting equipment {terminal.conducting_equipment}, expected {str(self)}.")
return False | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/conducting_equipment.py | conducting_equipment.py |
from __future__ import annotations
import logging
from abc import ABCMeta
from typing import Callable, Any, List, Generator, Optional
from dataclassy import dataclass
from zepben.evolve.model.cim.iec61970.base.core.name import Name
from zepben.evolve.util import require, CopyableUUID, nlen, ngen, safe_remove
__all__ = ["IdentifiedObject"]
logger = logging.getLogger(__name__)
@dataclass(slots=True)
class IdentifiedObject(object, metaclass=ABCMeta):
"""
Root class to provide common identification for all classes needing identification and naming attributes.
Everything should extend this class, however it's not mandated that every subclass must use all the fields
defined here.
All names of attributes of classes extending this class *must* directly reflect CIM properties if they have a direct
relation, however must be in snake case to keep the phases PEP compliant.
"""
mrid: str = CopyableUUID()
"""Master resource identifier issued by a model authority. The mRID is unique within an exchange context.
Global uniqueness is easily achieved by using a UUID, as specified in RFC 4122, for the mRID. The use of UUID is strongly recommended."""
name: str = ""
"""The name is any free human readable and possibly non unique text naming the object."""
description: str = ""
"""a free human readable text describing or naming the object. It may be non unique and may not correlate to a naming hierarchy."""
_names: Optional[List[Name]] = None
def __init__(self, names: Optional[List[Name]] = None, **kwargs):
super(IdentifiedObject, self).__init__(**kwargs)
if names:
for name in names:
self.add_name(name)
def __str__(self):
return f"{self.__class__.__name__}{{{'|'.join(a for a in (str(self.mrid), str(self.name)) if a)}}}"
@property
def names(self) -> Generator[Name, None, None]:
"""All names of this identified object. The returned collection is read only."""
return ngen(self._names)
def num_names(self) -> int:
"""Get the number of entries in the `Name` collection."""
return nlen(self._names)
def get_name(self, name_type: str, name: str) -> Optional[Name]:
"""
Find the `Name` with the matching `name_type` and `name`
:return: The matched Name or None
"""
if self._names:
for name_ in self._names:
if name_.type.name == name_type and name_.name == name:
return name_
return None
def add_name(self, name: Name) -> IdentifiedObject:
"""
Associate a `Name` with this `IdentifiedObject`
:param name: The `Name` to associate with this `IdentifiedObject`.
:return: A reference to this `IdentifiedObject` to allow fluent use.
:raise ValueError: If `name` references another `IdentifiedObject`, or another `Name` already exists with the matching `type` and `name`.
"""
if not name.identified_object:
name.identified_object = self
require(name.identified_object is self, lambda: f"Attempting to add a Name to {str(self)} that does not reference this identified object")
existing = self.get_name(name.type.name, name.name)
if existing:
if existing is name:
return self
else:
raise ValueError(f"Failed to add duplicate name {str(name)} to {str(self)}.")
self._names = list() if not self._names else self._names
self._names.append(name)
return self
def remove_name(self, name: Name) -> IdentifiedObject:
"""
Disassociate a `Name` from this `IdentifiedObject`.
:param name: The `Name` to disassociate from this `IdentifiedObject`.
:return: A reference to this `IdentifiedObject` to allow fluent use.
:raises ValueError: Iif `name` was not associated with this `IdentifiedObject`.
"""
self._names = safe_remove(self._names, name)
return self
def clear_names(self) -> IdentifiedObject:
"""
Clear all names.
:return: A reference to this `IdentifiedObject` to allow fluent use.
"""
self._names = None
return self
def _validate_reference(self, other: IdentifiedObject, getter: Callable[[str], IdentifiedObject], type_descr: str) -> bool:
"""
Validate whether a given reference exists to `other` using the provided getter function.
:param other: The object to look up with the getter using its mRID.
:param getter: A function that takes an mRID and returns an `IdentifiedObject`, and throws a `KeyError` if it couldn't be found.
:param type_descr: The type description to use for the lazily generated error message. Should be of the form "A[n] type(other)"
:return: True if `other` was retrieved with `getter` and was equivalent, False otherwise.
:raises ValueError: If the object retrieved from `getter` is not `other`.
"""
try:
get_result = getter(other.mrid)
require(get_result is other, lambda: f"{type_descr} with mRID {other.mrid} already exists in {str(self)}")
return True
except (KeyError, AttributeError):
return False
def _validate_reference_by_sn(self, field: Any, other: IdentifiedObject, getter: Callable[[Any], IdentifiedObject], type_descr: str,
field_name: str = "sequence_number") -> bool:
"""
Validate whether a given reference exists to `other` using the provided getter function called with `field`.
:param other: The object to look up with the getter using its mRID.
:param getter: A function that takes takes `field` and returns an `IdentifiedObject`, and throws an `IndexError` if it couldn't be found.
:param type_descr: The type description to use for the lazily generated error message. Should be of the form "A[n] type(other)"
:return: True if `other` was retrieved with `getter` and was equivalent, False otherwise.
:raises ValueError: If the object retrieved from `getter` is not `other`.
"""
try:
get_result = getter(field)
require(get_result is other, lambda: f"{type_descr} with {field_name} {field} already exists in {str(self)}")
return True
except IndexError:
return False | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/identified_object.py | identified_object.py |
from __future__ import annotations
from typing import Generator, List, TYPE_CHECKING
if TYPE_CHECKING:
from zepben.evolve import Terminal
from dataclassy import dataclass
from zepben.evolve.model.cim.iec61970.base.core.identified_object import IdentifiedObject
from zepben.evolve.util import get_by_mrid, ngen
__all__ = ["ConnectivityNode"]
@dataclass(slots=False)
class ConnectivityNode(IdentifiedObject):
"""
Connectivity nodes are points where terminals of AC conducting equipment are connected together with zero impedance.
"""
# noinspection PyDunderSlots
__slots__ = ["_terminals", "__weakref__"]
_terminals: List[Terminal] = []
def __init__(self, terminals: List[Terminal] = None, **kwargs):
super(ConnectivityNode, self).__init__(**kwargs)
if terminals:
for term in terminals:
self.add_terminal(term)
def __iter__(self):
return iter(self._terminals)
def num_terminals(self):
"""
Get the number of `Terminal`s for this `ConnectivityNode`.
"""
return len(self._terminals)
@property
def terminals(self) -> Generator[Terminal, None, None]:
"""
The `Terminal`s attached to this `ConnectivityNode`
"""
return ngen(self._terminals)
def get_terminal(self, mrid: str) -> Terminal:
"""
Get the `Terminal` for this `ConnectivityNode` 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._terminals, mrid)
def add_terminal(self, terminal: Terminal) -> ConnectivityNode:
"""
Associate a `terminal.Terminal` with this `ConnectivityNode`
`terminal` The `Terminal` to add. Will only add to this object if it is not already associated.
Returns A reference to this `ConnectivityNode` to allow fluent use.
Raises `ValueError` if another `Terminal` with the same `mrid` already exists for this `ConnectivityNode`.
"""
if self._validate_reference(terminal, self.get_terminal, "A Terminal"):
return self
self._terminals.append(terminal)
return self
def remove_terminal(self, terminal: Terminal) -> ConnectivityNode:
"""
Disassociate `terminal` from this `ConnectivityNode`.
`terminal` The `Terminal` to disassociate from this `ConnectivityNode`.
Returns A reference to this `ConnectivityNode` to allow fluent use.
Raises `ValueError` if `terminal` was not associated with this `ConnectivityNode`.
"""
self._terminals.remove(terminal)
return self
def clear_terminals(self) -> ConnectivityNode:
"""
Clear all terminals.
Returns A reference to this `ConnectivityNode` to allow fluent use.
"""
self._terminals.clear()
return self
def is_switched(self):
return self.get_switch() is not None
def get_switch(self):
for term in self._terminals:
try:
# All switches should implement is_open
_ = term.conducting_equipment.is_open()
return term.conducting_equipment
except AttributeError:
pass
return None | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/connectivity_node.py | connectivity_node.py |
from __future__ import annotations
from typing import Dict, List, Generator
from dataclassy import dataclass
from zepben.evolve.model.cim.iec61970.base.core.name import Name
__all__ = ["NameType"]
@dataclass(slots=True)
class NameType:
"""
Type of name. Possible values for attribute 'name' are implementation dependent but standard profiles may specify types. An enterprise may have multiple
IT systems each having its own local name for the same object, e.g. a planning system may have different names from an EMS. An object may also have
different names within the same IT system, e.g. localName as defined in CIM version 14. The definition from CIM14 is:
The localName is a human readable name of the object. It is a free text name local to a node in a naming hierarchy similar to a file directory structure.
A power system related naming hierarchy may be: Substation, VoltageLevel, Equipment etc. Children of the same parent in such a hierarchy have names that
typically are unique among them.
"""
name: str
"""Name of the name type."""
description: str = ""
"""Description of the name type."""
_names_index: Dict[str, Name] = dict()
_names_multi_index: Dict[str, List[Name]] = dict()
def __str__(self):
return f"NameType(name='{self.name}', description='{self.description}')"
@property
def names(self) -> Generator[Name, None, None]:
"""All names of this type."""
for names_ in self._names_multi_index.values():
for name in names_:
yield name
for name_ in self._names_index.values():
yield name_
def has_name(self, name: str):
"""Indicates if this :class:`NameType` contains `name`."""
return name in self._names_index or name in self._names_multi_index
def get_names(self, name) -> Generator[Name, None, None]:
"""Get all the :class:`Name` instances for the provided `name`.
:return: A `Generator` of `Name`
"""
try:
yield self._names_index[name]
except KeyError:
try:
for name_ in self._names_multi_index[name]:
yield name_
except KeyError:
pass
def get_or_add_name(self, name, identified_object):
"""
Gets a :class:`Name` for the given `name` and `identifiedObject` combination or adds a new :class:`Name`
to this :class:`NameType` with the combination and returns the new instance.
"""
if name in self._names_index:
existing = self._names_index[name]
if existing.identified_object == identified_object:
return existing
else:
# noinspection PyArgumentList
name_obj = Name(name, self, identified_object)
self._names_multi_index[name] = [existing, name_obj]
del self._names_index[name]
return name_obj
elif name in self._names_multi_index:
for n in self._names_multi_index[name]:
if n.identified_object == identified_object:
return n
# noinspection PyArgumentList
name_obj = Name(name, self, identified_object)
self._names_multi_index[name].append(name_obj)
return name_obj
else:
# noinspection PyArgumentList
name_obj = Name(name, self, identified_object)
self._names_index[name] = name_obj
return name_obj
def remove_name(self, name: Name):
"""
Removes the `name` from this name type.
:return: True if the name instance was successfully removed
"""
if name.type is not self:
return False
try:
del self._names_index[name.name]
return True
except KeyError:
try:
names = self._names_multi_index[name.name]
names.remove(name)
if not names:
del self._names_multi_index[name.name]
return True
except KeyError:
return False
def remove_names(self, name: str):
"""
Removes all :class:`Name` instances associated with name `name`.
:return: True if a matching name was removed.
"""
try:
del self._names_index[name]
return True
except KeyError:
try:
del self._names_multi_index[name]
return True
except KeyError:
return False
def clear_names(self) -> NameType:
self._names_index = dict()
self._names_multi_index = dict()
return self | zepben.evolve | /zepben.evolve-0.35.0b2-py3-none-any.whl/zepben/evolve/model/cim/iec61970/base/core/name_type.py | name_type.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.