bnop 0.2.0__py3-none-any.whl

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/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/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/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/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/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/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/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/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/core/object_model/bnop_repositories.py

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

bnop/core/object_model/objects/bnop_elements.py

@@ -0,0 +1,26 @@
+from bclearer_core.ckids.boro_object_ckids import (
+    BoroObjectCkIds,
+)
+from bnop.core.object_model.objects.bnop_objects import (
+    BnopObjects,
+)
+
+
+class BnopElements(BnopObjects):
+
+    def __init__(
+        self,
+        uuid,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        BnopObjects.__init__(
+            self,
+            uuid,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        self.add_to_registry_keyed_on_ckid_type(
+            BoroObjectCkIds.Elements
+        )

bnop/core/object_model/objects/bnop_names.py

@@ -0,0 +1,29 @@
+from bclearer_core.ckids.boro_object_ckids import (
+    BoroObjectCkIds,
+)
+from bnop.core.object_model.objects.bnop_representations import (
+    BnopRepresentations,
+)
+
+
+class BnopNames(BnopRepresentations):
+    def __init__(
+        self,
+        uuid,
+        exemplar_representation,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        BnopRepresentations.__init__(
+            self,
+            uuid,
+            exemplar_representation,
+            owning_repository_uuid,
+            presentation_name=presentation_name,
+        )
+
+        self.naming_spaces = set()
+
+        self.add_to_registry_keyed_on_ckid_type(
+            BoroObjectCkIds.Names
+        )

bnop/core/object_model/objects/bnop_objects.py

@@ -0,0 +1,86 @@
+from bclearer_core.ckids.boro_object_ckids import (
+    BoroObjectCkIds,
+)
+
+
+class BnopObjects(object):
+    registry_keyed_on_uuid = {}
+
+    registry_keyed_on_ckid_type = {}
+
+    matched_objects = []
+
+    def __init__(
+        self,
+        uuid,
+        owning_repository_uuid,
+        presentation_name=str(),
+    ):
+        self.uuid = uuid
+
+        self.registry_keyed_on_uuid.update(
+            {self.uuid: self}
+        )
+
+        self.owning_repository_uuid = (
+            owning_repository_uuid
+        )
+
+        self.is_named_bys = set()
+
+        self.names = set()
+
+        self.types = set()
+
+        self.instances = set()
+
+        self.supertypes = set()
+
+        self.subtypes = set()
+
+        self.uml_name = (
+            presentation_name
+        )
+
+        self.naming_spaces = set()
+
+    def add_to_registry_keyed_on_ckid_type(
+        self,
+        boro_object_ck_id: BoroObjectCkIds,
+    ):
+
+        if (
+            boro_object_ck_id
+            in self.registry_keyed_on_ckid_type
+        ):
+            ckid_typed_objects = self.registry_keyed_on_ckid_type[
+                boro_object_ck_id
+            ]
+        else:
+            ckid_typed_objects = set()
+
+            self.registry_keyed_on_ckid_type.update(
+                {
+                    boro_object_ck_id: ckid_typed_objects
+                }
+            )
+
+        ckid_typed_objects.add(self)
+
+    @staticmethod
+    def import_bnop_object(bnop_object):
+        BnopObjects.registry_keyed_on_uuid.update(
+            {
+                bnop_object.uuid: bnop_object
+            }
+        )
+
+        return bnop_object
+
+    @staticmethod
+    def add_to_matched_objects(
+        bnop_object,
+    ):
+        BnopObjects.matched_objects.append(
+            bnop_object.uuid
+        )