zepben.ewb 1.0.0b1__py3-none-any.whl

zepben/ewb/database/sqlite/customer/customer_database_reader.py

@@ -0,0 +1,44 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerDatabaseReader"]
+
+from sqlite3 import Connection
+
+from zepben.ewb.database.sqlite.common.base_database_reader import BaseDatabaseReader
+from zepben.ewb.database.sqlite.common.metadata_collection_reader import MetadataCollectionReader
+from zepben.ewb.database.sqlite.customer.customer_database_tables import CustomerDatabaseTables
+from zepben.ewb.database.sqlite.customer.customer_service_reader import CustomerServiceReader
+from zepben.ewb.database.sqlite.tables.table_version import TableVersion
+from zepben.ewb.services.customer.customers import CustomerService
+
+class CustomerDatabaseReader(BaseDatabaseReader):
+    """
+    A class for reading the `CustomerService` objects and `MetadataCollection` from our customer database.
+
+    :param connection: The connection to the database.
+    :param service: The `CustomerService` to populate with CIM objects from the database.
+    :param database_description: The description of the database for logging (e.g. filename).
+    """
+
+    def __init__(
+        self,
+        connection: Connection,
+        service: CustomerService,
+        database_description: str,
+        tables: CustomerDatabaseTables = None,
+        metadata_reader: MetadataCollectionReader = None,
+        service_reader: CustomerServiceReader = None,
+        table_version: TableVersion = None
+    ):
+        tables = tables if tables is not None else CustomerDatabaseTables()
+        super().__init__(
+            connection,
+            metadata_reader if metadata_reader is not None else MetadataCollectionReader(service, tables, connection),
+            service_reader if service_reader is not None else CustomerServiceReader(service, tables, connection),
+            service,
+            database_description,
+            table_version if table_version is not None else TableVersion()
+        )

zepben/ewb/database/sqlite/customer/customer_database_tables.py

@@ -0,0 +1,37 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerDatabaseTables"]
+
+from typing import Generator
+
+from zepben.ewb.database.sqlite.common.base_database_tables import BaseDatabaseTables
+from zepben.ewb.database.sqlite.tables.associations.table_customer_agreements_pricing_structures import *
+from zepben.ewb.database.sqlite.tables.associations.table_pricing_structures_tariffs import *
+from zepben.ewb.database.sqlite.tables.iec61968.common.table_organisations import *
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customer_agreements import *
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customers import *
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_pricing_structures import *
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_tariffs import *
+from zepben.ewb.database.sqlite.tables.sqlite_table import *
+
+
+class CustomerDatabaseTables(BaseDatabaseTables):
+    """
+    The collection of tables for our customer databases.
+    """
+
+    @property
+    def _included_tables(self) -> Generator[SqliteTable, None, None]:
+        for table in super()._included_tables:
+            yield table
+
+        yield TableCustomerAgreements()
+        yield TableCustomerAgreementsPricingStructures()
+        yield TableCustomers()
+        yield TableOrganisations()
+        yield TablePricingStructures()
+        yield TablePricingStructuresTariffs()
+        yield TableTariffs()

zepben/ewb/database/sqlite/customer/customer_database_writer.py

@@ -0,0 +1,45 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerDatabaseWriter"]
+
+import sqlite3
+from pathlib import Path
+from sqlite3 import Connection
+from typing import Callable, Union
+
+from zepben.ewb.database.sqlite.common.base_database_writer import BaseDatabaseWriter
+from zepben.ewb.database.sqlite.common.metadata_collection_writer import MetadataCollectionWriter
+from zepben.ewb.database.sqlite.customer.customer_database_tables import CustomerDatabaseTables
+from zepben.ewb.database.sqlite.customer.customer_service_writer import CustomerServiceWriter
+from zepben.ewb.services.customer.customers import CustomerService
+
+
+class CustomerDatabaseWriter(BaseDatabaseWriter):
+    """
+    A class for writing the `CustomerService` objects and `MetadataCollection` to our customer database.
+
+    :param database_file: the filename of the database to write.
+    :param service: The `CustomerService` to save to the database.
+    """
+
+    def __init__(
+        self,
+        database_file: Union[Path, str],
+        service: CustomerService,
+        database_tables: CustomerDatabaseTables = None,
+        create_metadata_writer: Callable[[], MetadataCollectionWriter] = None,
+        create_service_writer: Callable[[], CustomerServiceWriter] = None,
+        get_connection: Callable[[str], Connection] = None
+    ):
+        database_tables = database_tables if database_tables is not None else CustomerDatabaseTables()
+
+        super().__init__(
+            database_file,
+            database_tables,
+            create_metadata_writer if create_metadata_writer is not None else lambda: MetadataCollectionWriter(service, database_tables),
+            create_service_writer if create_service_writer is not None else lambda: CustomerServiceWriter(service, database_tables),
+            get_connection if get_connection is not None else sqlite3.connect
+        )

zepben/ewb/database/sqlite/customer/customer_service_reader.py

@@ -0,0 +1,57 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerServiceReader"]
+
+from sqlite3 import Connection
+
+from zepben.ewb.database.sqlite.common.base_service_reader import BaseServiceReader
+from zepben.ewb.database.sqlite.customer.customer_cim_reader import CustomerCimReader
+from zepben.ewb.database.sqlite.customer.customer_database_tables import CustomerDatabaseTables
+from zepben.ewb.database.sqlite.tables.associations.table_customer_agreements_pricing_structures import TableCustomerAgreementsPricingStructures
+from zepben.ewb.database.sqlite.tables.associations.table_pricing_structures_tariffs import TablePricingStructuresTariffs
+from zepben.ewb.database.sqlite.tables.iec61968.common.table_organisations import TableOrganisations
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customer_agreements import TableCustomerAgreements
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_customers import TableCustomers
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_pricing_structures import TablePricingStructures
+from zepben.ewb.database.sqlite.tables.iec61968.customers.table_tariffs import TableTariffs
+from zepben.ewb.services.customer.customers import CustomerService
+
+
+class CustomerServiceReader(BaseServiceReader):
+    """
+    A class for reading a [CustomerService] from the database.
+
+    @param service The [CustomerService] to populate from the database.
+    @param database_tables The tables available in the database.
+    @param connection A connection to the database.
+
+    @property reader The [CustomerCimReader] used to load the objects from the database.
+    """
+
+    def __init__(
+        self,
+        service: CustomerService,
+        database_tables: CustomerDatabaseTables,
+        connection: Connection,
+        reader: CustomerCimReader = None
+    ):
+        reader = reader if reader is not None else CustomerCimReader(service)
+        super().__init__(database_tables, connection, reader)
+
+        # This is not strictly necessary, it is just to update the type of the reader. It could be done with a generic
+        # on the base class which looks like it works, but that actually silently breaks code insight and completion
+        self._reader = reader
+
+    def _do_load(self) -> bool:
+        return all([
+            self._load_each(TableOrganisations, self._reader.load_organisations),
+            self._load_each(TableCustomers, self._reader.load_customers),
+            self._load_each(TableCustomerAgreements, self._reader.load_customer_agreements),
+            self._load_each(TablePricingStructures, self._reader.load_pricing_structures),
+            self._load_each(TableTariffs, self._reader.load_tariffs),
+            self._load_each(TableCustomerAgreementsPricingStructures, self._reader.load_customer_agreements_pricing_structures),
+            self._load_each(TablePricingStructuresTariffs, self._reader.load_pricing_structures_tariffs)
+        ])

zepben/ewb/database/sqlite/customer/customer_service_writer.py

@@ -0,0 +1,47 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CustomerServiceWriter"]
+
+from zepben.ewb.database.sqlite.common.base_service_writer import BaseServiceWriter
+from zepben.ewb.database.sqlite.customer.customer_cim_writer import CustomerCimWriter
+from zepben.ewb.database.sqlite.customer.customer_database_tables import CustomerDatabaseTables
+from zepben.ewb.model.cim.iec61968.common.organisation import Organisation
+from zepben.ewb.model.cim.iec61968.customers.customer import Customer
+from zepben.ewb.model.cim.iec61968.customers.customer_agreement import CustomerAgreement
+from zepben.ewb.model.cim.iec61968.customers.pricing_structure import PricingStructure
+from zepben.ewb.model.cim.iec61968.customers.tariff import Tariff
+from zepben.ewb.services.customer.customers import CustomerService
+
+
+class CustomerServiceWriter(BaseServiceWriter):
+    """
+    A class for writing a `CustomerService` into the database.
+
+    :param service: The `CustomerService` to save to the database.
+    :param database_tables: The `CustomerDatabaseTables` to add to the database.
+    """
+
+    def __init__(
+        self,
+        service: CustomerService,
+        database_tables: CustomerDatabaseTables,
+        writer: CustomerCimWriter = None
+    ):
+        writer = writer if writer is not None else CustomerCimWriter(database_tables)
+        super().__init__(service, writer)
+
+        # This is not strictly necessary, it is just to update the type of the writer. It could be done with a generic
+        # on the base class which looks like it works, but that actually silently breaks code insight and completion
+        self._writer = writer
+
+    def _do_save(self) -> bool:
+        return all([
+            self._save_each_object(Organisation, self._writer.save_organisation),
+            self._save_each_object(Customer, self._writer.save_customer),
+            self._save_each_object(CustomerAgreement, self._writer.save_customer_agreement),
+            self._save_each_object(PricingStructure, self._writer.save_pricing_structure),
+            self._save_each_object(Tariff, self._writer.save_tariff)
+        ])

zepben/ewb/database/sqlite/diagram/__init__.py

@@ -0,0 +1,4 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.

zepben/ewb/database/sqlite/diagram/diagram_cim_reader.py

@@ -0,0 +1,105 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["DiagramCimReader"]
+
+from typing import Callable
+
+from zepben.ewb.database.sqlite.common.base_cim_reader import BaseCimReader
+from zepben.ewb.database.sqlite.extensions.result_set import ResultSet
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_object_points import TableDiagramObjectPoints
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_objects import TableDiagramObjects
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagrams import TableDiagrams
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram import Diagram
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram_object import DiagramObject
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram_object_point import DiagramObjectPoint
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram_style import DiagramStyle
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.orientation_kind import OrientationKind
+from zepben.ewb.services.diagram.diagrams import DiagramService
+
+
+class DiagramCimReader(BaseCimReader):
+    """
+    A class for reading the `DiagramService` tables from the database.
+
+    :param service: The `DiagramService` to populate from the database.
+    """
+
+    def __init__(self, service: DiagramService):
+        super().__init__(service)
+
+    ################################
+    # IEC61970 Base Diagram Layout #
+    ################################
+
+    def load_diagrams(self, table: TableDiagrams, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `Diagram` and populate its fields from `TableDiagrams`.
+
+        :param table: The database table to read the `Diagram` fields from.
+        :param result_set: The record in the database table containing the fields for this `Diagram`.
+        :param set_identifier: A callback to register the mRID of this `Diagram` for logging purposes.
+
+        :return: True if the `Diagram` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        diagram = Diagram(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
+
+        diagram.diagram_style = DiagramStyle[result_set.get_string(table.diagram_style.query_index)]
+        diagram.orientation_kind = OrientationKind[result_set.get_string(table.orientation_kind.query_index)]
+
+        return self._load_identified_object(diagram, table, result_set) and self._add_or_throw(diagram)
+
+    def load_diagram_objects(self, table: TableDiagramObjects, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `DiagramObject` and populate its fields from `TableDiagramObjects`.
+
+        :param table: The database table to read the `DiagramObject` fields from.
+        :param result_set: The record in the database table containing the fields for this `DiagramObject`.
+        :param set_identifier: A callback to register the mRID of this `DiagramObject` for logging purposes.
+
+        :return: True if the `DiagramObject` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        diagram_object = DiagramObject(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
+
+        diagram_object.diagram = self._ensure_get(
+            result_set.get_string(table.diagram_mrid.query_index, on_none=None),
+            Diagram
+        )
+        if diagram_object.diagram is not None:
+            diagram_object.diagram.add_diagram_object(diagram_object)
+
+        diagram_object.identified_object_mrid = result_set.get_string(table.identified_object_mrid.query_index, on_none=None)
+        diagram_object.style = result_set.get_string(table.style.query_index, on_none=None)
+        diagram_object.rotation = result_set.get_float(table.rotation.query_index)
+
+        return self._load_identified_object(diagram_object, table, result_set) and self._add_or_throw(diagram_object)
+
+    def load_diagram_object_points(self, table: TableDiagramObjectPoints, result_set: ResultSet, set_identifier: Callable[[str], str]) -> bool:
+        """
+        Create a `DiagramObjectPoint` and populate its fields from `TableDiagramObjectPoints`.
+
+        :param table: The database table to read the `DiagramObjectPoint` fields from.
+        :param result_set: The record in the database table containing the fields for this `DiagramObjectPoint`.
+        :param set_identifier: A callback to register the mRID of this `DiagramObjectPoint` for logging purposes.
+
+        :return: True if the `DiagramObjectPoint` was successfully read from the database and added to the service.
+        :raises SqlException: For any errors encountered reading from the database.
+        """
+        diagram_object_mrid = set_identifier(result_set.get_string(table.diagram_object_mrid.query_index))
+        sequence_number = result_set.get_int(table.sequence_number.query_index)
+
+        set_identifier(f"{diagram_object_mrid}-point{sequence_number}")
+
+        self._service.get(diagram_object_mrid, DiagramObject).insert_point(
+            DiagramObjectPoint(
+                result_set.get_float(table.x_position.query_index),
+                result_set.get_float(table.y_position.query_index)
+            ),
+            sequence_number
+        )
+
+        return True

zepben/ewb/database/sqlite/diagram/diagram_cim_writer.py

@@ -0,0 +1,81 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["DiagramCimWriter"]
+
+from zepben.ewb.database.sqlite.common.base_cim_writer import BaseCimWriter
+from zepben.ewb.database.sqlite.diagram.diagram_database_tables import DiagramDatabaseTables
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_object_points import TableDiagramObjectPoints
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_objects import TableDiagramObjects
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagrams import TableDiagrams
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram import Diagram
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram_object import DiagramObject
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram_object_point import DiagramObjectPoint
+
+
+class DiagramCimWriter(BaseCimWriter):
+    """
+    A class for writing the `DiagramService` tables to the database.
+
+    :param database_tables: The tables available in the database.
+    """
+
+    def __init__(self, database_tables: DiagramDatabaseTables):
+        super().__init__(database_tables)
+
+    ################################
+    # IEC61970 Base Diagram Layout #
+    ################################
+
+    def save_diagram(self, diagram: Diagram) -> bool:
+        """
+        Save the `Diagram` fields to `TableDiagrams`.
+
+        :param diagram: The `Diagram` instance to write to the database.
+
+        :return: True if the `Diagram` was successfully written to the database, otherwise false.
+        :raises SqlException: For any errors encountered writing to the database.
+        """
+        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:
+        """
+        Save the `DiagramObject` fields to `TableDiagramObjects`.
+
+        :param diagram_object: The `DiagramObject` instance to write to the database.
+
+        :return: True if the `DiagramObject` was successfully written to the database, otherwise false.
+        :raises SqlException: For any errors encountered writing to the database.
+        """
+        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 = all([status, 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 all([status, 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, "diagram object point")

zepben/ewb/database/sqlite/diagram/diagram_database_reader.py

@@ -0,0 +1,45 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["DiagramDatabaseReader"]
+
+from sqlite3 import Connection
+
+from zepben.ewb.database.sqlite.common.base_database_reader import BaseDatabaseReader
+from zepben.ewb.database.sqlite.common.metadata_collection_reader import MetadataCollectionReader
+from zepben.ewb.database.sqlite.diagram.diagram_database_tables import DiagramDatabaseTables
+from zepben.ewb.database.sqlite.diagram.diagram_service_reader import DiagramServiceReader
+from zepben.ewb.database.sqlite.tables.table_version import TableVersion
+from zepben.ewb.services.diagram.diagrams import DiagramService
+
+
+class DiagramDatabaseReader(BaseDatabaseReader):
+    """
+    A class for reading the `DiagramService` objects and `MetadataCollection` from our diagram database.
+
+    :param connection: The connection to the database.
+    :param service: The `DiagramService` to populate with CIM objects from the database.
+    :param database_description: The description of the database for logging (e.g. filename).
+    """
+
+    def __init__(
+        self,
+        connection: Connection,
+        service: DiagramService,
+        database_description: str,
+        tables: DiagramDatabaseTables = None,
+        metadata_reader: MetadataCollectionReader = None,
+        service_reader: DiagramServiceReader = None,
+        table_version: TableVersion = None
+    ):
+        tables = tables if tables is not None else DiagramDatabaseTables()
+        super().__init__(
+            connection,
+            metadata_reader if metadata_reader is not None else MetadataCollectionReader(service, tables, connection),
+            service_reader if service_reader is not None else DiagramServiceReader(service, tables, connection),
+            service,
+            database_description,
+            table_version if table_version is not None else TableVersion()
+        )

zepben/ewb/database/sqlite/diagram/diagram_database_tables.py

@@ -0,0 +1,29 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["DiagramDatabaseTables"]
+
+from typing import Generator
+
+from zepben.ewb.database.sqlite.common.base_database_tables import BaseDatabaseTables
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_object_points import *
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_objects import *
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagrams import *
+from zepben.ewb.database.sqlite.tables.sqlite_table import *
+
+
+class DiagramDatabaseTables(BaseDatabaseTables):
+    """
+    The collection of tables for our customer databases.
+    """
+
+    @property
+    def _included_tables(self) -> Generator[SqliteTable, None, None]:
+        for table in super()._included_tables:
+            yield table
+
+        yield TableDiagramObjectPoints()
+        yield TableDiagramObjects()
+        yield TableDiagrams()

zepben/ewb/database/sqlite/diagram/diagram_database_writer.py

@@ -0,0 +1,44 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["DiagramDatabaseWriter"]
+
+import sqlite3
+from pathlib import Path
+from sqlite3 import Connection
+from typing import Callable, Union
+
+from zepben.ewb.database.sqlite.common.base_database_writer import BaseDatabaseWriter
+from zepben.ewb.database.sqlite.common.metadata_collection_writer import MetadataCollectionWriter
+from zepben.ewb.database.sqlite.diagram.diagram_database_tables import DiagramDatabaseTables
+from zepben.ewb.database.sqlite.diagram.diagram_service_writer import DiagramServiceWriter
+from zepben.ewb.services.diagram.diagrams import DiagramService
+
+
+class DiagramDatabaseWriter(BaseDatabaseWriter):
+    """
+    A class for writing the `DiagramService` objects and `MetadataCollection` to our diagram database.
+
+    :param database_file: the filename of the database to write.
+    :param service: The `DiagramService` to save to the database.
+    """
+
+    def __init__(
+        self,
+        database_file: Union[Path, str],
+        service: DiagramService,
+        database_tables: DiagramDatabaseTables = None,
+        create_metadata_writer: Callable[[], MetadataCollectionWriter] = None,
+        create_service_writer: Callable[[], DiagramServiceWriter] = None,
+        get_connection: Callable[[str], Connection] = None
+    ):
+        database_tables = database_tables if database_tables is not None else DiagramDatabaseTables()
+        super().__init__(
+            database_file,
+            database_tables,
+            create_metadata_writer if create_metadata_writer is not None else lambda: MetadataCollectionWriter(service, database_tables),
+            create_service_writer if create_service_writer is not None else lambda: DiagramServiceWriter(service, database_tables),
+            get_connection if get_connection is not None else sqlite3.connect
+        )

zepben/ewb/database/sqlite/diagram/diagram_service_reader.py

@@ -0,0 +1,49 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["DiagramServiceReader"]
+
+from sqlite3 import Connection
+
+from zepben.ewb.database.sqlite.common.base_service_reader import BaseServiceReader
+from zepben.ewb.database.sqlite.diagram.diagram_cim_reader import DiagramCimReader
+from zepben.ewb.database.sqlite.diagram.diagram_database_tables import DiagramDatabaseTables
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_object_points import TableDiagramObjectPoints
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagram_objects import TableDiagramObjects
+from zepben.ewb.database.sqlite.tables.iec61970.base.diagramlayout.table_diagrams import TableDiagrams
+from zepben.ewb.services.diagram.diagrams import DiagramService
+
+
+class DiagramServiceReader(BaseServiceReader):
+    """
+    A class for reading a `DiagramService` from the database.
+
+    :param service: The `DiagramService` to populate from the database.
+    :param database_tables: The tables available in the database.
+    :param connection: A connection to the database.
+
+    :param reader: The `DiagramCimReader` used to load the objects from the database.
+    """
+
+    def __init__(
+        self,
+        service: DiagramService,
+        database_tables: DiagramDatabaseTables,
+        connection: Connection,
+        reader: DiagramCimReader = None
+    ):
+        reader = reader if reader is not None else DiagramCimReader(service)
+        super().__init__(database_tables, connection, reader)
+
+        # This is not strictly necessary, it is just to update the type of the reader. It could be done with a generic
+        # on the base class which looks like it works, but that actually silently breaks code insight and completion
+        self._reader = reader
+
+    def _do_load(self) -> bool:
+        return all([
+            self._load_each(TableDiagrams, self._reader.load_diagrams),
+            self._load_each(TableDiagramObjects, self._reader.load_diagram_objects),
+            self._load_each(TableDiagramObjectPoints, self._reader.load_diagram_object_points)
+        ])

zepben/ewb/database/sqlite/diagram/diagram_service_writer.py

@@ -0,0 +1,41 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["DiagramServiceWriter"]
+
+from zepben.ewb.database.sqlite.common.base_service_writer import BaseServiceWriter
+from zepben.ewb.database.sqlite.diagram.diagram_cim_writer import DiagramCimWriter
+from zepben.ewb.database.sqlite.diagram.diagram_database_tables import DiagramDatabaseTables
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram import Diagram
+from zepben.ewb.model.cim.iec61970.base.diagramlayout.diagram_object import DiagramObject
+from zepben.ewb.services.diagram.diagrams import DiagramService
+
+
+class DiagramServiceWriter(BaseServiceWriter):
+    """
+    A class for writing a `DiagramService` into the database.
+
+    :param service: The `DiagramService` to save to the database.
+    :param database_tables: The `DiagramDatabaseTables` to add to the database.
+    """
+
+    def __init__(
+        self,
+        service: DiagramService,
+        database_tables: DiagramDatabaseTables,
+        writer: DiagramCimWriter = None
+    ):
+        writer = writer if writer is not None else DiagramCimWriter(database_tables)
+        super().__init__(service, writer)
+
+        # This is not strictly necessary, it is just to update the type of the writer. It could be done with a generic
+        # on the base class which looks like it works, but that actually silently breaks code insight and completion
+        self._writer = writer
+
+    def _do_save(self) -> bool:
+        return all([
+            self._save_each_object(DiagramObject, self._writer.save_diagram_object),
+            self._save_each_object(Diagram, self._writer.save_diagram)
+        ])

zepben/ewb/database/sqlite/extensions/__init__.py

@@ -0,0 +1,4 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.