Typing improvements

Author: timsavage

src/odin/codecs/toml_codec.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, Sequence, Type, Union
+from collections.abc import Sequence
 
 from odin import ResourceAdapter, resources
 from odin.exceptions import CodecDecodeError
@@ -21,10 +21,10 @@ def load(fp, resource=None, full_clean=True, default_to_not_supplied=False):
     """
     Load a resource from a TOML encoded file.
 
-    If a ``resource`` value is supplied it is used as the base resource for the supplied YAML. If one is not supplied a
-    resource type field ``$`` is used to obtain the type represented by the dictionary. A ``ValidationError`` will be
-    raised if either of these values are supplied and not compatible. It is valid for a type to be supplied in the file
-    to be a child object from within the inheritance tree.
+    If a ``resource`` value is supplied it is used as the base resource for the supplied YAML. If one is not
+    supplied, a resource type field ``$`` is used to obtain the type represented by the dictionary. A
+    ``ValidationError`` will be raised if either of these values are supplied and not compatible. It is valid for a
+    type to be supplied in the file to be a child object from within the inheritance tree.
 
     :param fp: a file pointer to read TOML data format.
     :param resource: A resource type, resource name or list of resources and names to use as the base for creating a
@@ -53,10 +53,10 @@ def load(fp, resource=None, full_clean=True, default_to_not_supplied=False):
 def loads(s, resource=None, full_clean=True, default_to_not_supplied=False):
     """Load a resource from a TOML encoded string.
 
-    If a ``resource`` value is supplied it is used as the base resource for the supplied YAML. If one is not supplied a
-    resource type field ``$`` is used to obtain the type represented by the dictionary. A ``ValidationError`` will be
-    raised if either of these values are supplied and not compatible. It is valid for a type to be supplied in the file
-    to be a child object from within the inheritance tree.
+    If a ``resource`` value is supplied it is used as the base resource for the supplied YAML. If one is not
+    supplied, a resource type field ``$`` is used to obtain the type represented by the dictionary. A
+    ``ValidationError`` will be raised if either of these values are supplied and not compatible. It is valid for a
+    type to be supplied in the file to be a child object from within the inheritance tree.
 
     :param s: a string containing TOML.
     :param resource: A resource type, resource name or list of resources and names to use as the base for creating a
@@ -90,7 +90,7 @@ def __init__(
         include_virtual_fields: bool = True,
         include_type_field: bool = True,
         *args,
-        **kwargs
+        **kwargs,
     ):
         super().__init__(*args, **kwargs)
         self.include_virtual_fields = include_virtual_fields
@@ -104,7 +104,7 @@ def resource_to_dict(self, v):
         return resource_dict
 
     def dump_value(self, v):
-        if isinstance(v, (ResourceBase, ResourceAdapter)):
+        if isinstance(v, ResourceBase | ResourceAdapter):
             resource_dict = self.resource_to_dict(v)
             return self.dump_inline_table(resource_dict)
 
@@ -113,21 +113,21 @@ def dump_value(self, v):
         return super().dump_value(v)
 
 
-RT = Union[
-    ResourceBase,
-    ResourceAdapter,
-    Sequence[ResourceBase],
-    Sequence[ResourceAdapter],
-    Dict,
-]
+RT = (
+    ResourceBase
+    | ResourceAdapter
+    | Sequence[ResourceBase]
+    | Sequence[ResourceAdapter]
+    | dict,
+)
 
 
 def dump(
     resource: RT,
     fp,
-    encoder: Optional[Type[OdinEncoder]] = None,
+    encoder: type[OdinEncoder] | None = None,
     include_virtual_fields: bool = True,
-    **kwargs
+    **kwargs,
 ):
     """Dump to a TOML encoded file.
 
@@ -139,17 +139,17 @@ def dump(
     """
     encoder = (encoder or OdinEncoder)(include_virtual_fields, **kwargs)
 
-    if isinstance(resource, (ResourceBase, ResourceAdapter)):
+    if isinstance(resource, ResourceBase | ResourceAdapter):
         resource = encoder.resource_to_dict(resource)
 
     toml.dump(resource, fp, encoder)
 
 
 def dumps(
     resource: RT,
-    encoder: Optional[Type[OdinEncoder]] = None,
+    encoder: type[OdinEncoder] | None = None,
     include_virtual_fields: bool = True,
-    **kwargs
+    **kwargs,
 ) -> str:
     """Dump to a TOML encoded file.
 
@@ -161,7 +161,7 @@ def dumps(
     """
     encoder = (encoder or OdinEncoder)(include_virtual_fields, **kwargs)
 
-    if isinstance(resource, (ResourceBase, ResourceAdapter)):
+    if isinstance(resource, ResourceBase | ResourceAdapter):
         resource = encoder.resource_to_dict(resource)
 
     return toml.dumps(resource, encoder)

src/odin/codecs/yaml_codec.py

@@ -1,6 +1,7 @@
 """Codec to load/save Yaml documents."""
+
 from io import StringIO
-from typing import TextIO, Union
+from typing import TextIO
 
 from odin import ResourceAdapter, bases, resources
 from odin.exceptions import CodecEncodeError
@@ -31,7 +32,7 @@ def __init__(
         include_virtual_fields: bool = True,
         include_type_field: bool = True,
         *args,
-        **kwargs
+        **kwargs,
     ):
         SafeDumper.__init__(self, stream, *args, **kwargs)
         self.include_virtual_fields = include_virtual_fields
@@ -51,17 +52,17 @@ def represent_resource(self, data):
 
 
 def load(
-    fp: Union[TextIO, str],
+    fp: TextIO | str,
     resource: resources.ResourceBase = None,
     full_clean: bool = True,
     default_to_not_supplied: bool = False,
 ):
     """Load a resource from a YAML encoded file.
 
-    If a ``resource`` value is supplied it is used as the base resource for the supplied YAML. I one is not supplied a
-    resource type field ``$`` is used to obtain the type represented by the dictionary. A ``ValidationError`` will be
-    raised if either of these values are supplied and not compatible. It is valid for a type to be supplied in the file
-    to be a child object from within the inheritance tree.
+    If a ``resource`` value is supplied it is used as the base resource for the supplied YAML. I one is not supplied
+    a resource type field ``$`` is used to obtain the type represented by the dictionary. A ``ValidationError`` will
+    be raised if either of these values are supplied and not compatible. It is valid for a type to be supplied in the
+    file to be a child object from within the inheritance tree.
 
     :param fp: a file pointer to read YAML data fromat.
     :param resource: A resource type, resource name or list of resources and names to use as the base for creating a

src/odin/contrib/geo/datatypes.py

@@ -1,10 +1,9 @@
 import math
-from typing import Tuple
 
 __all__ = ("latitude", "longitude", "latlng", "point")
 
 
-def to_dms(value: float, absolute: bool = False) -> Tuple[float, float, float]:
+def to_dms(value: float, absolute: bool = False) -> tuple[float, float, float]:
     """
     Split a float value into DMS (degree, minute, second) parts
 
@@ -22,7 +21,7 @@ def to_dms(value: float, absolute: bool = False) -> Tuple[float, float, float]:
     return (-degree if invert else degree), minute, second
 
 
-def to_dm(value: float, absolute: bool = False) -> Tuple[float, float]:
+def to_dm(value: float, absolute: bool = False) -> tuple[float, float]:
     """
     Split a float value into DM (degree, minute) parts
 
@@ -45,7 +44,7 @@ class latitude(float):  # NoQA
 
     def __new__(cls, x):
         lat = float.__new__(cls, x)
-        if lat > 90.0 or lat < -90.0:
+        if lat > 90.0 or lat < -90.0:  # noqa: PLR2004
             raise ValueError(f"not in range -90.0 -> 90.0: '{x}'")
         return lat
 
@@ -61,7 +60,7 @@ class longitude(float):  # NoQA
 
     def __new__(cls, x):
         lng = float.__new__(cls, x)
-        if lng > 180.0 or lng < -180.0:
+        if lng > 180.0 or lng < -180.0:  # noqa: PLR2004
             raise ValueError(f"not in range -180.0 -> 180.0: '{x}'")
         return lng
 
@@ -70,14 +69,12 @@ def __str__(self):
         return result + ("W" if self < 0 else "E")
 
 
-class latlng(tuple):
-    """
-    Combination latitude and longitude value.
-    """
+class latlng(tuple):  # noqa: N801 - This is for consistency
+    """Combination latitude and longitude value."""
 
     def __new__(cls, *args):
         # Unpack a tuple, list or latlng instance.
-        if len(args) == 1 and isinstance(args[0], (tuple, list)):
+        if len(args) == 1 and isinstance(args[0], tuple | list):
             args = args[0]
         try:
             lat, lng = args
@@ -100,13 +97,14 @@ def __str__(self):
         return "({}, {})".format(*self)
 
 
-class point(tuple):
-    """
-    A point in cartesian space. This type can be either 2D (on a plain) or 3D (includes a z-axis).
+class point(tuple):  # noqa: N801 - This is for consistency
+    """A point in cartesian space.
+
+    This type can be either 2D (on a plain) or 3D (includes a z-axis).
     """
 
     def __new__(cls, *args):
-        if len(args) == 1 and isinstance(args[0], (tuple, list)):
+        if len(args) == 1 and isinstance(args[0], tuple | list):
             args = args[0]
         if len(args) in (2, 3):
             return tuple.__new__(cls, (float(x) for x in args))
@@ -130,7 +128,7 @@ def z(self):
 
     @property
     def is_3d(self):
-        return len(self) == 3
+        return len(self) == 3  # noqa: PLR2004
 
     def __repr__(self):
         return ("point({}, {}, {})" if self.is_3d else "point({}, {})").format(*self)

src/odin/contrib/json_schema/__init__.py

@@ -1,6 +1,8 @@
 """JSON schema support for Odin."""
+
 import json
-from typing import Any, Dict, Final, List, Sequence, TextIO, Tuple, Type, Union
+from collections.abc import Sequence
+from typing import Any, Final, TextIO
 
 import odin
 import odin.validators
@@ -42,14 +44,14 @@ class JSONSchema:
     """JSON Schema representation of an Odin resource."""
 
     def __init__(
-        self, resource: Type[ResourceBase], *, require_type_field: bool = True
+        self, resource: type[ResourceBase], *, require_type_field: bool = True
     ):
         self.resource = resource
         self.require_type_field = require_type_field
 
         self.defs = {}
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert the schema to a dictionary."""
         meta = getmeta(self.resource)
 
@@ -62,7 +64,7 @@ def to_dict(self) -> Dict[str, Any]:
 
         return schema
 
-    def _resource_to_schema(self, meta: ResourceOptions) -> Dict[str, Any]:
+    def _resource_to_schema(self, meta: ResourceOptions) -> dict[str, Any]:
         """Convert a resource to a JSON schema."""
         schema = {
             "type": "object",
@@ -79,14 +81,14 @@ def _required_fields(self, meta: ResourceOptions) -> Sequence[str]:
             required.append(meta.type_field)
         return required
 
-    def _fields_to_properties(self, meta: ResourceOptions) -> Dict[str, Any]:
+    def _fields_to_properties(self, meta: ResourceOptions) -> dict[str, Any]:
         """Convert a set of fields to JSON schema properties."""
         properties = {meta.type_field: {"const": meta.resource_name}}
         for field in meta.fields:
             properties[field.name] = self._field_to_schema(field)
         return properties
 
-    def _field_to_schema(self, field: odin.Field) -> Dict[str, Any]:
+    def _field_to_schema(self, field: odin.Field) -> dict[str, Any]:
         """Convert a field to a JSON schema."""
         if isinstance(field, odin.CompositeField):
             schema = self._composite_field_to_schema(field)
@@ -103,9 +105,7 @@ def _field_to_schema(self, field: odin.Field) -> Dict[str, Any]:
 
         return schema
 
-    def _field_type(
-        self, field: odin.Field
-    ) -> Tuple[Union[str, List[str]], Dict[str, Any]]:
+    def _field_type(self, field: odin.Field) -> tuple[str | list[str], dict[str, Any]]:
         """Get the type of a field."""
 
         field_type = type(field)
@@ -139,7 +139,7 @@ def _field_type(
 
         return ([type_name, "null"] if field.null else type_name), schema
 
-    def _composite_field_to_schema(self, field: odin.CompositeField) -> Dict[str, Any]:
+    def _composite_field_to_schema(self, field: odin.CompositeField) -> dict[str, Any]:
         """Convert a composite field to a JSON schema."""
 
         # Handle abstract resources
@@ -165,7 +165,7 @@ def _composite_field_to_schema(self, field: odin.CompositeField) -> Dict[str, An
 
         return schema
 
-    def _schema_def(self, resource: Type[ResourceBase]) -> Dict[str, str]:
+    def _schema_def(self, resource: type[ResourceBase]) -> dict[str, str]:
         """Convert a resource to a JSON schema definition."""
         meta = getmeta(resource)
         ref = meta.resource_name
@@ -175,13 +175,13 @@ def _schema_def(self, resource: Type[ResourceBase]) -> Dict[str, str]:
         return {"$ref": f"#/$defs/{ref}"}
 
 
-def dumps(resource: Type[ResourceBase]) -> str:
+def dumps(resource: type[ResourceBase]) -> str:
     """Dump a JSON schema for the given resource."""
     schema = JSONSchema(resource).to_dict()
     return json.dumps(schema, indent=2)
 
 
-def dump(resource: Type[ResourceBase], fp: TextIO):
+def dump(resource: type[ResourceBase], fp: TextIO):
     """Dump a JSON schema for the given resource."""
     schema = JSONSchema(resource).to_dict()
     json.dump(schema, fp, indent=2)

src/odin/contrib/rich/theme.py

@@ -1,11 +1,10 @@
 """Rich Theme definition."""
-from typing import Dict
 
 from rich import get_console
 from rich.style import Style
 from rich.theme import Theme
 
-ODIN_STYLES: Dict[str, Style] = {
+ODIN_STYLES: dict[str, Style] = {
     "odin.resource.name": Style(color="bright_cyan"),
     "odin.resource.error": Style(color="red", underline=True),
     "odin.field.name": Style(color="bright_blue"),

src/odin/contrib/rich/validation_tree.py

@@ -1,5 +1,6 @@
 """Integration with Rich for nicer CLI's!"""
-from typing import Iterable, Union
+
+from collections.abc import Iterable
 
 from rich.tree import Tree
 
@@ -11,7 +12,7 @@ def _all_str(iterable: Iterable) -> bool:
     return all(isinstance(item, str) for item in iterable)
 
 
-def _validation_error_to_tree(error_messages: Union[list, dict], tree: Tree):
+def _validation_error_to_tree(error_messages: list | dict, tree: Tree):
     """Internal recursive method."""
 
     if isinstance(error_messages, dict):