fixed linting

Author: sneakers-the-rat

linkml_runtime/index/object_index.py

@@ -11,8 +11,8 @@
 
 import inspect
 import logging
-from collections.abc import Iterator, Mapping
-from typing import Any, Union
+from collections.abc import Iterator, MutableMapping
+from typing import Any
 
 from linkml_runtime import SchemaView
 from linkml_runtime.utils import eval_utils
@@ -56,9 +56,9 @@ def __init__(self, obj: YAMLRoot, schemaview: SchemaView):
         self._root_object = obj
         self._schemaview = schemaview
         self._class_map = schemaview.class_name_mappings()
-        self._source_object_cache: Mapping[str, Any] = {}
-        self._proxy_object_cache: Mapping[str, ProxyObject] = {}
-        self._child_to_parent: Mapping[str, list[tuple[str, str]]] = {}
+        self._source_object_cache: MutableMapping[str, Any] = {}
+        self._proxy_object_cache: MutableMapping[str, ProxyObject] = {}
+        self._child_to_parent: MutableMapping[str, list[tuple[str, str]]] = {}
         self._index(obj)
 
     def _index(self, obj: Any, parent_key=None, parent=None):
@@ -70,16 +70,11 @@ def _index(self, obj: Any, parent_key=None, parent=None):
             return {k: self._index(v, parent_key, parent) for k, v in obj.items()}
         cls_name = type(obj).__name__
         if cls_name in self._class_map:
-            cls = self._class_map[cls_name]
             pk_val = self._key(obj)
             self._source_object_cache[pk_val] = obj
             if pk_val not in self._child_to_parent:
                 self._child_to_parent[pk_val] = []
             self._child_to_parent[pk_val].append((parent_key, parent))
-            # id_slot = self._schemaview.get_identifier_slot(cls.name)
-            # if id_slot:
-            #    id_val = getattr(obj, id_slot.name)
-            #    self._source_object_cache[(cls.name, id_val)] = obj
             for k, v in vars(obj).items():
                 self._index(v, k, obj)
         else:
@@ -115,7 +110,7 @@ def bless(self, obj: Any) -> "ProxyObject":
         else:
             return ProxyObject(obj, _db=self)
 
-    def _key(self, obj: Any) -> tuple[Union[str, YAMLRoot], str]:
+    def _key(self, obj: Any) -> tuple[str, str]:
         """
         Returns primary key value for this object.
 

linkml_runtime/loaders/rdf_loader.py

@@ -1,3 +1,4 @@
+import json
 from typing import Optional, TextIO, Union
 
 from hbreader import FileInfo
@@ -85,7 +86,7 @@ def loader(data: Union[str, dict], _: FileInfo) -> Optional[dict]:
 
         # If the input is a graph, convert it to JSON-LD
         if isinstance(source, Graph):
-            source = pyld_jsonld_from_rdflib_graph(source)
+            source = pyld_jsonld_from_rdflib_graph(source)  # noqa: F821 - no idea what this is
             jsonld_str = source.serialize(format="json-ld", indent=4)
             source = json.loads(jsonld_str)
             fmt = "json-ld"

linkml_runtime/loaders/rdflib_loader.py

@@ -55,7 +55,8 @@ def from_rdf_graph(
         :param schemaview: schema to which graph conforms
         :param target_class: class which root nodes should instantiate
         :param prefix_map: additional prefix mappings for data objects
-        :param ignore_unmapped_predicates: if True then a predicate that has no mapping to a slot does not raise an error
+        :param ignore_unmapped_predicates:
+            if True then a predicate that has no mapping to a slot does not raise an error
         :return: all instances of target class type
         """
         namespaces = schemaview.namespaces()
@@ -231,8 +232,7 @@ def _get_id_dict(self, node: VALID_SUBJECT, schemaview: SchemaView, cn: ClassDef
         id_slot = schemaview.get_identifier_slot(cn)
         if not isinstance(node, BNode):
             id_val = self._uri_to_id(node, id_slot, schemaview)
-            # id_val = schemaview.namespaces().curie_for(node)
-            if id_val == None:
+            if id_val is None:
                 id_val = str(node)
             return {id_slot.name: id_val}
         else:

linkml_runtime/processing/referencevalidator.py

@@ -667,7 +667,7 @@ def ensure_simple_dict(
     ) -> Any:
         simple_dict_value_slot = self._slot_as_simple_dict_value_slot(parent_slot)
         if not simple_dict_value_slot:
-            raise AssertionError(f"Should have simple dict slot valie: {parent_slot.name}")
+            raise AssertionError(f"Should have simple dict slot value: {parent_slot.name}")
         normalized_object = input_object
         if isinstance(input_object, list):
             normalized_object = {v[pk_slot_name]: v for v in input_object}

linkml_runtime/processing/validation_datamodel.py

@@ -405,7 +405,8 @@ class ConstraintType(EnumDefinitionImpl):
     )
     MinCountConstraint = PermissibleValue(
         text="MinCountConstraint",
-        description="cardinality constraint where the number of values of the slot must be greater or equal to a specified minimum",
+        description="cardinality constraint where the number of values of the slot must be greater than "
+        "or equal to a specified minimum",
         meaning=SH.MinCountConstraintComponent,
     )
     RequiredConstraint = PermissibleValue(
@@ -420,7 +421,8 @@ class ConstraintType(EnumDefinitionImpl):
     )
     MaxCountConstraint = PermissibleValue(
         text="MaxCountConstraint",
-        description="cardinality constraint where the number of values of the slot must be less than or equal to a specified maximum",
+        description="cardinality constraint where the number of values of the slot must be less than "
+        "or equal to a specified maximum",
         meaning=SH.MaxCountConstraintComponent,
     )
     SingleValuedConstraint = PermissibleValue(

linkml_runtime/utils/context_utils.py

@@ -1,11 +1,14 @@
 import json
 import os
 from io import TextIOWrapper
-from typing import Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
 
 import yaml
 from jsonasobj2 import JsonObj, loads
 
+if TYPE_CHECKING:
+    from linkml_runtime.utils.namespaces import Namespaces
+
 CONTEXT_TYPE = Union[str, dict, JsonObj]
 CONTEXTS_PARAM_TYPE = Optional[Union[CONTEXT_TYPE, list[CONTEXT_TYPE]]]
 

linkml_runtime/utils/enumerations.py

@@ -1,9 +1,12 @@
 from dataclasses import fields
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 from linkml_runtime.utils.metamodelcore import Curie
 from linkml_runtime.utils.yamlutils import YAMLRoot
 
+if TYPE_CHECKING:
+    from linkml_runtime.linkml_model import EnumDefinition, PermissibleValue
+
 
 class EnumDefinitionMeta(type):
     def __init__(cls, *args, **kwargs):

linkml_runtime/utils/eval_utils.py

@@ -24,7 +24,7 @@
 
 def eval_conditional(*conds: list[tuple[bool, Any]]) -> Any:
     """
-    Evaluate a collection of expression,value tuples, returing the first value whose expression is true
+    Evaluate a collection of expression, value tuples, returning the first value whose expression is true
 
     >>> x= 40
     >>> eval_conditional((x < 25, 'low'),  (x > 25, 'high'), (True, 'low'))

linkml_runtime/utils/formatutils.py

@@ -100,7 +100,7 @@ def wrapped_annotation(txt: str) -> str:
 def shex_results_as_string(rslts) -> str:
     """Pretty print ShEx Evaluation result"""
     # TODO: Add this method to ShEx itself
-    rval = [f"Evalutating: {str(rslts.focus)} against {str(rslts.start)}"]
+    rval = [f"Evaluating: {str(rslts.focus)} against {str(rslts.start)}"]
     if rslts.result:
         rval.append("Result: CONFORMS")
     else:
@@ -158,7 +158,7 @@ def remove_empty_items(obj: Any, hide_protected_keys: bool = False, inside: bool
         obj_list = [
             e
             for e in [
-                remove_empty_items(l, hide_protected_keys=hide_protected_keys, inside=True) for l in obj if l != "_root"
+                remove_empty_items(i, hide_protected_keys=hide_protected_keys, inside=True) for i in obj if i != "_root"
             ]
             if not is_empty(e)
         ]

linkml_runtime/utils/metamodelcore.py

@@ -13,14 +13,14 @@
 from linkml_runtime.utils.namespaces import Namespaces
 from linkml_runtime.utils.strictness import is_strict
 from linkml_runtime.utils.uri_validator import validate_curie, validate_uri, validate_uri_reference
+from linkml_runtime.utils.yamlutils import TypedNode
 
 # Reference Decimal to make sure it stays in the imports
 _z = Decimal(1)
 
 # ===========================
 # Fields for use in dataclass
 # ===========================
-from linkml_runtime.utils.yamlutils import TypedNode
 
 
 def empty_list():
@@ -233,13 +233,11 @@ def __new__(cls, value: Union[str, datetime.time, datetime.datetime, Literal]) -
             if not isinstance(value, datetime.time):
                 value = datetime.time.fromisoformat(value)
             return datetime.time.fromisoformat(str(value)).isoformat()
-        except TypeError:
-            pass
-        except ValueError:
-            pass
-        if not is_strict():
+        except (TypeError, ValueError):
+            if is_strict():
+                raise
+        finally:
             return str(value)
-        raise e
 
     @classmethod
     def is_valid(cls, value: Union[str, datetime.time, datetime.datetime, Literal]) -> bool:
@@ -266,13 +264,11 @@ def __new__(cls, value: Union[str, datetime.date, Literal]) -> str:
             if not isinstance(value, datetime.date):
                 value = datetime.date.fromisoformat(str(value))
             return value.isoformat()
-        except TypeError:
-            pass
-        except ValueError:
-            pass
-        if not is_strict():
+        except (TypeError, ValueError):
+            if is_strict():
+                raise
+        finally:
             return str(value)
-        raise e
 
     @classmethod
     def is_valid(cls, value: Union[str, datetime.date, Literal]) -> bool:
@@ -301,13 +297,11 @@ def __new__(cls, value: Union[str, datetime.datetime, Literal]) -> str:
             if not isinstance(value, datetime.datetime):
                 value = datetime.datetime.fromisoformat(value)  # Note that this handles non 'T' format as well
             return value.isoformat()
-        except TypeError:
-            pass
-        except ValueError:
-            pass
-        if not is_strict():
+        except (TypeError, ValueError):
+            if is_strict():
+                raise
+        finally:
             return str(value)
-        raise e
 
     @classmethod
     def is_valid(cls, value: Union[str, datetime.datetime, Literal]) -> bool: