cognite-neat 0.86.0__py3-none-any.whl → 0.87.0__py3-none-any.whl

cognite/neat/legacy/graph/stores/_rdf_to_graph.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 from rdflib import Graph, Namespace
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 
 
 def rdf_file_to_graph(
@@ -10,7 +10,7 @@ def rdf_file_to_graph(
     filepath: Path,
     base_prefix: str | None = None,
     base_namespace: Namespace | None = None,
-    prefixes: dict[str, Namespace] = PREFIXES,
+    prefixes: dict[str, Namespace] | None = None,
 ) -> Graph:
     """Created rdflib Graph instance loaded with RDF triples from file
 
@@ -18,13 +18,15 @@ def rdf_file_to_graph(
         filepath: Path to the RDF file
         base_prefix: base prefix for URIs. Defaults to None.
         base_namespace: base namespace for URIs . Defaults to None.
-        prefixes: Dictionary of prefixes to bind to graph. Defaults to PREFIXES.
+        prefixes: Dictionary of prefixes to bind to graph. Defaults to internal set of prefixes.
         graph: Graph instance to load RDF triples into. Defaults to None.
 
     Returns:
         Graph instance loaded with RDF triples from file
     """
 
+    prefixes = prefixes if prefixes else get_default_prefixes()
+
     if filepath.is_file():
         graph.parse(filepath, publicID=base_namespace)
     else:

cognite/neat/legacy/graph/transformations/query_generator/sparql.py

@@ -6,7 +6,7 @@ from typing import cast
 from rdflib import Graph, Namespace
 from rdflib.term import URIRef
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 from cognite.neat.legacy.rules.analysis import get_classes_with_properties
 from cognite.neat.legacy.rules.models._base import Triple
 from cognite.neat.legacy.rules.models.rdfpath import (
@@ -24,7 +24,7 @@ from cognite.neat.legacy.rules.models.rules import Rules
 from cognite.neat.utils.utils import remove_namespace_from_uri
 
 
-def _generate_prefix_header(prefixes: dict[str, Namespace] = PREFIXES) -> str:
+def _generate_prefix_header(prefixes: dict[str, Namespace] | None = None) -> str:
     """Generate prefix header which is added to SPARQL query and allows for shorten query statements
 
     Parameters
@@ -37,11 +37,15 @@ def _generate_prefix_header(prefixes: dict[str, Namespace] = PREFIXES) -> str:
     str
         Prefix header
     """
+    prefixes = prefixes if prefixes else get_default_prefixes()
     return "".join(f"PREFIX {key}:<{value}>\n" for key, value in prefixes.items())
 
 
 def _get_predicate_id(
-    graph: Graph, subject_type_id: str, object_type_id: str, prefixes: dict[str, Namespace] = PREFIXES
+    graph: Graph,
+    subject_type_id: str,
+    object_type_id: str,
+    prefixes: dict[str, Namespace] | None = None,
 ) -> URIRef:
     """Returns predicate (aka property) URI (i.e., ID) that connects subject and object
 
@@ -61,6 +65,7 @@ def _get_predicate_id(
     URIRef
         ID of predicate (aka property) connecting subject and object
     """
+    prefixes = prefixes if prefixes else get_default_prefixes()
     query = """
 
         SELECT ?predicateTypeID
@@ -122,11 +127,21 @@ def _get_hop_triples(graph, path: Hop, prefixes) -> list[Triple]:
     if previous_step.property:
         triples.extend(
             [
-                Triple(subject=f"?{previous_step.class_.suffix}ID", predicate="a", object=previous_step.class_.id),
                 Triple(
-                    subject=f"?{previous_step.class_.suffix}ID", predicate=previous_step.property.id, object="?object"
+                    subject=f"?{previous_step.class_.suffix}ID",
+                    predicate="a",
+                    object=previous_step.class_.id,
+                ),
+                Triple(
+                    subject=f"?{previous_step.class_.suffix}ID",
+                    predicate=previous_step.property.id,
+                    object="?object",
+                ),
+                Triple(
+                    subject="?predicate",
+                    predicate="a",
+                    object=previous_step.property.id,
                 ),
-                Triple(subject="?predicate", predicate="a", object=previous_step.property.id),
             ]
         )
     else:
@@ -139,7 +154,7 @@ def _get_hop_triples(graph, path: Hop, prefixes) -> list[Triple]:
     return triples
 
 
-def _get_path_triples(graph: Graph, traversal: Traversal, prefixes: dict[str, Namespace] = PREFIXES) -> list[Triple]:
+def _get_path_triples(graph: Graph, traversal: Traversal, prefixes: dict[str, Namespace] | None = None) -> list[Triple]:
     """Creates triples subject-predicate-object from declarative graph traversal path
 
     Parameters
@@ -227,7 +242,9 @@ def _generate_all_references_query_statement(
 
 
 def _generate_single_property_query_statement(
-    subject: str, predicate: str, query_template: str = SINGLE_PROPERTY_SPARQL_QUERY_TEMPLATE
+    subject: str,
+    predicate: str,
+    query_template: str = SINGLE_PROPERTY_SPARQL_QUERY_TEMPLATE,
 ) -> str:
     query_insertions = "\n".join([f"\t\t?subject a {subject} .", f"\t\t?subject {predicate} ?object ."])
 
@@ -257,7 +274,7 @@ def _generate_hop_query_statement(triples: list[Triple], query_template: str = B
 def build_sparql_query(
     graph: Graph,
     traversal_path: str | Traversal,
-    prefixes: dict[str, Namespace] = PREFIXES,
+    prefixes: dict[str, Namespace] | None = None,
     insert_prefixes: bool = False,
 ) -> str:
     """Builds SPARQL query based on declarative traversal path
@@ -276,7 +293,7 @@ def build_sparql_query(
     str
         SPARQL query
     """
-
+    prefixes = prefixes if prefixes else get_default_prefixes()
     traversal = parse_traversal(traversal_path) if isinstance(traversal_path, str) else traversal_path
     triples = _get_path_triples(graph, traversal, prefixes)
 
@@ -297,7 +314,10 @@ def build_sparql_query(
     for prefix, URI in prefixes.items():
         query = query.replace(URI, f"{prefix}:")
 
-    return query.replace("insertPrefixes\n\n", _generate_prefix_header(prefixes) if insert_prefixes else "")
+    return query.replace(
+        "insertPrefixes\n\n",
+        _generate_prefix_header(prefixes) if insert_prefixes else "",
+    )
 
 
 def compress_uri(uri: URIRef, prefixes: dict) -> str:
@@ -420,7 +440,8 @@ def _add_filter(class_instances, query_template):
     if class_instances:
         class_instances_formatted = [f"<{instance}>" for instance in class_instances]
         query_template = query_template.replace(
-            "insert_filter", f"\n\nFILTER (?subject IN ({', '.join(class_instances_formatted)}))"
+            "insert_filter",
+            f"\n\nFILTER (?subject IN ({', '.join(class_instances_formatted)}))",
         )
     else:
         query_template = query_template.replace("insert_filter", "")
@@ -439,7 +460,10 @@ def _triples2sparql_statement(triples: list[Triple]):
 
 
 def _to_construct_triples(
-    graph: Graph, class_: str, transformation_rules: Rules, properties_optional: bool = True
+    graph: Graph,
+    class_: str,
+    transformation_rules: Rules,
+    properties_optional: bool = True,
 ) -> tuple[list[Triple], list[Triple]]:
     """Converts class definition to CONSTRUCT triples which are used to generate CONSTRUCT query
 
@@ -485,7 +509,10 @@ def _to_construct_triples(
         # by binding them to certain property
         if isinstance(traversal, AllReferences):
             graph_pattern_triple = Triple(
-                subject="BIND(?subject", predicate="AS", object=f"{graph_template_triple.object})", optional=False
+                subject="BIND(?subject",
+                predicate="AS",
+                object=f"{graph_template_triple.object})",
+                optional=False,
             )
 
         elif isinstance(traversal, SingleProperty):
@@ -510,7 +537,13 @@ def _to_construct_triples(
 
     # add first triple for graph pattern stating type of object
     patterns.insert(
-        0, Triple(subject="?subject", predicate="a", object=_most_occurring_element(class_ids), optional=False)
+        0,
+        Triple(
+            subject="?subject",
+            predicate="a",
+            object=_most_occurring_element(class_ids),
+            optional=False,
+        ),
     )
 
     return templates, patterns

cognite/neat/legacy/rules/importers/_graph2rules.py

@@ -10,11 +10,15 @@ from typing import cast
 import pandas as pd
 from rdflib import Graph, Literal, Namespace, URIRef
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 from cognite.neat.legacy.rules import exceptions
 from cognite.neat.legacy.rules.exporters._rules2rules import to_dms_name
 from cognite.neat.legacy.rules.models.tables import Tables
-from cognite.neat.utils.utils import get_namespace, remove_namespace_from_uri, uri_to_short_form
+from cognite.neat.utils.utils import (
+    get_namespace,
+    remove_namespace_from_uri,
+    uri_to_short_form,
+)
 
 from ._base import BaseImporter
 
@@ -74,11 +78,26 @@ def _create_default_properties_parsing_config() -> dict[str, tuple[str, ...]]:
 
 def _create_default_classes_parsing_config() -> dict[str, tuple[str, ...]]:
     # TODO: these are to be read from Class pydantic model
-    return {"header": ("Class", "Description", "Parent Class", "Source", "Source Entity Name", "Match Type", "Comment")}
+    return {
+        "header": (
+            "Class",
+            "Description",
+            "Parent Class",
+            "Source",
+            "Source Entity Name",
+            "Match Type",
+            "Comment",
+        )
+    }
 
 
 def _parse_prefixes_df(prefixes: dict[str, Namespace]) -> pd.DataFrame:
-    return pd.DataFrame.from_dict({"Prefix": list(prefixes.keys()), "URI": [str(uri) for uri in prefixes.values()]})
+    return pd.DataFrame.from_dict(
+        {
+            "Prefix": list(prefixes.keys()),
+            "URI": [str(uri) for uri in prefixes.values()],
+        }
+    )
 
 
 def _parse_metadata_df() -> pd.DataFrame:
@@ -169,7 +188,7 @@ def _graph_to_data_model_dict(graph: Graph, max_number_of_instance: int = -1) ->
     """
     data_model: dict[str, dict] = {}
 
-    prefixes: dict[str, Namespace] = PREFIXES
+    prefixes: dict[str, Namespace] = get_default_prefixes()
 
     for class_ in _get_class_ids(graph):
         _add_uri_namespace_to_prefixes(class_, prefixes)
@@ -183,10 +202,18 @@ def _graph_to_data_model_dict(graph: Graph, max_number_of_instance: int = -1) ->
             )
             class_name = f"{class_name}_{len(data_model)+1}"
 
-        data_model[class_name] = {"properties": {}, "uri": uri_to_short_form(class_, prefixes)}
+        data_model[class_name] = {
+            "properties": {},
+            "uri": uri_to_short_form(class_, prefixes),
+        }
 
         for instance in _get_class_instance_ids(graph, class_, max_number_of_instance):
-            for property_, occurrence, data_type, object_type in _define_instance_properties(graph, instance):
+            for (
+                property_,
+                occurrence,
+                data_type,
+                object_type,
+            ) in _define_instance_properties(graph, instance):
                 property_name = remove_namespace_from_uri(property_)
                 _add_uri_namespace_to_prefixes(property_, prefixes)
 

cognite/neat/legacy/rules/models/raw_rules.py

@@ -9,11 +9,17 @@ from pydantic import field_validator
 from pydantic_core import ErrorDetails, ValidationError
 from rdflib import Namespace
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 from cognite.neat.exceptions import wrangle_warnings
 
 # rules model and model components:
-from cognite.neat.legacy.rules.models.rules import Class, Metadata, Property, RuleModel, Rules
+from cognite.neat.legacy.rules.models.rules import (
+    Class,
+    Metadata,
+    Property,
+    RuleModel,
+    Rules,
+)
 from cognite.neat.legacy.rules.models.tables import Tables
 
 # importers:
@@ -36,7 +42,7 @@ class RawRules(RuleModel):
         classes: Classes defined in the data model
         properties: Class properties defined in the data model with accompanying transformation rules
                     to transform data from source to target representation
-        prefixes: Prefixes used in the data model. Defaults to PREFIXES
+        prefixes: Prefixes used in the data model. Defaults to internal set of prefixes
         instances: Instances defined in the data model. Defaults to None
     """
 
@@ -242,7 +248,9 @@ def _raw_tables_to_rules_dict(raw_tables: RawRules, validators_to_skip: set | No
         "metadata": _metadata_table2dict(raw_tables.Metadata),
         "classes": _classes_table2dict(raw_tables.Classes),
         "properties": _properties_table2dict(raw_tables.Properties),
-        "prefixes": PREFIXES if raw_tables.Prefixes.empty else _prefixes_table2dict(raw_tables.Prefixes),
+        "prefixes": (
+            get_default_prefixes() if raw_tables.Prefixes.empty else _prefixes_table2dict(raw_tables.Prefixes)
+        ),
     }
 
     rules_dict["instances"] = (
@@ -272,11 +280,15 @@ def _metadata_table2dict(meta_df: pd.DataFrame) -> dict[str, Any]:
     return metadata_dict
 
 
-def _classes_table2dict(classes_df: pd.DataFrame) -> dict[Any | None, dict[Hashable, Any]]:
+def _classes_table2dict(
+    classes_df: pd.DataFrame,
+) -> dict[Any | None, dict[Hashable, Any]]:
     return {class_.get("Class"): class_ for class_ in classes_df.to_dict(orient="records")}
 
 
-def _properties_table2dict(properties_df: pd.DataFrame) -> dict[str, dict[Hashable, Any]]:
+def _properties_table2dict(
+    properties_df: pd.DataFrame,
+) -> dict[str, dict[Hashable, Any]]:
     return {f"row {i+3}": property_ for i, property_ in enumerate(properties_df.to_dict(orient="records"))}
 
 

cognite/neat/legacy/rules/models/rules.py

@@ -29,7 +29,7 @@ from pydantic import (
 from pydantic.fields import FieldInfo
 from rdflib import XSD, Literal, Namespace, URIRef
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 from cognite.neat.legacy.rules import exceptions
 from cognite.neat.legacy.rules.models._base import (
     ENTITY_ID_REGEX_COMPILED,
@@ -49,7 +49,10 @@ from cognite.neat.legacy.rules.models.rdfpath import (
     Traversal,
     parse_rule,
 )
-from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS, ValueType
+from cognite.neat.legacy.rules.models.value_types import (
+    XSD_VALUE_TYPE_MAPPINGS,
+    ValueType,
+)
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -82,7 +85,10 @@ def replace_nan_floats_with_default(values: dict, model_fields: dict[str, FieldI
             output[field_name] = model_fields[field_name].default
         else:
             # field_name may be an alias
-            source_name = next((name for name, field in model_fields.items() if field.alias == field_name), None)
+            source_name = next(
+                (name for name, field in model_fields.items() if field.alias == field_name),
+                None,
+            )
             if source_name:
                 output[field_name] = model_fields[source_name].default
             else:
@@ -335,7 +341,9 @@ class Metadata(RuleModel):
         if value.endswith("#") or value.endswith("/"):
             return value
         warnings.warn(
-            exceptions.NamespaceEndingFixed(value).message, category=exceptions.NamespaceEndingFixed, stacklevel=2
+            exceptions.NamespaceEndingFixed(value).message,
+            category=exceptions.NamespaceEndingFixed,
+            stacklevel=2,
         )
         return Namespace(f"{value}#")
 
@@ -444,10 +452,14 @@ class Resource(RuleModel):
         default=None,
     )
     source_entity_name: str | None = Field(
-        alias="Source Entity Name", description="Closest entity in source, e.g. Substation", default=None
+        alias="Source Entity Name",
+        description="Closest entity in source, e.g. Substation",
+        default=None,
     )
     match_type: str | None = Field(
-        alias="Match Type", description="Type of match between source entity and one being defined", default=None
+        alias="Match Type",
+        description="Type of match between source entity and one being defined",
+        default=None,
     )
     comment: str | None = Field(alias="Comment", description="Comment about mapping", default=None)
 
@@ -656,7 +668,9 @@ class Property(Resource):
     # Specialization of cdf_resource_type to allow definition of both
     # Asset and Relationship at the same time
     cdf_resource_type: list[str] = Field(
-        alias="Resource Type", default_factory=list, description="This is typically 'Asset' or 'Relationship'"
+        alias="Resource Type",
+        default_factory=list,
+        description="This is typically 'Asset' or 'Relationship'",
     )
 
     # Transformation rule (domain to solution)
@@ -701,7 +715,11 @@ class Property(Resource):
             return ValueType.from_string(entity_string=value, type_=EntityTypes.object_value_type, mapping=None)
         else:
             return ValueType(
-                prefix="undefined", suffix=value, name=value, type_=EntityTypes.object_value_type, mapping=None
+                prefix="undefined",
+                suffix=value,
+                name=value,
+                type_=EntityTypes.object_value_type,
+                mapping=None,
             )
         #     return ValueType(
 
@@ -820,7 +838,9 @@ class Property(Resource):
     def set_relationship_label(self):
         if self.label is None:
             warnings.warn(
-                exceptions.MissingLabel(self.property_id).message, category=exceptions.MissingLabel, stacklevel=2
+                exceptions.MissingLabel(self.property_id).message,
+                category=exceptions.MissingLabel,
+                stacklevel=2,
             )
             self.label = self.property_id
         return self
@@ -899,7 +919,7 @@ class Prefixes(RuleModel):
         prefixes: Dict of prefixes
     """
 
-    prefixes: dict[str, Namespace] = PREFIXES
+    prefixes: dict[str, Namespace] = get_default_prefixes()
 
 
 class Instance(RuleModel):
@@ -1019,7 +1039,7 @@ class Rules(RuleModel):
         classes: Classes defined in the data model
         properties: Class properties defined in the data model with accompanying transformation rules
                     to transform data from source to target representation
-        prefixes: Prefixes used in the data model. Defaults to PREFIXES
+        prefixes: Prefixes used in the data model. Defaults to internal prefixes
         instances: Instances defined in the data model. Defaults to None
         validators_to_skip: List of validators to skip. Defaults to []
 
@@ -1035,7 +1055,7 @@ class Rules(RuleModel):
     metadata: Metadata
     classes: Classes
     properties: Properties
-    prefixes: dict[str, Namespace] = PREFIXES.copy()
+    prefixes: dict[str, Namespace] = get_default_prefixes()
     instances: list[Instance] = Field(default_factory=list)
 
     @property

cognite/neat/rules/_shared.py

@@ -1,5 +1,10 @@
 from typing import TypeAlias
 
-from cognite.neat.rules.models import AssetRules, DMSRules, DomainRules, InformationRules
+from cognite.neat.rules.models import (
+    AssetRules,
+    DMSRules,
+    DomainRules,
+    InformationRules,
+)
 
 Rules: TypeAlias = DomainRules | InformationRules | DMSRules | AssetRules

cognite/neat/rules/analysis/__init__.py

@@ -1,6 +1,6 @@
-from ._information_rules import (
-    AssetArchitectRulesAnalysis,
-    InformationArchitectRulesAnalysis,
+from ._asset import AssetAnalysis
+from ._information import (
+    InformationAnalysis,
 )
 
-__all__ = ["InformationArchitectRulesAnalysis", "AssetArchitectRulesAnalysis"]
+__all__ = ["InformationAnalysis", "AssetAnalysis"]

cognite/neat/rules/analysis/_asset.py

@@ -0,0 +1,128 @@
+import warnings
+from typing import cast
+
+from cognite.neat.rules.models import AssetRules
+from cognite.neat.rules.models._rdfpath import RDFPath
+from cognite.neat.rules.models.asset import AssetClass, AssetProperty
+from cognite.neat.rules.models.entities import (
+    AssetEntity,
+    ClassEntity,
+    EntityTypes,
+    ReferenceEntity,
+    RelationshipEntity,
+)
+
+from ._base import BaseAnalysis
+
+
+class AssetAnalysis(BaseAnalysis[AssetRules, AssetClass, AssetProperty, ClassEntity, str]):
+    """Assumes analysis over only the complete schema"""
+
+    def _get_reference(self, class_or_property: AssetClass | AssetProperty) -> ReferenceEntity | None:
+        return class_or_property.reference if isinstance(class_or_property.reference, ReferenceEntity) else None
+
+    def _get_cls_entity(self, class_: AssetClass | AssetProperty) -> ClassEntity:
+        return class_.class_
+
+    def _get_prop_entity(self, property_: AssetProperty) -> str:
+        return property_.property_
+
+    def _get_cls_parents(self, class_: AssetClass) -> list[ClassEntity] | None:
+        return list(class_.parent or []) or None
+
+    def _get_reference_rules(self) -> AssetRules | None:
+        return self.rules.reference
+
+    @classmethod
+    def _set_cls_entity(cls, property_: AssetProperty, class_: ClassEntity) -> None:
+        property_.class_ = class_
+
+    def _get_object(self, property_: AssetProperty) -> ClassEntity | None:
+        return property_.value_type if isinstance(property_.value_type, ClassEntity) else None
+
+    def _get_max_occurrence(self, property_: AssetProperty) -> int | float | None:
+        return property_.max_count
+
+    def _get_classes(self) -> list[AssetClass]:
+        return list(self.rules.classes)
+
+    def _get_properties(self) -> list[AssetProperty]:
+        return list(self.rules.properties)
+
+    def subset_rules(self, desired_classes: set[ClassEntity]) -> AssetRules:
+        raise NotImplementedError("Method not implemented")
+
+    def class_property_pairs(
+        self,
+        only_rdfpath: bool = False,
+        consider_inheritance: bool = False,
+        implementation_type: EntityTypes = EntityTypes.asset,
+    ) -> dict[ClassEntity, dict[str, AssetProperty]]:
+        class_property_pairs = {}
+
+        T_implementation = AssetEntity if implementation_type == EntityTypes.asset else RelationshipEntity
+
+        for class_, properties in self.classes_with_properties(consider_inheritance).items():
+            processed_properties = {}
+            for property_ in properties:
+                if property_.property_ in processed_properties:
+                    # TODO: use appropriate Warning class from _exceptions.py
+                    # if missing make one !
+                    warnings.warn(
+                        f"Property {property_.property_} for {class_} has been defined more than once!"
+                        " Only the first definition will be considered, skipping the rest..",
+                        stacklevel=2,
+                    )
+                    continue
+
+                if (
+                    property_.implementation
+                    and any(isinstance(implementation, T_implementation) for implementation in property_.implementation)
+                    and (not only_rdfpath or (only_rdfpath and isinstance(property_.transformation, RDFPath)))
+                ):
+                    implementation = [
+                        implementation
+                        for implementation in property_.implementation
+                        if isinstance(implementation, T_implementation)
+                    ]
+
+                    processed_properties[property_.property_] = property_.model_copy(
+                        deep=True, update={"implementation": implementation}
+                    )
+
+            if processed_properties:
+                class_property_pairs[class_] = processed_properties
+
+        return class_property_pairs
+
+    def asset_definition(
+        self, only_rdfpath: bool = False, consider_inheritance: bool = False
+    ) -> dict[ClassEntity, dict[str, AssetProperty]]:
+        return self.class_property_pairs(
+            consider_inheritance=consider_inheritance,
+            only_rdfpath=only_rdfpath,
+            implementation_type=EntityTypes.asset,
+        )
+
+    def relationship_definition(
+        self, only_rdfpath: bool = False, consider_inheritance: bool = False
+    ) -> dict[ClassEntity, dict[str, AssetProperty]]:
+        return self.class_property_pairs(
+            consider_inheritance=consider_inheritance,
+            only_rdfpath=only_rdfpath,
+            implementation_type=EntityTypes.relationship,
+        )
+
+    def define_property_renaming_config(self, class_: ClassEntity) -> dict[str, str]:
+        property_renaming_configuration = {}
+
+        if asset_definition := self.asset_definition().get(class_, None):
+            for property_, transformation in asset_definition.items():
+                asset_property = cast(list[AssetEntity], transformation.implementation)[0].property_
+
+                if asset_property != "metadata":
+                    property_renaming_configuration[property_] = str(asset_property)
+                else:
+                    property_renaming_configuration[property_] = f"{asset_property}.{property_}"
+
+        return property_renaming_configuration