Merge pull request #404 from ialarmedalien/ruff_format

Ruff format

Author: sierra-moxon

.github/workflows/main.yaml

@@ -34,11 +34,9 @@ jobs:
       - name: Run code format checks
         run: tox -e format_check
 
-
   test:
-    # TODO: uncomment when ruff format has been run over the codebase
-    # needs:
-    #   - quality-checks
+    needs:
+      - quality-checks
     strategy:
       fail-fast: false
       matrix:

linkml_runtime/__init__.py

@@ -12,13 +12,13 @@
 # the version in the code
 import importlib.metadata as importlib_metadata
 
-LINKML = CurieNamespace('linkml', 'https://w3id.org/linkml/')
-TCCM = CurieNamespace('tccm', 'https://ontologies.r.us/tccm/')
-OWL = CurieNamespace('owl', OWL)
-RDF = CurieNamespace('rdf', RDF)
-RDFS = CurieNamespace('rdfs', RDFS)
-SKOS = CurieNamespace('skos', SKOS)
-XSD = CurieNamespace('xsd', XSD)
+LINKML = CurieNamespace("linkml", "https://w3id.org/linkml/")
+TCCM = CurieNamespace("tccm", "https://ontologies.r.us/tccm/")
+OWL = CurieNamespace("owl", OWL)
+RDF = CurieNamespace("rdf", RDF)
+RDFS = CurieNamespace("rdfs", RDFS)
+SKOS = CurieNamespace("skos", SKOS)
+XSD = CurieNamespace("xsd", XSD)
 
 __version__ = importlib_metadata.version(__name__)
 
@@ -39,24 +39,28 @@
 
 
 URI_TO_LOCAL = {
-    'https://w3id.org/linkml/annotations.yaml': str(LINKML_ANNOTATIONS),
-    'https://w3id.org/linkml/array.yaml': str(LINKML_ARRAY),
-    'https://w3id.org/linkml/extensions.yaml': str(LINKML_EXTENSIONS),
-    'https://w3id.org/linkml/mappings.yaml': str(LINKML_MAPPINGS),
-    'https://w3id.org/linkml/meta.yaml': str(MAIN_SCHEMA_PATH),
-    'https://w3id.org/linkml/types.yaml': str(LINKML_TYPES),
-    'https://w3id.org/linkml/units.yaml': str(LINKML_UNITS),
-    'https://w3id.org/linkml/validation.yaml': str(LINKML_VALIDATION),
+    "https://w3id.org/linkml/annotations.yaml": str(LINKML_ANNOTATIONS),
+    "https://w3id.org/linkml/array.yaml": str(LINKML_ARRAY),
+    "https://w3id.org/linkml/extensions.yaml": str(LINKML_EXTENSIONS),
+    "https://w3id.org/linkml/mappings.yaml": str(LINKML_MAPPINGS),
+    "https://w3id.org/linkml/meta.yaml": str(MAIN_SCHEMA_PATH),
+    "https://w3id.org/linkml/types.yaml": str(LINKML_TYPES),
+    "https://w3id.org/linkml/units.yaml": str(LINKML_UNITS),
+    "https://w3id.org/linkml/validation.yaml": str(LINKML_VALIDATION),
 }
 
+
 class MappingError(ValueError):
     """
     An error when mapping elements of a LinkML model to runtime objects
     """
+
     pass
 
+
 class DataNotFoundError(ValueError):
     """
     An error in which data cannot be found
     """
+
     pass

linkml_runtime/dumpers/csv_dumper.py

@@ -2,7 +2,6 @@
 
 
 class CSVDumper(DelimitedFileDumper):
-
     @property
     def delimiter(self):
         return ","

linkml_runtime/dumpers/delimited_file_dumper.py

@@ -16,18 +16,20 @@
 
 
 class DelimitedFileDumper(Dumper, ABC):
-
     @property
     @abstractmethod
     def delimiter(self):
         pass
 
-    def dumps(self, element: Union[BaseModel, YAMLRoot],
-              index_slot: SlotDefinitionName = None,
-              schema: SchemaDefinition = None,
-              schemaview: SchemaView = None,
-              **kwargs) -> str:
-        """ Return element formatted as CSV lines """
+    def dumps(
+        self,
+        element: Union[BaseModel, YAMLRoot],
+        index_slot: SlotDefinitionName = None,
+        schema: SchemaDefinition = None,
+        schemaview: SchemaView = None,
+        **kwargs,
+    ) -> str:
+        """Return element formatted as CSV lines"""
         json_dumper = JSONDumper()
         element_j = json.loads(json_dumper.dumps(element))
         objs = element_j[index_slot]

linkml_runtime/dumpers/dumper_root.py

@@ -6,7 +6,7 @@
 
 
 class Dumper(ABC):
-    """ Abstract base class for all dumpers """
+    """Abstract base class for all dumpers"""
 
     def dump(self, element: Union[BaseModel, YAMLRoot], to_file: str, **_) -> None:
         """
@@ -15,7 +15,7 @@ def dump(self, element: Union[BaseModel, YAMLRoot], to_file: str, **_) -> None:
         :param to_file: file to dump to
         :@param _: method specific arguments
         """
-        with open(to_file, 'w', encoding='UTF-8') as output_file:
+        with open(to_file, "w", encoding="UTF-8") as output_file:
             output_file.write(self.dumps(element, **_))
 
     @abstractmethod

linkml_runtime/dumpers/json_dumper.py

@@ -15,9 +15,9 @@
 
 
 class JSONDumper(Dumper):
-
-    def dump(self, element: Union[BaseModel, YAMLRoot], to_file: str, contexts: CONTEXTS_PARAM_TYPE = None,
-             **kwargs) -> None:
+    def dump(
+        self, element: Union[BaseModel, YAMLRoot], to_file: str, contexts: CONTEXTS_PARAM_TYPE = None, **kwargs
+    ) -> None:
         """
         Write element as json to to_file
         :param element: LinkML object to be serialized as YAML
@@ -61,12 +61,12 @@ def default(o):
                 return str(o)
             else:
                 return json.JSONDecoder().decode(o)
+
         if isinstance(element, BaseModel):
             element = element.model_dump()
-        return json.dumps(as_json_object(element, contexts, inject_type=inject_type),
-                          default=default,
-                          ensure_ascii=False,
-                          indent='  ')
+        return json.dumps(
+            as_json_object(element, contexts, inject_type=inject_type), default=default, ensure_ascii=False, indent="  "
+        )
 
     @staticmethod
     @deprecated("Use `utils/formatutils/remove_empty_items` instead")
@@ -78,8 +78,9 @@ def remove_empty_items(obj: dict) -> dict:
         """
         return formatutils.remove_empty_items(obj, hide_protected_keys=True)
 
-    def to_json_object(self, element: Union[BaseModel, YAMLRoot], contexts: CONTEXTS_PARAM_TYPE = None,
-                       inject_type=True) -> JsonObj:
+    def to_json_object(
+        self, element: Union[BaseModel, YAMLRoot], contexts: CONTEXTS_PARAM_TYPE = None, inject_type=True
+    ) -> JsonObj:
         """
         As dumps(), except returns a JsonObj, not a string
 

linkml_runtime/dumpers/rdf_dumper.py

@@ -13,7 +13,9 @@
 
 
 class RDFDumper(Dumper):
-    def as_rdf_graph(self, element: Union[BaseModel, YAMLRoot], contexts: CONTEXTS_PARAM_TYPE, namespaces: CONTEXT_TYPE = None) -> Graph:
+    def as_rdf_graph(
+        self, element: Union[BaseModel, YAMLRoot], contexts: CONTEXTS_PARAM_TYPE, namespaces: CONTEXT_TYPE = None
+    ) -> Graph:
         """
         Convert element into an RDF graph guided by the context(s) in contexts
         :param element: element to represent in RDF
@@ -29,42 +31,49 @@ def as_rdf_graph(self, element: Union[BaseModel, YAMLRoot], contexts: CONTEXTS_P
         :return: rdflib Graph containing element
         """
         if contexts is None:
-            raise Exception(f'Must pass in JSON-LD context via contexts parameter')
+            raise Exception(f"Must pass in JSON-LD context via contexts parameter")
         if isinstance(contexts, list):
             inp_contexts = [json.loads(hbread(c)) for c in contexts]
         else:
             inp_contexts = json.loads(hbread(contexts))
 
         from linkml_runtime.dumpers import json_dumper
+
         jsonld_str = json_dumper.dumps(element)
-        g = Graph().parse(data=jsonld_str, format='json-ld')
-        #rdf_jsonld = expand()
-        #g = rdflib_graph_from_pyld_jsonld(rdf_jsonld)
+        g = Graph().parse(data=jsonld_str, format="json-ld")
+        # rdf_jsonld = expand()
+        # g = rdflib_graph_from_pyld_jsonld(rdf_jsonld)
 
         if namespaces is not None:
             ns_source = json.loads(hbread(namespaces))
         else:
             ns_source = inp_contexts
 
         # TODO: make a utility out of this or add it to prefixcommons
-        if ns_source and '@context' in ns_source:
-            ns_contexts = ns_source['@context']
+        if ns_source and "@context" in ns_source:
+            ns_contexts = ns_source["@context"]
             if isinstance(ns_contexts, dict):
                 ns_contexts = [ns_contexts]
             for ns_context in ns_contexts:
                 if isinstance(ns_context, dict):
                     for pfx, ns in ns_context.items():
                         if isinstance(ns, dict):
-                            if '@id' in ns and ns.get('@prefix', False):
-                                ns = ns['@id']
+                            if "@id" in ns and ns.get("@prefix", False):
+                                ns = ns["@id"]
                             else:
                                 continue
-                        if not pfx.startswith('@'):
+                        if not pfx.startswith("@"):
                             g.bind(pfx, ns)
 
         return g
 
-    def dump(self, element: Union[BaseModel, YAMLRoot], to_file: str, contexts: CONTEXTS_PARAM_TYPE = None, fmt: str = 'turtle') -> None:
+    def dump(
+        self,
+        element: Union[BaseModel, YAMLRoot],
+        to_file: str,
+        contexts: CONTEXTS_PARAM_TYPE = None,
+        fmt: str = "turtle",
+    ) -> None:
         """
         Write element as rdf to to_file
         :param element: LinkML object to be emitted
@@ -82,7 +91,9 @@ def dump(self, element: Union[BaseModel, YAMLRoot], to_file: str, contexts: CONT
             element = element.model_dump()
         super().dump(element, to_file, contexts=contexts, fmt=fmt)
 
-    def dumps(self, element: Union[BaseModel, YAMLRoot], contexts: CONTEXTS_PARAM_TYPE = None, fmt: Optional[str] = 'turtle') -> str:
+    def dumps(
+        self, element: Union[BaseModel, YAMLRoot], contexts: CONTEXTS_PARAM_TYPE = None, fmt: Optional[str] = "turtle"
+    ) -> str:
         """
         Convert element into an RDF graph guided by the context(s) in contexts
         :param element: element to represent in RDF
@@ -92,5 +103,4 @@ def dumps(self, element: Union[BaseModel, YAMLRoot], contexts: CONTEXTS_PARAM_TY
         """
         if isinstance(element, BaseModel):
             element = element.model_dump()
-        return self.as_rdf_graph(remove_empty_items(element, hide_protected_keys=True), contexts).\
-            serialize(format=fmt)
+        return self.as_rdf_graph(remove_empty_items(element, hide_protected_keys=True), contexts).serialize(format=fmt)

linkml_runtime/dumpers/rdflib_dumper.py

@@ -26,6 +26,7 @@ class RDFLibDumper(Dumper):
     This requires a SchemaView object
 
     """
+
     def as_rdf_graph(
         self,
         element: Union[BaseModel, YAMLRoot],
@@ -45,7 +46,7 @@ def as_rdf_graph(
         if isinstance(prefix_map, Converter):
             # TODO replace with `prefix_map = prefix_map.bimap` after making minimum requirement on python 3.8
             prefix_map = {record.prefix: record.uri_prefix for record in prefix_map.records}
-        logger.debug(f'PREFIXMAP={prefix_map}')
+        logger.debug(f"PREFIXMAP={prefix_map}")
         namespaces = schemaview.namespaces()
         if prefix_map:
             for k, v in prefix_map.items():
@@ -69,7 +70,9 @@ def as_rdf_graph(
         self.inject_triples(element, schemaview, g)
         return g
 
-    def inject_triples(self, element: Any, schemaview: SchemaView, graph: Graph, target_type: ElementName = None) -> Node:
+    def inject_triples(
+        self, element: Any, schemaview: SchemaView, graph: Graph, target_type: ElementName = None
+    ) -> Node:
         """
         Inject triples from conversion of element into a Graph
 
@@ -81,7 +84,7 @@ def inject_triples(self, element: Any, schemaview: SchemaView, graph: Graph, tar
         """
         namespaces = schemaview.namespaces()
         slot_name_map = schemaview.slot_name_mappings()
-        logger.debug(f'CONVERT: {element} // {type(element)} // {target_type}')
+        logger.debug(f"CONVERT: {element} // {type(element)} // {target_type}")
         if target_type in schemaview.all_enums():
             if isinstance(element, PermissibleValueText):
                 e = schemaview.get_enum(target_type)
@@ -97,22 +100,22 @@ def inject_triples(self, element: Any, schemaview: SchemaView, graph: Graph, tar
             t = schemaview.get_type(target_type)
             dt_uri = t.uri
             if dt_uri:
-                if dt_uri == 'rdfs:Resource':
+                if dt_uri == "rdfs:Resource":
                     return URIRef(schemaview.expand_curie(element))
-                elif dt_uri == 'xsd:string':
+                elif dt_uri == "xsd:string":
                     return Literal(element)
                 else:
                     if "xsd" not in namespaces:
                         namespaces["xsd"] = XSD
                     return Literal(element, datatype=namespaces.uri_for(dt_uri))
             else:
-                logger.warning(f'No datatype specified for : {t.name}, using plain Literal')
+                logger.warning(f"No datatype specified for : {t.name}, using plain Literal")
                 return Literal(element)
-        element_vars = {k: v for k, v in vars(element).items() if not k.startswith('_')}
+        element_vars = {k: v for k, v in vars(element).items() if not k.startswith("_")}
         if len(element_vars) == 0:
             id_slot = schemaview.get_identifier_slot(target_type)
             return self._as_uri(element, id_slot, schemaview)
-            #return URIRef(schemaview.expand_curie(str(element)))
+            # return URIRef(schemaview.expand_curie(str(element)))
         element_type = type(element)
         cn = element_type.class_name
         id_slot = schemaview.get_identifier_slot(cn)
@@ -135,7 +138,7 @@ def inject_triples(self, element: Any, schemaview: SchemaView, graph: Graph, tar
                 if k in slot_name_map:
                     k = slot_name_map[k].name
                 else:
-                    logger.error(f'Slot {k} not in name map')
+                    logger.error(f"Slot {k} not in name map")
                 slot = schemaview.induced_slot(k, cn)
                 if not slot.identifier:
                     slot_uri = URIRef(schemaview.get_uri(slot, expand=True))
@@ -152,7 +155,7 @@ def dump(
         element: Union[BaseModel, YAMLRoot],
         to_file: str,
         schemaview: SchemaView = None,
-        fmt: str = 'turtle',
+        fmt: str = "turtle",
         prefix_map: Union[dict[str, str], Converter, None] = None,
         **args,
     ) -> None:
@@ -172,7 +175,7 @@ def dumps(
         self,
         element: Union[BaseModel, YAMLRoot],
         schemaview: SchemaView = None,
-        fmt: Optional[str] = 'turtle',
+        fmt: Optional[str] = "turtle",
         prefix_map: Union[dict[str, str], Converter, None] = None,
     ) -> str:
         """
@@ -184,12 +187,10 @@ def dumps(
         :param prefix_map:
         :return: serialization of rdflib Graph containing element
         """
-        return self.as_rdf_graph(element, schemaview, prefix_map=prefix_map).\
-            serialize(format=fmt)
+        return self.as_rdf_graph(element, schemaview, prefix_map=prefix_map).serialize(format=fmt)
 
     def _as_uri(self, element_id: str, id_slot: Optional[SlotDefinition], schemaview: SchemaView) -> URIRef:
         if id_slot and schemaview.is_slot_percent_encoded(id_slot):
             return URIRef(urllib.parse.quote(element_id))
         else:
             return schemaview.namespaces().uri_for(element_id)
-

linkml_runtime/dumpers/tsv_dumper.py

@@ -2,7 +2,6 @@
 
 
 class TSVDumper(DelimitedFileDumper):
-
     @property
     def delimiter(self):
         return "\t"

linkml_runtime/dumpers/yaml_dumper.py

@@ -6,15 +6,18 @@
 from linkml_runtime.utils.formatutils import remove_empty_items
 from linkml_runtime.utils.yamlutils import YAMLRoot
 
-class YAMLDumper(Dumper):
 
+class YAMLDumper(Dumper):
     def dumps(self, element: Union[BaseModel, YAMLRoot], **kwargs) -> str:
-        """ Return element formatted as a YAML string """
+        """Return element formatted as a YAML string"""
         # Internal note: remove_empty_items will also convert Decimals to int/float;
         # this is necessary until https://github.com/yaml/pyyaml/pull/372 is merged
 
         dumper_safe_element = element.model_dump() if isinstance(element, BaseModel) else element
-        return yaml.dump(remove_empty_items(dumper_safe_element, hide_protected_keys=True),
-                         Dumper=yaml.SafeDumper, sort_keys=False, 
-                         allow_unicode=True,
-                         **kwargs)
+        return yaml.dump(
+            remove_empty_items(dumper_safe_element, hide_protected_keys=True),
+            Dumper=yaml.SafeDumper,
+            sort_keys=False,
+            allow_unicode=True,
+            **kwargs,
+        )