bnop 0.2.0__tar.gz

bnop-0.2.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 BORO Solutions Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bnop-0.2.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: bnop
+Version: 0.2.0
+Summary: a common top level ontology for bCLEARer based on BORO.
+Author: Mesbah Khan
+Author-email: khanm@ontoledgy.io
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+# BNOP
+
+BNOP is a reference library containing the code for the BNOP Domain (BORO Native Objects (Python)).
+
+**This project is currently closed, but may be sporadically updated by the BORO Development Team in the future.**
+
+## Execution
+
+* This code is a library, so not to be run on its own.
+
+## Usage Examples
+
+For examples see usages in the following projects:
+
+* https://github.com/boro-alpha/bclearer_boson_1_1.git
+
+## Documentation
+
+#### Background
+
+The Agile Manifesto prefers “working software over comprehensive documentation”. Robert C. Martin, one of the original authors of the Agile Manifesto, is also the author of the book Clean Code.
+
+In this book, he makes a strong case for code being self-documenting: saying things such as "always try to explain yourself in code."
+
+He suggests that the goal of every programmer should be to write code so clean and expressive that code comments are unnecessary.
+
+When a programmer writes a comment, it will usually mean that they have failed to write code that was expressive enough. At the extreme, he suggests, maybe a little rhetorically, that "comments are always failures".
+
+#### The BORO documentation policy
+
+To aim to write code so clean and expressive that code comments are unnecessary.
+
+## Contributing
+
+This package doesn't allow external contributors.
+
+## Liability and Warranty
+
+This code is provided as-is and without warranty.
+
+Under no circumstances will the developers be liable for any incidental, consequential, or indirect damages including but not limited to lost or damaged data, revenue loss, economic loss, or commercial loss arising out of the use of this code.
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)
+
+## Acknowledgements
+
+This work was developed initially by BORO Solutions (https://www.borosolutions.net/) and has been updated as part of the Information Management Framework to support the [National Digital Twin programme](https://www.cdbb.cam.ac.uk/what-we-do/national-digital-twin-programme), and funded by [Department for Business, Energy & Industrial Strategy](https://www.gov.uk/government/organisations/department-for-business-energy-and-industrial-strategy) through the Centre for the Protection of National Infrastructure.
+

bnop-0.2.0/README.md

@@ -0,0 +1,49 @@
+# BNOP
+
+BNOP is a reference library containing the code for the BNOP Domain (BORO Native Objects (Python)).
+
+**This project is currently closed, but may be sporadically updated by the BORO Development Team in the future.**
+
+## Execution
+
+* This code is a library, so not to be run on its own.
+
+## Usage Examples
+
+For examples see usages in the following projects:
+
+* https://github.com/boro-alpha/bclearer_boson_1_1.git
+
+## Documentation
+
+#### Background
+
+The Agile Manifesto prefers “working software over comprehensive documentation”. Robert C. Martin, one of the original authors of the Agile Manifesto, is also the author of the book Clean Code.
+
+In this book, he makes a strong case for code being self-documenting: saying things such as "always try to explain yourself in code."
+
+He suggests that the goal of every programmer should be to write code so clean and expressive that code comments are unnecessary.
+
+When a programmer writes a comment, it will usually mean that they have failed to write code that was expressive enough. At the extreme, he suggests, maybe a little rhetorically, that "comments are always failures".
+
+#### The BORO documentation policy
+
+To aim to write code so clean and expressive that code comments are unnecessary.
+
+## Contributing
+
+This package doesn't allow external contributors.
+
+## Liability and Warranty
+
+This code is provided as-is and without warranty.
+
+Under no circumstances will the developers be liable for any incidental, consequential, or indirect damages including but not limited to lost or damaged data, revenue loss, economic loss, or commercial loss arising out of the use of this code.
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)
+
+## Acknowledgements
+
+This work was developed initially by BORO Solutions (https://www.borosolutions.net/) and has been updated as part of the Information Management Framework to support the [National Digital Twin programme](https://www.cdbb.cam.ac.uk/what-we-do/national-digital-twin-programme), and funded by [Department for Business, Energy & Industrial Strategy](https://www.gov.uk/government/organisations/department-for-business-energy-and-industrial-strategy) through the Centre for the Protection of National Infrastructure.

bnop-0.2.0/bnop/bnop_facades.py

@@ -0,0 +1,307 @@
+from bclearer_core.ckids.boro_object_ckids import (
+    BoroObjectCkIds,
+)
+from bclearer_core.ckids.place_number_type_ckids import (
+    PlaceNumberTypeCkIds,
+)
+from bclearer_orchestration_services.identification_services.uuid_service.uuid_helpers.uuid_factory import (
+    create_new_uuid,
+)
+from bnop.core.factories.bnop_element_factories import (
+    BnopElementFactories,
+)
+from bnop.core.factories.bnop_name_factories import (
+    BnopNameFactories,
+)
+from bnop.core.factories.bnop_object_factories import (
+    BnopObjectFactories,
+)
+from bnop.core.factories.bnop_placeabletype_factories import (
+    BnopPlaceableTypeFactories,
+)
+from bnop.core.factories.bnop_tuple_factories import (
+    BnopTupleFactories,
+)
+from bnop.core.factories.bnop_type_factories import (
+    BnopTypeFactories,
+)
+from bnop.core.factories.bnop_type_place_factories import (
+    BnopTypePlaceFactories,
+)
+from bnop.core.object_model.objects.bnop_names import (
+    BnopNames,
+)
+from bnop.core.object_model.objects.bnop_objects import (
+    BnopObjects,
+)
+from bnop.core.object_model.objects.places.bnop_placed_objects_dictionaries import (
+    BnopPlacedObjectsDictionaries,
+)
+from bnop.core.object_model.objects.places.bnop_placed_types_dictionaries import (
+    BnopPlacedTypesDictionaries,
+)
+from bnop.migrations.bnop_to_xml_migration.bnop_xml_write_orchestrator import (
+    orchestrate_xml_write,
+)
+
+
+class BnopFacades:
+
+    @staticmethod
+    def write_bnop_object_to_xml(
+        xml_file_path: str,
+    ):
+        orchestrate_xml_write(
+            xml_file_path=xml_file_path
+        )
+
+    @staticmethod
+    def create_new_bnop_type(
+        owning_repository_uuid,
+    ):
+        bnop_type = (
+            BnopTypeFactories.create(
+                create_new_uuid(),
+                owning_repository_uuid,
+            )
+        )
+
+        return bnop_type
+
+    @staticmethod
+    def create_bnop_object(
+        object_uuid,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        bnop_object = BnopObjectFactories.create(
+            object_uuid,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        return bnop_object
+
+    @staticmethod
+    def create_bnop_type(
+        type_uuid,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        bnop_type = BnopTypeFactories.create(
+            type_uuid,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        return bnop_type
+
+    @staticmethod
+    def create_new_bnop_element(
+        owning_repository_uuid,
+    ):
+        bnop_element = (
+            BnopElementFactories.create(
+                create_new_uuid(),
+                owning_repository_uuid,
+            )
+        )
+
+        return bnop_element
+
+    @staticmethod
+    def create_bnop_element(
+        element_uuid,
+        owning_repository_uuid,
+    ):
+        bnop_element = (
+            BnopElementFactories.create(
+                element_uuid,
+                owning_repository_uuid,
+            )
+        )
+
+        return bnop_element
+
+    @staticmethod
+    def create_new_bnop_name(
+        exemplar_representation,
+        owning_repository_uuid,
+    ):
+        bnop_name = (
+            BnopNameFactories.create(
+                create_new_uuid(),
+                exemplar_representation,
+                owning_repository_uuid,
+            )
+        )
+
+        return bnop_name
+
+    @staticmethod
+    def create_bnop_name(
+        name_uuid,
+        exemplar_representation,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        bnop_name = BnopNameFactories.create(
+            name_uuid,
+            exemplar_representation,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        return bnop_name
+
+    @staticmethod
+    def create_new_bnop_tuple_from_two_placed_objects(
+        placed1_object,
+        placed2_object,
+        immutable_minor_composition_couple_type_boro_object_ckid,
+        owning_repository_uuid,
+    ):
+        tuple_placed_objects_dictionary = (
+            BnopPlacedObjectsDictionaries()
+        )
+
+        tuple_placed_objects_dictionary.add_tuple_placed_object_to_dictionary(
+            PlaceNumberTypeCkIds.PlaceNumberOnes,
+            placed1_object,
+        )
+
+        tuple_placed_objects_dictionary.add_tuple_placed_object_to_dictionary(
+            PlaceNumberTypeCkIds.PlaceNumberTwos,
+            placed2_object,
+        )
+
+        bnop_tuple = BnopTupleFactories.create(
+            create_new_uuid(),
+            tuple_placed_objects_dictionary,
+            immutable_minor_composition_couple_type_boro_object_ckid,
+            owning_repository_uuid,
+        )
+
+        return bnop_tuple
+
+    @staticmethod
+    def create_bnop_tuple_from_two_placed_objects(
+        tuple_uuid,
+        placed1_object: BnopObjects,
+        placed2_object: BnopObjects,
+        immutable_minor_composition_couple_type_boro_object_ckid: BoroObjectCkIds,
+        owning_repository_uuid,
+    ):
+        tuple_placed_objects_dictionary = (
+            BnopPlacedObjectsDictionaries()
+        )
+
+        tuple_placed_objects_dictionary.add_tuple_placed_object_to_dictionary(
+            PlaceNumberTypeCkIds.PlaceNumberOnes,
+            placed1_object,
+        )
+
+        tuple_placed_objects_dictionary.add_tuple_placed_object_to_dictionary(
+            PlaceNumberTypeCkIds.PlaceNumberTwos,
+            placed2_object,
+        )
+
+        bnop_tuple = BnopTupleFactories.create(
+            tuple_uuid,
+            tuple_placed_objects_dictionary,
+            immutable_minor_composition_couple_type_boro_object_ckid,
+            owning_repository_uuid,
+        )
+
+        if (
+            immutable_minor_composition_couple_type_boro_object_ckid
+            == BoroObjectCkIds.SuperSubTypes
+        ):
+            placed2_object.supertypes.add(
+                placed1_object
+            )
+
+            placed1_object.subtypes.add(
+                placed2_object
+            )
+
+        if (
+            immutable_minor_composition_couple_type_boro_object_ckid
+            == BoroObjectCkIds.NamedBy
+        ):
+            placed1_object.is_named_bys.add(
+                placed2_object
+            )
+
+            placed2_object.names.add(
+                placed1_object
+            )
+
+        if (
+            immutable_minor_composition_couple_type_boro_object_ckid
+            == BoroObjectCkIds.TypesInstances
+        ):
+            placed2_object.types.add(
+                placed1_object
+            )
+
+            placed1_object.instances.add(
+                placed2_object
+            )
+
+            if (
+                type(placed2_object)
+                is BnopNames
+            ):
+                placed2_object.naming_spaces.add(
+                    placed1_object
+                )
+
+        return bnop_tuple
+
+    @staticmethod
+    def create_bnop_placeabletype(
+        placeabletype_uuid,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        placeable_type_placed_type_dictionary = (
+            BnopPlacedTypesDictionaries()
+        )
+
+        bnop_placeabletype = BnopPlaceableTypeFactories.create(
+            placeabletype_uuid,
+            placeable_type_placed_type_dictionary,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        return bnop_placeabletype
+
+    @staticmethod
+    def create_bnop_type_place(
+        type_place_uuid,
+        placing_type,
+        placed_type,
+        type_place_ckid,
+        owning_repository_uuid,
+    ):
+        bnop_type_place = BnopTypePlaceFactories.create(
+            type_place_uuid,
+            placing_type,
+            placed_type,
+            type_place_ckid,
+            owning_repository_uuid,
+        )
+
+        return bnop_type_place
+
+    @staticmethod
+    def __add_placed_type_to_placeabletype(
+        placed_type,
+        place_number_ckid,
+        placeable_type,
+    ):
+        placeable_type.placeable_type_placed_types_dictionary[
+            place_number_ckid
+        ] = placed_type

bnop-0.2.0/bnop/bnop_io/shelve_bnop.py

@@ -0,0 +1,42 @@
+import shelve
+
+from bnop.core.object_model.objects.bnop_objects import (
+    BnopObjects,
+)
+
+
+def write_bnop(full_filename: str):
+    bnop_shelf = shelve.open(
+        full_filename
+    )
+
+    bnop_shelf.clear_xml_model_branches()
+
+    for (
+        key,
+        value,
+    ) in (
+        BnopObjects.registry_keyed_on_uuid.items()
+    ):
+        bnop_shelf[key] = value
+
+    bnop_shelf.close()
+
+
+def read_bnop(full_filename: str):
+    bnop_shelf = shelve.open(
+        full_filename
+    )
+
+    for (
+        key,
+        value,
+    ) in bnop_shelf.items():
+        print(
+            "Key: "
+            + key
+            + " - Type: "
+            + str(type(value).__name__)
+        )
+
+    bnop_shelf.close()

bnop-0.2.0/bnop/core/factories/bnop_element_factories.py

@@ -0,0 +1,16 @@
+from bnop.core.object_model.objects.bnop_elements import (
+    BnopElements,
+)
+
+
+class BnopElementFactories:
+
+    @staticmethod
+    def create(
+        uuid, owning_repository_uuid
+    ):
+        bnop_element = BnopElements(
+            uuid, owning_repository_uuid
+        )
+
+        return bnop_element

bnop-0.2.0/bnop/core/factories/bnop_name_factories.py

@@ -0,0 +1,22 @@
+from bnop.core.object_model.objects.bnop_names import (
+    BnopNames,
+)
+
+
+class BnopNameFactories:
+
+    @staticmethod
+    def create(
+        uuid,
+        exemplar_representation,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        bnop_name = BnopNames(
+            uuid,
+            exemplar_representation,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        return bnop_name

bnop-0.2.0/bnop/core/factories/bnop_object_factories.py

@@ -0,0 +1,29 @@
+from bclearer_core.ckids.boro_object_ckids import (
+    BoroObjectCkIds,
+)
+from bnop.core.object_model.objects.bnop_objects import (
+    BnopObjects,
+)
+
+
+class BnopObjectFactories:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def create(
+        uuid,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        bnop_object = BnopObjects(
+            uuid,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        bnop_object.add_to_registry_keyed_on_ckid_type(
+            BoroObjectCkIds.Objects
+        )
+
+        return bnop_object

bnop-0.2.0/bnop/core/factories/bnop_placeabletype_factories.py

@@ -0,0 +1,22 @@
+from bnop.core.object_model.objects.bnop_placeable_types import (
+    BnopPlaceableTypes,
+)
+
+
+class BnopPlaceableTypeFactories:
+
+    @staticmethod
+    def create(
+        uuid,
+        placeable_type_placed_types_dictionary,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        bnop_placeabletype = BnopPlaceableTypes(
+            uuid,
+            placeable_type_placed_types_dictionary,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        return bnop_placeabletype

bnop-0.2.0/bnop/core/factories/bnop_tuple_factories.py

@@ -0,0 +1,25 @@
+from bclearer_core.ckids.boro_object_ckids import (
+    BoroObjectCkIds,
+)
+from bnop.core.object_model.objects.bnop_tuples import (
+    BnopTuples,
+)
+
+
+class BnopTupleFactories:
+
+    @staticmethod
+    def create(
+        uuid,
+        tuple_placed_objects_dictionary,
+        immutable_minor_composition_couple_type_boro_object_ckid: BoroObjectCkIds,
+        owning_repository_uuid,
+    ):
+        bnop_tuple = BnopTuples(
+            uuid,
+            tuple_placed_objects_dictionary,
+            immutable_minor_composition_couple_type_boro_object_ckid,
+            owning_repository_uuid,
+        )
+
+        return bnop_tuple

bnop-0.2.0/bnop/core/factories/bnop_type_factories.py

@@ -0,0 +1,26 @@
+from bnop.core.factories.bnop_object_factories import (
+    BnopObjectFactories,
+)
+from bnop.core.object_model.objects.bnop_types import (
+    BnopTypes,
+)
+
+
+class BnopTypeFactories(
+    BnopObjectFactories
+):
+    pass
+
+    @staticmethod
+    def create(
+        uuid,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        bnop_type = BnopTypes(
+            uuid,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        return bnop_type

bnop-0.2.0/bnop/core/factories/bnop_type_place_factories.py

@@ -0,0 +1,26 @@
+from bnop.core.object_model.objects.bnop_type_places import (
+    BnopTypePlaces,
+)
+
+
+class BnopTypePlaceFactories:
+
+    @staticmethod
+    def create(
+        uuid,
+        placing_type,
+        placed_type,
+        type_place_ckid,
+        owning_repository_uuid,
+    ):
+        bnop_type_place = (
+            BnopTypePlaces(
+                uuid,
+                placing_type,
+                placed_type,
+                type_place_ckid,
+                owning_repository_uuid,
+            )
+        )
+
+        return bnop_type_place

bnop-0.2.0/bnop/core/object_model/bnop_repositories.py

@@ -0,0 +1,4 @@
+class BnopRepositories(object):
+
+    def __init__(self, uuid):
+        self.uuid = uuid