cognite-neat 0.121.1__py3-none-any.whl → 0.122.0__py3-none-any.whl

cognite/neat/core/_data_model/importers/_rdf/{_imf2rules.py → _imf2data_model.py}

@@ -1,28 +1,28 @@
 """This module performs importing of various formats to one of serializations for which
-there are loaders to TransformationRules pydantic class."""
+there are loaders to data model pydantic class."""
 
 from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
 from cognite.neat.core._data_model.importers._rdf._shared import (
-    parse_classes,
+    parse_concepts,
     parse_properties,
 )
 
 CLASSES_QUERY = """
-    SELECT ?class_ ?name ?description ?implements
+    SELECT ?concept ?name ?description ?implements
     WHERE {{
         VALUES ?type {{ imf:BlockType imf:TerminalType imf:AttributeType }}
-        ?class_ a ?type .
+        ?concept a ?type .
 
-        OPTIONAL {{?class_ rdfs:subClassOf ?parent }}.
-        OPTIONAL {{?class_ rdfs:label|skos:prefLabel ?name }}.
-        OPTIONAL {{?class_ rdfs:comment|skos:definition ?description}}.
+        OPTIONAL {{?concept rdfs:subClassOf ?parent }}.
+        OPTIONAL {{?concept rdfs:label|skos:prefLabel ?name }}.
+        OPTIONAL {{?concept rdfs:comment|skos:definition ?description}}.
 
 
         # Add imf:Attribute as parent class when no parent is found
         BIND(IF(!bound(?parent) && ?type = imf:AttributeType, imf:Attribute, ?parent) AS ?implements)
 
         # FILTERS
-        FILTER (!isBlank(?class_))
+        FILTER (!isBlank(?concept))
         FILTER (!bound(?implements) || !isBlank(?implements))
 
         FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "{language}"))
@@ -31,13 +31,13 @@ CLASSES_QUERY = """
     """
 
 PROPERTIES_QUERY = """
-    SELECT ?class_ ?property_ ?name ?description ?value_type ?min_count ?max_count ?default
+    SELECT ?concept ?property_ ?name ?description ?value_type ?min_count ?max_count ?default
     WHERE
     {{
         # CASE 1: Handling Blocks and Terminals
         {{
             VALUES ?type {{ imf:BlockType imf:TerminalType }}
-            ?class_ a ?type ;
+            ?concept a ?type ;
                 sh:property ?propertyShape .
                 ?propertyShape sh:path ?property_ .
 
@@ -55,10 +55,10 @@ PROPERTIES_QUERY = """
 
         # CASE 2: Handling Attributes
         {{
-            ?class_ a imf:AttributeType .
+            ?concept a imf:AttributeType .
             BIND(xsd:anyURI AS ?valueShape)
             BIND(imf:predicate AS ?property_)
-            ?class_  ?property_ ?defaultURI .
+            ?concept  ?property_ ?defaultURI .
             BIND(STR(?defaultURI) AS ?default)
 
         }}
@@ -67,7 +67,7 @@ PROPERTIES_QUERY = """
         BIND(IF(BOUND(?valueShape), ?valueShape, IF(BOUND(?range) , ?range , ?valueShape)) AS ?value_type)
 
         FILTER (!isBlank(?property_))
-        FILTER (!bound(?class_) || !isBlank(?class_))
+        FILTER (!bound(?concept) || !isBlank(?concept))
         FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "{language}"))
         FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "{language}"))
     }}
@@ -75,23 +75,23 @@ PROPERTIES_QUERY = """
 
 
 class IMFImporter(BaseRDFImporter):
-    """Convert IMF Types provided as SHACL shapes to Input Rules."""
+    """Convert IMF Types provided as SHACL shapes to unverified data model."""
 
     @property
     def description(self) -> str:
         return f"IMF Types {self.source_name} read as unverified data model"
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
-        classes, issue_list = parse_classes(self.graph, CLASSES_QUERY, self.language, self.issue_list)
+        classes, issue_list = parse_concepts(self.graph, CLASSES_QUERY, self.language, self.issue_list)
         self.issue_list = issue_list
         properties, issue_list = parse_properties(self.graph, PROPERTIES_QUERY, self.language, self.issue_list)
         self.issue_list = issue_list
 
         components = {
             "Metadata": self._metadata,
-            "Classes": list(classes.values()) if classes else [],
+            "Concepts": list(classes.values()) if classes else [],
             "Properties": list(properties.values()) if properties else [],
         }
 

cognite/neat/core/_data_model/importers/_rdf/{_inference2rules.py → _inference2rdata_model.py}

@@ -12,19 +12,19 @@ from rdflib import Literal as RdfLiteral
 
 from cognite.neat.core._config import GLOBAL_CONFIG
 from cognite.neat.core._constants import NEAT, get_default_prefixes_and_namespaces
-from cognite.neat.core._data_model.analysis import RulesAnalysis
+from cognite.neat.core._data_model.analysis import DataModelAnalysis
 from cognite.neat.core._data_model.models import ConceptualDataModel, data_types
 from cognite.neat.core._data_model.models.conceptual import (
-    ConceptualClass,
+    Concept,
     ConceptualMetadata,
-    UnverifiedConceptualClass,
+    UnverifiedConcept,
     UnverifiedConceptualProperty,
 )
 from cognite.neat.core._data_model.models.data_types import AnyURI
 from cognite.neat.core._data_model.models.entities._single_value import UnknownEntity
 from cognite.neat.core._issues import IssueList
 from cognite.neat.core._issues.warnings import PropertyValueTypeUndefinedWarning
-from cognite.neat.core._store import NeatGraphStore
+from cognite.neat.core._store import NeatInstanceStore
 from cognite.neat.core._store._provenance import INSTANCES_ENTITY
 from cognite.neat.core._utils.collection_ import iterate_progress_bar
 from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
@@ -56,10 +56,10 @@ INSTANCE_PROPERTIES_DEFINITION = """SELECT ?property (count(?property) as ?occur
 
 
 class InferenceImporter(BaseRDFImporter):
-    """Infers rules from a triple store.
+    """Infers data model from instances stored as triples.
 
-    Rules inference through analysis of knowledge graph provided in various formats.
-    Use the factory methods to create a triple store from sources such as
+    Data model inference through analysis of knowledge graph provided in various formats.
+    Use the factory methods to create triples from sources such as
     RDF files, JSON files, YAML files, XML files, or directly from a graph store.
 
     ClassVars:
@@ -83,8 +83,8 @@ class InferenceImporter(BaseRDFImporter):
     @classmethod
     def from_graph_store(
         cls,
-        store: NeatGraphStore,
-        data_model_id: dm.DataModelId | tuple[str, str, str] = DEFAULT_INFERENCE_DATA_MODEL_ID,
+        store: NeatInstanceStore,
+        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_INFERENCE_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
         language: str = "en",
@@ -145,46 +145,46 @@ class InferenceImporter(BaseRDFImporter):
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
         """Convert RDF graph to dictionary defining data model and prefixes of the graph
 
         Args:
-            graph: RDF graph to be converted to TransformationRules object
+            graph: RDF graph to be converted to data model
             max_number_of_instance: Max number of instances to be considered for each class
 
         Returns:
             Tuple of data model and prefixes of the graph
         """
 
-        classes: dict[str, dict] = {}
+        concepts: dict[str, dict] = {}
         properties: dict[str, dict] = {}
         prefixes: dict[str, Namespace] = {}
         count_by_value_type_by_property: dict[str, dict[str, int]] = defaultdict(Counter)
 
         # Infers all the classes in the graph
-        for class_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
-            if (class_id := remove_namespace_from_uri(cast(URIRef, class_uri))) in classes:
+        for concept_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
+            if (concept_id := remove_namespace_from_uri(cast(URIRef, concept_uri))) in concepts:
                 # handles cases when class id is already present in classes
-                class_id = f"{class_id}_{len(classes) + 1}"
+                concept_id = f"{concept_id}_{len(concepts) + 1}"
 
-            classes[class_id] = {
-                "class_": class_id,
-                "uri": class_uri,
+            concepts[concept_id] = {
+                "concept": concept_id,
+                "uri": concept_uri,
                 "comment": f"Inferred from knowledge graph, where this class has <{no_instances}> instances",
             }
 
-            self._add_uri_namespace_to_prefixes(cast(URIRef, class_uri), prefixes)
+            self._add_uri_namespace_to_prefixes(cast(URIRef, concept_uri), prefixes)
 
         instances_query = (
             INSTANCES_OF_CLASS_QUERY if self.max_number_of_instance == -1 else INSTANCES_OF_CLASS_RICHNESS_ORDERED_QUERY
         )
 
-        classes_iterable = iterate_progress_bar(classes.items(), len(classes), "Inferring classes")
+        classes_iterable = iterate_progress_bar(concepts.items(), len(concepts), "Inferring classes")
 
         # Infers all the properties of the class
-        for class_id, class_definition in classes_iterable:
+        for concept_id, class_definition in classes_iterable:
             for (  # type: ignore[misc]
                 instance,
                 _,
@@ -216,19 +216,19 @@ class InferenceImporter(BaseRDFImporter):
 
                         issue = PropertyValueTypeUndefinedWarning(
                             resource_type="Property",
-                            identifier=f"{class_id}:{property_id}",
+                            identifier=f"{concept_id}:{property_id}",
                             property_name=property_id,
-                            default_action="Remove the property from the rules",
+                            default_action="Remove the property from the data model",
                             recommended_action="Make sure that graph is complete",
                         )
 
                         if issue not in self.issue_list:
                             self.issue_list.append(issue)
 
-                    id_ = f"{class_id}:{property_id}"
+                    id_ = f"{concept_id}:{property_id}"
 
                     definition = {
-                        "class_": class_id,
+                        "concept": concept_id,
                         "property_": property_id,
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
@@ -265,7 +265,7 @@ class InferenceImporter(BaseRDFImporter):
 
         return {
             "metadata": self._default_metadata(),
-            "classes": list(classes.values()),
+            "concepts": list(concepts.values()),
             "properties": list(properties.values()),
             "prefixes": prefixes,
         }
@@ -300,11 +300,11 @@ class _ReadProperties:
 
 
 class SubclassInferenceImporter(BaseRDFImporter):
-    """Infer subclasses from a triple store.
+    """Infer subclasses from instances stored in a triple store.
 
-    Assumes that the graph already is connected to a schema. The classes should
-    match the RDF.type of the instances in the graph, while the subclasses should
-    match the NEAT.type of the instances in the graph.
+    Assumes that the instances already are connected to a schema. The classes should
+    match the RDF.type of the instances, while the subclasses should match the NEAT.type
+    of the instances.
 
     ClassVars:
         overwrite_data_types: Mapping of data types to be overwritten. The InferenceImporter will overwrite
@@ -357,26 +357,26 @@ class SubclassInferenceImporter(BaseRDFImporter):
         self,
         issue_list: IssueList,
         graph: Graph,
-        rules: ConceptualDataModel | None = None,
+        data_model: ConceptualDataModel | None = None,
         data_model_id: dm.DataModelId | tuple[str, str, str] | None = None,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ) -> None:
-        if sum([1 for v in [rules, data_model_id] if v is not None]) != 1:
-            raise ValueError("Exactly one of rules or data_model_id must be provided.")
+        if sum([1 for v in [data_model, data_model_id] if v is not None]) != 1:
+            raise ValueError("Exactly one of data model or data_model_id must be provided.")
         if data_model_id is not None:
             identifier = data_model_id
-        elif rules is not None:
-            identifier = rules.metadata.as_data_model_id().as_tuple()  # type: ignore[assignment]
+        elif data_model is not None:
+            identifier = data_model.metadata.as_data_model_id().as_tuple()  # type: ignore[assignment]
         else:
-            raise ValueError("Exactly one of rules or data_model_id must be provided.")
+            raise ValueError("Exactly one of data model or data_model_id must be provided.")
         super().__init__(issue_list, graph, identifier, -1, non_existing_node_type, language="en")
-        self._rules = rules
+        self._data_model = data_model
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
-        if self._rules:
-            prefixes = self._rules.prefixes.copy()
+        if self._data_model:
+            prefixes = self._data_model.prefixes.copy()
         else:
             prefixes = get_default_prefixes_and_namespaces()
 
@@ -384,27 +384,27 @@ class SubclassInferenceImporter(BaseRDFImporter):
         read_properties = self._read_class_properties_from_graph(parent_by_child)
         classes, properties = self._create_classes_properties(read_properties, prefixes)
 
-        if self._rules:
-            metadata = self._rules.metadata.model_dump()
-            default_space = self._rules.metadata.prefix
+        if self._data_model:
+            metadata = self._data_model.metadata.model_dump()
+            default_space = self._data_model.metadata.prefix
         else:
             metadata = self._default_metadata()
             default_space = metadata["space"]
         return {
             "metadata": metadata,
-            "classes": [cls.dump(default_space) for cls in classes],
+            "concepts": [cls.dump(default_space) for cls in classes],
             "properties": [prop.dump(default_space) for prop in properties],
             "prefixes": prefixes,
         }
 
     def _create_classes_properties(
         self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
-    ) -> tuple[list[UnverifiedConceptualClass], list[UnverifiedConceptualProperty]]:
-        if self._rules:
-            existing_classes = {class_.class_.suffix: class_ for class_ in self._rules.classes}
+    ) -> tuple[list[UnverifiedConcept], list[UnverifiedConceptualProperty]]:
+        if self._data_model:
+            existing_classes = {class_.concept.suffix: class_ for class_ in self._data_model.concepts}
         else:
             existing_classes = {}
-        classes: list[UnverifiedConceptualClass] = []
+        classes: list[UnverifiedConcept] = []
         properties_by_class_suffix_by_property_id: dict[str, dict[str, UnverifiedConceptualProperty]] = {}
 
         # Help for IDE
@@ -429,9 +429,9 @@ class SubclassInferenceImporter(BaseRDFImporter):
                 parent_suffix = remove_namespace_from_uri(parent_uri)
                 self._add_uri_namespace_to_prefixes(parent_uri, prefixes)
                 if parent_suffix not in existing_classes:
-                    classes.append(UnverifiedConceptualClass(class_=parent_suffix))
+                    classes.append(UnverifiedConcept(concept=parent_suffix))
                 else:
-                    classes.append(UnverifiedConceptualClass.load(existing_classes[parent_suffix].model_dump()))
+                    classes.append(UnverifiedConcept.load(existing_classes[parent_suffix].model_dump()))
             else:
                 shared_property_uris = set()
             shared_properties: dict[URIRef, list[_ReadProperties]] = defaultdict(list)
@@ -441,14 +441,14 @@ class SubclassInferenceImporter(BaseRDFImporter):
 
                 if class_suffix not in existing_classes:
                     classes.append(
-                        UnverifiedConceptualClass(
-                            class_=class_suffix,
+                        UnverifiedConcept(
+                            concept=class_suffix,
                             implements=parent_suffix,
                             instance_source=type_uri,
                         )
                     )
                 else:
-                    classes.append(UnverifiedConceptualClass.load(existing_classes[class_suffix].model_dump()))
+                    classes.append(UnverifiedConcept.load(existing_classes[class_suffix].model_dump()))
 
                 properties_by_id: dict[str, UnverifiedConceptualProperty] = {}
                 for property_uri, read_properties in properties_by_property_uri.items():
@@ -509,21 +509,21 @@ class SubclassInferenceImporter(BaseRDFImporter):
         for result_row in self.graph.query(self._ordered_class_query):
             type_uri, instance_count_literal = cast(tuple[URIRef, RdfLiteral], result_row)
             count_by_type[type_uri] = instance_count_literal.toPython()
-        if self._rules:
-            analysis = RulesAnalysis(self._rules)
+        if self._data_model:
+            analysis = DataModelAnalysis(self._data_model)
             existing_class_properties = {
                 (class_entity.suffix, prop.property_): prop
-                for class_entity, properties in analysis.properties_by_class(
+                for class_entity, properties in analysis.properties_by_concepts(
                     include_ancestors=True, include_different_space=True
                 ).items()
                 for prop in properties
             }
-            existing_classes = {cls_.class_.suffix: cls_ for cls_ in self._rules.classes}
+            existing_classes = {cls_.concept.suffix: cls_ for cls_ in self._data_model.concepts}
         else:
             existing_class_properties = {}
             existing_classes = {}
         properties_by_class_by_subclass: list[_ReadProperties] = []
-        existing_class: ConceptualClass | None
+        existing_class: Concept | None
         total_instance_count = sum(count_by_type.values())
         iterable = count_by_type.items()
         if GLOBAL_CONFIG.use_iterate_bar_threshold and total_instance_count > GLOBAL_CONFIG.use_iterate_bar_threshold:
@@ -581,7 +581,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
         first = read_properties[0]
         value_type = self._get_value_type(read_properties, prefixes)
         return UnverifiedConceptualProperty(
-            class_=class_suffix,
+            concept=class_suffix,
             property_=property_id,
             max_count=first.max_occurrence,
             value_type=value_type,

cognite/neat/core/_data_model/importers/_rdf/{_owl2rules.py → _owl2data_model.py}

@@ -1,22 +1,22 @@
 """This module performs importing of various formats to one of serializations for which
-there are loaders to TransformationRules pydantic class."""
+there are loaders to data model pydantic class."""
 
 from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
 from cognite.neat.core._data_model.importers._rdf._shared import (
-    parse_classes,
+    parse_concepts,
     parse_properties,
 )
 
-CLASSES_QUERY = """SELECT ?class_ ?name ?description ?implements
+CLASSES_QUERY = """SELECT ?concept  ?name ?description ?implements
         WHERE {{
 
-        ?class_ a owl:Class .
-        OPTIONAL {{?class_ rdfs:subClassOf ?implements }}.
-        OPTIONAL {{?class_ rdfs:label|skos:prefLabel ?name }}.
-        OPTIONAL {{?class_ rdfs:comment|skos:definition ?description}} .
+        ?concept  a owl:Class .
+        OPTIONAL {{?concept  rdfs:subClassOf ?implements }}.
+        OPTIONAL {{?concept  rdfs:label|skos:prefLabel ?name }}.
+        OPTIONAL {{?concept  rdfs:comment|skos:definition ?description}} .
 
 
-        FILTER (!isBlank(?class_))
+        FILTER (!isBlank(?concept ))
         FILTER (!bound(?implements) || !isBlank(?implements))
 
         FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "{language}"))
@@ -27,11 +27,11 @@ CLASSES_QUERY = """SELECT ?class_ ?name ?description ?implements
 
 PROPERTIES_QUERY = """
 
-    SELECT ?class_ ?property_ ?name ?description ?value_type ?minCount ?maxCount ?default
+    SELECT ?concept  ?property_ ?name ?description ?value_type ?minCount ?maxCount ?default
     WHERE {{
         ?property_ a ?property_Type.
         FILTER (?property_Type IN (owl:ObjectProperty, owl:DatatypeProperty ) )
-        OPTIONAL {{?property_ rdfs:domain ?class_ }}.
+        OPTIONAL {{?property_ rdfs:domain ?concept  }}.
         OPTIONAL {{?property_ rdfs:range ?value_type }}.
         OPTIONAL {{?property_ rdfs:label|skos:prefLabel ?name }}.
         OPTIONAL {{?property_ rdfs:comment|skos:definition ?description}}.
@@ -47,27 +47,27 @@ PROPERTIES_QUERY = """
 
 
 class OWLImporter(BaseRDFImporter):
-    """Convert OWL ontology to tables/ transformation rules / Excel file.
+    """Convert OWL ontology to unverified data model.
 
         Args:
             filepath: Path to OWL ontology
 
     !!! Note
         OWL Ontologies are information models which completeness varies. As such, constructing functional
-        data model directly will often be impossible, therefore the produced Rules object will be ill formed.
-        To avoid this, neat will automatically attempt to make the imported rules compliant by adding default
+        data model directly will often be impossible, therefore the produced data model object will be ill formed.
+        To avoid this, neat will automatically attempt to make the imported data model compliant by adding default
         values for missing information, attaching dangling properties to default containers based on the
         property type, etc.
 
         One has to be aware that NEAT will be opinionated about how to make the ontology
-        compliant, and that the resulting rules may not be what you expect.
+        compliant, and that the resulting data model may not be what you expect.
 
     """
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
-        classes, issue_list = parse_classes(self.graph, CLASSES_QUERY, self.language, self.issue_list)
+        concepts, issue_list = parse_concepts(self.graph, CLASSES_QUERY, self.language, self.issue_list)
         self.issue_list = issue_list
 
         # NeatError
@@ -76,7 +76,7 @@ class OWLImporter(BaseRDFImporter):
 
         components = {
             "Metadata": self._metadata,
-            "Classes": list(classes.values()) if classes else [],
+            "Concepts": list(concepts.values()) if concepts else [],
             "Properties": list(properties.values()) if properties else [],
         }
 

cognite/neat/core/_data_model/importers/_rdf/_shared.py

@@ -13,18 +13,18 @@ from cognite.neat.core._issues.warnings._resources import (
 from cognite.neat.core._utils.rdf_ import convert_rdflib_content
 
 
-def parse_classes(graph: Graph, query: str, language: str, issue_list: IssueList) -> tuple[dict, IssueList]:
-    """Parse classes from graph
+def parse_concepts(graph: Graph, query: str, language: str, issue_list: IssueList) -> tuple[dict, IssueList]:
+    """Parse concepts from graph
 
     Args:
-        graph: Graph containing classes definitions
+        graph: Graph containing concept definitions
         language: Language to use for parsing, by default "en"
 
     Returns:
         Dataframe containing owl classes
     """
 
-    classes: dict[str, dict] = {}
+    concepts: dict[str, dict] = {}
 
     query = prepareQuery(query.format(language=language), initNs={k: v for k, v in graph.namespaces()})
     expected_keys = [str(v) for v in query.algebra._vars]
@@ -33,42 +33,42 @@ def parse_classes(graph: Graph, query: str, language: str, issue_list: IssueList
         res: dict = convert_rdflib_content(cast(ResultRow, raw).asdict(), True)
         res = {key: res.get(key, None) for key in expected_keys}
 
-        class_id = res["class_"]
+        concept_id = res["concept"]
 
         # Safeguarding against incomplete semantic definitions
         if res["implements"] and isinstance(res["implements"], BNode):
             issue_list.append(
                 ResourceRetrievalWarning(
-                    class_id,
+                    concept_id,
                     "implements",
-                    error=("Unable to determine class that is being implemented"),
+                    error=("Unable to determine concept that is being implemented"),
                 )
             )
             continue
 
-        if class_id not in classes:
-            classes[class_id] = res
+        if concept_id not in concepts:
+            concepts[concept_id] = res
         else:
             # Handling implements
-            if classes[class_id]["implements"] and isinstance(classes[class_id]["implements"], list):
-                if res["implements"] not in classes[class_id]["implements"]:
-                    classes[class_id]["implements"].append(res["implements"])
+            if concepts[concept_id]["implements"] and isinstance(concepts[concept_id]["implements"], list):
+                if res["implements"] not in concepts[concept_id]["implements"]:
+                    concepts[concept_id]["implements"].append(res["implements"])
 
-            elif classes[class_id]["implements"] and isinstance(classes[class_id]["implements"], str):
-                classes[class_id]["implements"] = [classes[class_id]["implements"]]
+            elif concepts[concept_id]["implements"] and isinstance(concepts[concept_id]["implements"], str):
+                concepts[concept_id]["implements"] = [concepts[concept_id]["implements"]]
 
-                if res["implements"] not in classes[class_id]["implements"]:
-                    classes[class_id]["implements"].append(res["implements"])
+                if res["implements"] not in concepts[concept_id]["implements"]:
+                    concepts[concept_id]["implements"].append(res["implements"])
             elif res["implements"]:
-                classes[class_id]["implements"] = [res["implements"]]
+                concepts[concept_id]["implements"] = [res["implements"]]
 
-            handle_meta("class_", classes, class_id, res, "name", issue_list)
-            handle_meta("class_", classes, class_id, res, "description", issue_list)
+            handle_meta("concept", concepts, concept_id, res, "name", issue_list)
+            handle_meta("concept", concepts, concept_id, res, "description", issue_list)
 
-    if not classes:
-        issue_list.append(NeatValueError("Unable to parse classes"))
+    if not concepts:
+        issue_list.append(NeatValueError("Unable to parse concepts"))
 
-    return classes, issue_list
+    return concepts, issue_list
 
 
 def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueList) -> tuple[dict, IssueList]:
@@ -94,12 +94,12 @@ def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueL
         property_id = res["property_"]
 
         # Safeguarding against incomplete semantic definitions
-        if not res["class_"] or isinstance(res["class_"], BNode):
+        if not res["concept"] or isinstance(res["concept"], BNode):
             issue_list.append(
                 ResourceRetrievalWarning(
                     property_id,
                     "property",
-                    error=("Unable to determine to what class property is being defined"),
+                    error=("Unable to determine to what concept property is being defined"),
                 )
             )
             continue
@@ -115,7 +115,7 @@ def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueL
             )
             continue
 
-        id_ = f"{res['class_']}.{res['property_']}"
+        id_ = f"{res['concept']}.{res['property_']}"
 
         if id_ not in properties:
             properties[id_] = res