move from cls to self for instance properties

Author: MBueschelberger

data2rdf/models/base.py

@@ -71,14 +71,14 @@ class BasicGraphModel(BasicConceptMapping):
 
     @property
     @abstractmethod
-    def json_ld(cls) -> Dict[str, Any]:
+    def json_ld(self) -> Dict[str, Any]:
         """Return dict for json-ld of graph"""
 
     @property
-    def graph(cls) -> Graph:
+    def graph(self) -> Graph:
         """Return graph object based on json-ld"""
-        graph = Graph(identifier=cls.config.graph_identifier)
-        graph.parse(data=json.dumps(cls.json_ld), format="json-ld")
+        graph = Graph(identifier=self.config.graph_identifier)
+        graph.parse(data=json.dumps(self.json_ld), format="json-ld")
         return graph
 
 

data2rdf/models/graph.py

@@ -226,23 +226,23 @@ def validate_quantity_graph(cls, self) -> "QuantityGraph":
         return self
 
     @property
-    def json_ld(cls) -> Dict[str, Any]:
+    def json_ld(self) -> Dict[str, Any]:
         """Return dict of json-ld for graph"""
         return {
             "@context": {
-                f"{cls.config.prefix_name}": make_prefix(cls.config),
+                f"{self.config.prefix_name}": make_prefix(self.config),
                 "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
                 "xsd": "http://www.w3.org/2001/XMLSchema#",
                 "qudt": "http://qudt.org/schema/qudt/",
             },
-            "@id": f"{cls.config.prefix_name}:{cls.suffix}",
+            "@id": f"{self.config.prefix_name}:{self.suffix}",
             "@type": (
-                [str(iri) for iri in cls.iri]
-                if isinstance(cls.iri, list)
-                else str(cls.iri)
+                [str(iri) for iri in self.iri]
+                if isinstance(self.iri, list)
+                else str(self.iri)
             ),
-            **cls.unit_json,
-            **cls.value_json,
+            **self.unit_json,
+            **self.value_json,
         }
 
     @property
@@ -340,17 +340,17 @@ def validate_property_graph(cls, self: "PropertyGraph") -> "PropertyGraph":
         return self
 
     @property
-    def json_ld(cls) -> Dict[str, Any]:
+    def json_ld(self) -> Dict[str, Any]:
         """Return dict of json-ld for graph"""
         return {
             "@context": {
-                f"{cls.config.prefix_name}": make_prefix(cls.config),
+                f"{self.config.prefix_name}": make_prefix(self.config),
                 "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
                 "xsd": "http://www.w3.org/2001/XMLSchema#",
             },
-            "@id": f"{cls.config.prefix_name}:{cls.suffix}",
-            **cls.value_json,
-            **cls.types_json,
+            "@id": f"{self.config.prefix_name}:{self.suffix}",
+            **self.value_json,
+            **self.types_json,
         }
 
     @property
@@ -372,26 +372,26 @@ def value_json(self) -> "Optional[Dict[str, str]]":
         return response
 
     @property
-    def types_json(cls) -> "Dict[str, Any]":
+    def types_json(self) -> "Dict[str, Any]":
         """Dict of json-ld for class types of the individual"""
-        if cls.annotation:
+        if self.annotation:
             types = {
                 "@type": [
                     (
-                        [str(iri) for iri in cls.iri]
-                        if isinstance(cls.iri, list)
-                        else str(cls.iri)
+                        [str(iri) for iri in self.iri]
+                        if isinstance(self.iri, list)
+                        else str(self.iri)
                     ),
-                    cls.annotation,
+                    self.annotation,
                 ]
             }
         else:
             types = {
                 "@type": [
                     (
-                        [str(iri) for iri in cls.iri]
-                        if isinstance(cls.iri, list)
-                        else str(cls.iri)
+                        [str(iri) for iri in self.iri]
+                        if isinstance(self.iri, list)
+                        else str(self.iri)
                     )
                 ]
             }

data2rdf/parsers/base.py

@@ -72,7 +72,7 @@ def json_ld(self) -> Dict[str, Any]:
 
     @property
     @abstractmethod
-    def mapping_model(cls) -> "BaseParser":
+    def mapping_model(self) -> "BaseParser":
         """Pydantic model for validating mapping.
         Must be a subclass of `ABoxBaseParser` or `TBoxBaseParser`.
         """
@@ -93,10 +93,10 @@ def _load_data_file(cls, self: "BaseParser") -> "Dict[str, Any]":
         """Class method for loading data file"""
 
     @property
-    def graph(cls) -> "Graph":
+    def graph(self) -> "Graph":
         """Return RDF Graph from the parsed data."""
-        graph = Graph(identifier=cls.config.graph_identifier)
-        graph.parse(data=json.dumps(cls.json_ld), format="json-ld")
+        graph = Graph(identifier=self.config.graph_identifier)
+        graph.parse(data=json.dumps(self.json_ld), format="json-ld")
         return graph
 
     @model_validator(mode="after")
@@ -313,11 +313,11 @@ def execute_parser(cls, self: "BaseFileParser") -> "BaseFileParser":
         return self
 
     @property
-    def plain_metadata(cls) -> Dict[str, Any]:
+    def plain_metadata(self) -> Dict[str, Any]:
         """Metadata as flat json - without units and iris.
         Useful e.g. for the custom properties of the DSMS."""
-        if cls.mode == PipelineMode.ABOX:
-            return cls.abox.plain_metadata
+        if self.mode == PipelineMode.ABOX:
+            return self.abox.plain_metadata
         else:
             raise NotImplementedError(
                 "`plain_metadata` is not available in `tbox`-mode."
@@ -333,30 +333,30 @@ def to_dict(self, schema: Callable = None) -> "List[Dict[str, Any]]":
             )
 
     @property
-    def general_metadata(cls) -> "List[BasicConceptMapping]":
+    def general_metadata(self) -> "List[BasicConceptMapping]":
         """Return list object with general metadata"""
-        if cls.mode == PipelineMode.ABOX:
-            return cls.abox.general_metadata
+        if self.mode == PipelineMode.ABOX:
+            return self.abox.general_metadata
         else:
             raise NotImplementedError(
                 "`general_metadata` is not available in `tbox`-mode."
             )
 
     @property
-    def dataframe_metadata(cls) -> "List[BasicConceptMapping]":
+    def dataframe_metadata(self) -> "List[BasicConceptMapping]":
         """Return time series metadata"""
-        if cls.mode == PipelineMode.ABOX:
-            return cls.abox.dataframe_metadata
+        if self.mode == PipelineMode.ABOX:
+            return self.abox.dataframe_metadata
         else:
             raise NotImplementedError(
                 "`dataframe_metadata` is not available in `tbox`-mode."
             )
 
     @property
-    def dataframe(cls) -> "Dict[str, Any]":
+    def dataframe(self) -> "Dict[str, Any]":
         """Return time series"""
-        if cls.mode == PipelineMode.ABOX:
-            return cls.abox.dataframe
+        if self.mode == PipelineMode.ABOX:
+            return self.abox.dataframe
         else:
             raise NotImplementedError(
                 "`dataframe` is not available in `tbox`-mode."

data2rdf/parsers/csv.py

@@ -68,15 +68,15 @@ class CSVTBoxParser(TBoxBaseParser):
 
     # OVERRIDE
     @property
-    def mapping_model(cls) -> TBoxBaseMapping:
+    def mapping_model(self) -> TBoxBaseMapping:
         """TBox Mapping Model for CSV Parser"""
         return TBoxBaseMapping
 
     # OVERRIDE
     @property
-    def json_ld(cls) -> "Dict[str, Any]":
+    def json_ld(self) -> "Dict[str, Any]":
         """Make the json-ld if pipeline is in abox-mode"""
-        return _make_tbox_json_ld(cls)
+        return _make_tbox_json_ld(self)
 
     # OVERRIDE
     @classmethod
@@ -137,13 +137,13 @@ class CSVABoxParser(ABoxBaseParser):
 
     # OVERRIDE
     @property
-    def mapping_model(cls) -> ABoxBaseMapping:
+    def mapping_model(self) -> ABoxBaseMapping:
         """ABox Mapping Model for CSV Parser"""
         return ABoxBaseMapping
 
     # OVERRIDE
     @property
-    def json_ld(cls) -> "Dict[str, Any]":
+    def json_ld(self) -> "Dict[str, Any]":
         """
         Returns a JSON-LD representation of the CSV data in ABox mode.
 
@@ -162,17 +162,17 @@ def json_ld(cls) -> "Dict[str, Any]":
         Dict[str, Any]: A JSON-LD object representing the CSV data in ABox mode.
         """
 
-        if not cls.config.suppress_file_description:
+        if not self.config.suppress_file_description:
             tables = []
 
-            if cls.general_metadata:
+            if self.general_metadata:
                 meta_table = {
                     "@type": "csvw:Table",
                     "rdfs:label": "Metadata",
                     "csvw:row": [],
                 }
 
-                for n, mapping in enumerate(cls.general_metadata):
+                for n, mapping in enumerate(self.general_metadata):
                     if isinstance(mapping, QuantityGraph):
                         row = {
                             "@type": "csvw:Row",
@@ -207,7 +207,7 @@ def json_ld(cls) -> "Dict[str, Any]":
                         )
                 tables += [meta_table]
 
-            if cls.dataframe_metadata:
+            if self.dataframe_metadata:
                 column_schema = {"@type": "csvw:Schema", "csvw:column": []}
                 tables += [
                     {
@@ -216,7 +216,7 @@ def json_ld(cls) -> "Dict[str, Any]":
                         "csvw:tableSchema": column_schema,
                     }
                 ]
-                for idx, mapping in enumerate(cls.dataframe_metadata):
+                for idx, mapping in enumerate(self.dataframe_metadata):
                     if isinstance(mapping, QuantityGraph):
                         entity = {"qudt:quantity": mapping.json_ld}
                     elif isinstance(mapping, PropertyGraph):
@@ -226,12 +226,12 @@ def json_ld(cls) -> "Dict[str, Any]":
                             f"Mapping must be of type {QuantityGraph} or {PropertyGraph}, not {type(mapping)}"
                         )
 
-                    if cls.config.data_download_uri:
+                    if self.config.data_download_uri:
                         download_url = {
                             "dcterms:identifier": {
                                 "@type": "xsd:anyURI",
                                 "@value": urljoin(
-                                    str(cls.config.data_download_uri),
+                                    str(self.config.data_download_uri),
                                     f"column-{idx}",
                                 ),
                             }
@@ -272,7 +272,7 @@ def json_ld(cls) -> "Dict[str, Any]":
 
             json_ld = {
                 "@context": {
-                    f"{cls.config.prefix_name}": make_prefix(cls.config),
+                    f"{self.config.prefix_name}": make_prefix(self.config),
                     "csvw": "http://www.w3.org/ns/csvw#",
                     "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
                     "dcat": "http://www.w3.org/ns/dcat#",
@@ -282,14 +282,14 @@ def json_ld(cls) -> "Dict[str, Any]":
                     "csvw": "http://www.w3.org/ns/csvw#",
                     "foaf": "http://xmlns.com/foaf/spec/",
                 },
-                "@id": f"{cls.config.prefix_name}:tableGroup",
+                "@id": f"{self.config.prefix_name}:tableGroup",
                 "@type": "csvw:TableGroup",
                 **csvw_tables,
             }
         else:
             json_ld = {
-                "@graph": [model.json_ld for model in cls.general_metadata]
-                + [model.json_ld for model in cls.dataframe_metadata]
+                "@graph": [model.json_ld for model in self.general_metadata]
+                + [model.json_ld for model in self.dataframe_metadata]
             }
         return json_ld