Drop support for Python 3.8

Author: mr-c

.github/workflows/ci-tests.yml

@@ -20,7 +20,7 @@ jobs:
     strategy:
       matrix:
         py-ver-major: [3]
-        py-ver-minor: [8, 9, 10, 11, 12, 13]
+        py-ver-minor: [9, 10, 11, 12, 13]
       fail-fast: false
 
     env:

CONTRIBUTING.md

@@ -1,5 +1,5 @@
 Style guide:
-- Python 3.8+ compatible code
+- Python 3.9+ compatible code
 - PEP-484 type hints
 - Prefer new style format strings https://pyformat.info/
 - Use ``make format`` to format your code
@@ -19,6 +19,6 @@ Here's a rough guide (improvements are welcome!)
 - Check the version which might be different from the version installed in general on any system: ``schema-salad-tool --version``
 - After you've made the changes, you can the complete test suite via tox: ``tox``
 	- If you want to run specific tests, say ``unit tests`` in Python 3.5, then: ``tox -e py35-unit``.
-	- Look at ``tox.ini`` for all available tests and runtimes
+	- Look at ``tox -l`` for all available tests and runtimes
 - If tests are passing, you can simply commit and create a PR on ``schema_salad`` repo:
 - After you're done working, you can deactivate the virtual environment: ``deactivate``

Makefile

@@ -205,7 +205,7 @@ bandit:
 	bandit --recursive --exclude schema_salad/tests/ schema_salad
 
 pyupgrade: $(filter-out schema_salad/metaschema.py,$(PYSOURCES))
-	pyupgrade --exit-zero-even-if-changed --py38-plus $^
+	pyupgrade --exit-zero-even-if-changed --py39-plus $^
 	auto-walrus $^
 
 release-test: FORCE

README.rst

@@ -23,7 +23,7 @@ generation, and transformation to RDF_. Salad provides a bridge
 between document and record oriented data modeling and the Semantic
 Web.
 
-The Schema Salad library is Python 3.8+ only.
+The Schema Salad library is Python 3.9+ only.
 
 Installation
 ------------

pyproject.toml

@@ -6,7 +6,6 @@ requires = [
     "black>=19.10b0,<23.12",
     "types-requests",
     "types-dataclasses",
-    "importlib_resources>=1.4;python_version<'3.9'",
     "ruamel.yaml>=0.17.6, < 0.19",
     "types-setuptools",
     "CacheControl[filecache] >= 0.13.1, < 0.15"
@@ -28,4 +27,4 @@ environment = { SCHEMA_SALAD_USE_MYPYC="1", MYPYPATH="$(pwd)/mypy-stubs" }
 
 [tool.black]
 line-length = 100
-target-version = [ "py38" ]
+target-version = [ "py39" ]

requirements.txt

@@ -5,4 +5,3 @@ mistune>=3,<3.1
 CacheControl[filecache]>= 0.11.7, < 0.15
 black>=19.10b0,<24.11
 mypy_extensions
-importlib_resources>=1.4;python_version<'3.9'

schema_salad/avro/schema.py

@@ -31,7 +31,7 @@
   A boolean; or
   Null.
 """
-from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from typing import Any, Optional, Union, cast
 
 from mypy_extensions import mypyc_attr
 
@@ -63,13 +63,13 @@
 # MappingDataType = Dict[str, Union[PropType, List[PropsType]]]
 # was: Union[str, MappingDataType, List[MappingDataType]]
 JsonDataType = Any
-AtomicPropType = Union[None, str, int, float, bool, "Schema", List[str], List["Field"]]
+AtomicPropType = Union[None, str, int, float, bool, "Schema", list[str], list["Field"]]
 PropType = Union[
     AtomicPropType,
-    Dict[str, AtomicPropType],
-    List[Dict[str, AtomicPropType]],
+    dict[str, AtomicPropType],
+    list[dict[str, AtomicPropType]],
 ]
-PropsType = Dict[str, PropType]
+PropsType = dict[str, PropType]
 
 FIELD_RESERVED_PROPS = ("default", "name", "doc", "order", "type")
 
@@ -189,7 +189,7 @@ class Names:
     """Track name set and default namespace during parsing."""
 
     def __init__(self, default_namespace: Optional[str] = None) -> None:
-        self.names: Dict[str, NamedSchema] = {}
+        self.names: dict[str, NamedSchema] = {}
         self.default_namespace = default_namespace
 
     def has_name(self, name_attr: str, space_attr: Optional[str]) -> bool:
@@ -281,7 +281,7 @@ def __init__(
         default: Optional[Any] = None,
         order: Optional[str] = None,
         names: Optional[Names] = None,
-        doc: Optional[Union[str, List[str]]] = None,
+        doc: Optional[Union[str, list[str]]] = None,
         other_props: Optional[PropsType] = None,
     ) -> None:
         # Ensure valid ctor args
@@ -361,9 +361,9 @@ def __init__(
         self,
         name: str,
         namespace: Optional[str],
-        symbols: List[str],
+        symbols: list[str],
         names: Optional[Names] = None,
-        doc: Optional[Union[str, List[str]]] = None,
+        doc: Optional[Union[str, list[str]]] = None,
         other_props: Optional[PropsType] = None,
     ) -> None:
         # Ensure valid ctor args
@@ -384,8 +384,8 @@ def __init__(
 
     # read-only properties
     @property
-    def symbols(self) -> List[str]:
-        return cast(List[str], self.get_prop("symbols"))
+    def symbols(self) -> list[str]:
+        return cast(list[str], self.get_prop("symbols"))
 
 
 #
@@ -473,7 +473,7 @@ def __init__(
         names: Names,
         name: str,
         namespace: Optional[str] = None,
-        doc: Optional[Union[str, List[str]]] = None,
+        doc: Optional[Union[str, list[str]]] = None,
         other_props: Optional[PropsType] = None,
     ) -> None:
         """Create a NamedMapSchema object."""
@@ -505,8 +505,8 @@ def values(self) -> Schema:
         return cast(Schema, self.get_prop("values"))
 
 
-def _build_schema_objects(schemas: List[JsonDataType], names: Names) -> List[Schema]:
-    schema_objects: List[Schema] = []
+def _build_schema_objects(schemas: list[JsonDataType], names: Names) -> list[Schema]:
+    schema_objects: list[Schema] = []
     for schema in schemas:
         if isinstance(schema, str) and names.has_name(schema, None):
             new_schema = cast(Schema, names.get_name(schema, None))
@@ -536,7 +536,7 @@ class UnionSchema(Schema):
 
     def __init__(
         self,
-        schemas: List[JsonDataType],
+        schemas: list[JsonDataType],
         names: Names,
     ) -> None:
         """
@@ -558,7 +558,7 @@ def __init__(
 
     # read-only properties
     @property
-    def schemas(self) -> List[Schema]:
+    def schemas(self) -> list[Schema]:
         """Avro schemas composing the Union type."""
         return self._schemas
 
@@ -568,11 +568,11 @@ class NamedUnionSchema(NamedSchema):
 
     def __init__(
         self,
-        schemas: List[JsonDataType],
+        schemas: list[JsonDataType],
         names: Names,
         name: str,
         namespace: Optional[str] = None,
-        doc: Optional[Union[str, List[str]]] = None,
+        doc: Optional[Union[str, list[str]]] = None,
     ):
         """
         Initialize a new NamedUnionSchema.
@@ -595,16 +595,16 @@ def __init__(
 
     # read-only properties
     @property
-    def schemas(self) -> List[Schema]:
+    def schemas(self) -> list[Schema]:
         return self._schemas
 
 
 class RecordSchema(NamedSchema):
     @staticmethod
-    def make_field_objects(field_data: List[PropsType], names: Names) -> List[Field]:
+    def make_field_objects(field_data: list[PropsType], names: Names) -> list[Field]:
         """We're going to need to make message parameters too."""
-        field_objects: List[Field] = []
-        parsed_fields: Dict[str, PropsType] = {}
+        field_objects: list[Field] = []
+        parsed_fields: dict[str, PropsType] = {}
         for field in field_data:
             if hasattr(field, "get") and callable(field.get):
                 atype = field.get("type")
@@ -622,7 +622,7 @@ def make_field_objects(field_data: List[PropsType], names: Names) -> List[Field]
                 doc = field.get("doc")
                 if not (doc is None or isinstance(doc, (list, str))):
                     raise SchemaParseException('"doc" must be a string, list of strings, or None')
-                doc = cast(Union[str, List[str], None], doc)
+                doc = cast(Union[str, list[str], None], doc)
                 other_props = get_other_props(field, FIELD_RESERVED_PROPS)
                 new_field = Field(atype, name, has_default, default, order, names, doc, other_props)
                 parsed_fields[new_field.name] = field
@@ -635,10 +635,10 @@ def __init__(
         self,
         name: str,
         namespace: Optional[str],
-        fields: List[PropsType],
+        fields: list[PropsType],
         names: Names,
         schema_type: str = "record",
-        doc: Optional[Union[str, List[str]]] = None,
+        doc: Optional[Union[str, list[str]]] = None,
         other_props: Optional[PropsType] = None,
     ) -> None:
         # Ensure valid ctor args
@@ -663,14 +663,14 @@ def __init__(
 
     # read-only properties
     @property
-    def fields(self) -> List[Field]:
-        return cast(List[Field], self.get_prop("fields"))
+    def fields(self) -> list[Field]:
+        return cast(list[Field], self.get_prop("fields"))
 
 
 #
 # Module Methods
 #
-def get_other_props(all_props: PropsType, reserved_props: Tuple[str, ...]) -> Optional[PropsType]:
+def get_other_props(all_props: PropsType, reserved_props: tuple[str, ...]) -> Optional[PropsType]:
     """
     Retrieve the non-reserved properties from a dictionary of properties.
 
@@ -690,7 +690,7 @@ def make_avsc_object(json_data: JsonDataType, names: Optional[Names] = None) ->
     if names is None:
         names = Names()
 
-    if isinstance(json_data, Dict) and json_data.get("name") == "org.w3id.cwl.salad.Any":
+    if isinstance(json_data, dict) and json_data.get("name") == "org.w3id.cwl.salad.Any":
         del names.names["org.w3id.cwl.salad.Any"]
     elif not names.has_name("org.w3id.cwl.salad.Any", None):
         EnumSchema("org.w3id.cwl.salad.Any", None, ["Any"], names=names)
@@ -723,15 +723,15 @@ def make_avsc_object(json_data: JsonDataType, names: Optional[Names] = None) ->
                     raise SchemaParseException(
                         f'"symbols" for type enum must be a list of strings: {json_data}'
                     )
-                symbols = cast(List[str], symbols)
+                symbols = cast(list[str], symbols)
                 return EnumSchema(name, namespace, symbols, names, doc, other_props)
             if atype in ["record", "error"]:
                 fields = json_data.get("fields", [])
                 if not isinstance(fields, list):
                     raise SchemaParseException(
                         f'"fields" for type {atype} must be a list of mappings: {json_data}'
                     )
-                fields = cast(List[PropsType], fields)
+                fields = cast(list[PropsType], fields)
                 return RecordSchema(name, namespace, fields, names, atype, doc, other_props)
             raise SchemaParseException(f"Unknown Named Type: {atype}")
         if atype in VALID_TYPES:
@@ -774,7 +774,7 @@ def make_avsc_object(json_data: JsonDataType, names: Optional[Names] = None) ->
     raise SchemaParseException(fail_msg)
 
 
-def is_subtype(types: Dict[str, Any], existing: PropType, new: PropType) -> bool:
+def is_subtype(types: dict[str, Any], existing: PropType, new: PropType) -> bool:
     """Check if a new type specification is compatible with an existing type spec."""
     if existing == new:
         return True
@@ -804,9 +804,9 @@ def is_subtype(types: Dict[str, Any], existing: PropType, new: PropType) -> bool
         if existing.get("type") == "enum" and new.get("type") == "enum":
             return is_subtype(types, existing["symbols"], new["symbols"])
         if existing.get("type") == "record" and new.get("type") == "record":
-            for new_field in cast(List[Dict[str, Any]], new["fields"]):
+            for new_field in cast(list[dict[str, Any]], new["fields"]):
                 new_field_missing = True
-                for existing_field in cast(List[Dict[str, Any]], existing["fields"]):
+                for existing_field in cast(list[dict[str, Any]], existing["fields"]):
                     if new_field["name"] == existing_field["name"]:
                         if not is_subtype(types, existing_field["type"], new_field["type"]):
                             return False

schema_salad/codegen.py

@@ -1,17 +1,9 @@
 """Generate language specific loaders for a particular SALAD schema."""
 
 import sys
+from collections.abc import MutableMapping, MutableSequence
 from io import TextIOWrapper
-from typing import (
-    Any,
-    Dict,
-    List,
-    MutableMapping,
-    MutableSequence,
-    Optional,
-    TextIO,
-    Union,
-)
+from typing import Any, Optional, TextIO, Union
 from urllib.parse import urlsplit
 
 from . import schema
@@ -32,14 +24,14 @@
 
 def codegen(
     lang: str,
-    i: List[Dict[str, str]],
-    schema_metadata: Dict[str, Any],
+    i: list[dict[str, str]],
+    schema_metadata: dict[str, Any],
     loader: Loader,
     target: Optional[str] = None,
     examples: Optional[str] = None,
     package: Optional[str] = None,
     copyright: Optional[str] = None,
-    spdx_copyright_text: Optional[List[str]] = None,
+    spdx_copyright_text: Optional[list[str]] = None,
     spdx_license_identifier: Optional[str] = None,
     parser_info: Optional[str] = None,
 ) -> None:

schema_salad/codegen_base.py

@@ -1,7 +1,8 @@
 """Base class for the generation of loaders from schema-salad definitions."""
 
 from collections import OrderedDict
-from typing import Any, Dict, List, MutableSequence, Optional, Set, Union
+from collections.abc import MutableSequence
+from typing import Any, Optional, Union
 
 
 class TypeDef:  # pylint: disable=too-few-public-methods
@@ -66,7 +67,7 @@ class CodeGenBase:
     def __init__(self) -> None:
         self.collected_types: OrderedDict[str, TypeDef] = OrderedDict()
         self.lazy_inits: OrderedDict[str, LazyInitDef] = OrderedDict()
-        self.vocab: Dict[str, str] = {}
+        self.vocab: dict[str, str] = {}
 
     def declare_type(self, declared_type: TypeDef) -> TypeDef:
         """Add this type to our collection, if needed."""
@@ -99,18 +100,18 @@ def begin_class(
         abstract: bool,
         field_names: MutableSequence[str],
         idfield: str,
-        optional_fields: Set[str],
+        optional_fields: set[str],
     ) -> None:
         """Produce the header for the given class."""
         raise NotImplementedError()
 
-    def end_class(self, classname: str, field_names: List[str]) -> None:
+    def end_class(self, classname: str, field_names: list[str]) -> None:
         """Signal that we are done with this class."""
         raise NotImplementedError()
 
     def type_loader(
         self,
-        type_declaration: Union[List[Any], Dict[str, Any]],
+        type_declaration: Union[list[Any], dict[str, Any]],
         container: Optional[str] = None,
         no_link_check: Optional[bool] = None,
     ) -> TypeDef: