Removed Python<=3.10 support.

Author: noamkush

.github/workflows/python-test.yml

@@ -52,7 +52,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
         pydantic-version: ["1.10.*", "2.*"]
 
     services:

django_pydantic_field/compat/django.py

@@ -300,18 +300,13 @@ def serialize(self):
 if sys.version_info >= (3, 14):
     GenericAlias = types.GenericAlias
     GenericTypes: ty.Tuple[ty.Any, ...] = (GenericAlias, type(ty.List[int]), type(ty.List), ty.Union)
-elif sys.version_info >= (3, 9):
+else:
     GenericAlias = types.GenericAlias
     GenericTypes = (
         GenericAlias,
         type(ty.List[int]),
         type(ty.List),
     )
-else:
-    # types.GenericAlias is missing, meaning python version < 3.9,
-    # which has a different inheritance models for typed generics
-    GenericAlias = type(ty.List[int])  # noqa
-    GenericTypes = GenericAlias, type(ty.List)  # noqa
 
 
 # BaseContainerSerializer *must be* registered after all specialized container serializers
@@ -331,21 +326,22 @@ def serialize(self):
 MigrationWriter.register_serializer(ty._SpecialForm, TypingSerializer)  # type: ignore
 
 
-if sys.version_info >= (3, 10):
-    UnionType = types.UnionType
+UnionType = types.UnionType
+
 
-    class UnionTypeSerializer(BaseSerializer):
-        value: UnionType
+class UnionTypeSerializer(BaseSerializer):
+    value: UnionType
+
+    def serialize(self):
+        imports = set()
+        if isinstance(self.value, (type(ty.Union), types.UnionType)):  # type: ignore
+            imports.add("import typing")
 
-        def serialize(self):
-            imports = set()
-            if isinstance(self.value, (type(ty.Union), types.UnionType)):  # type: ignore
-                imports.add("import typing")
+        for arg in get_args(self.value):
+            _, arg_imports = serializer_factory(arg).serialize()
+            imports.update(arg_imports)
 
-            for arg in get_args(self.value):
-                _, arg_imports = serializer_factory(arg).serialize()
-                imports.update(arg_imports)
+        return repr(self.value), imports
 
-            return repr(self.value), imports
 
-    MigrationWriter.register_serializer(UnionType, UnionTypeSerializer)
+MigrationWriter.register_serializer(UnionType, UnionTypeSerializer)

django_pydantic_field/v2/utils.py

@@ -57,12 +57,5 @@ def get_origin_type(cls: type):
     return cls
 
 
-if sys.version_info >= (3, 9):
-
-    def evaluate_forward_ref(ref: ty.ForwardRef, ns: Mapping[str, ty.Any]) -> ty.Any:
-        return ref._evaluate(dict(ns), {}, recursive_guard=frozenset())
-
-else:
-
-    def evaluate_forward_ref(ref: ty.ForwardRef, ns: Mapping[str, ty.Any]) -> ty.Any:
-        return ref._evaluate(dict(ns), {})
+def evaluate_forward_ref(ref: ty.ForwardRef, ns: Mapping[str, ty.Any]) -> ty.Any:
+    return ref._evaluate(dict(ns), {}, recursive_guard=frozenset())

pyproject.toml

@@ -35,8 +35,6 @@ classifiers = [
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -74,8 +72,7 @@ test = [
     "syrupy>=3,<5",
 ]
 ci = [
-    'psycopg[binary]>=3.1,<4; python_version>="3.9"',
-    'psycopg2-binary>=2.7,<3; python_version<"3.9"',
+    'psycopg[binary]>=3.1,<4',
     "mysqlclient>=2.1",
 ]
 

tests/test_fields.py

@@ -147,7 +147,6 @@ def test_field_serialization(field):
     _test_field_serialization(field)
 
 
-@pytest.mark.skipif(sys.version_info < (3, 9), reason="Built-in type subscription supports only in 3.9+")
 @pytest.mark.parametrize(
     "field_factory",
     [
@@ -161,30 +160,11 @@ def test_field_builtin_annotations_serialization(field_factory):
     _test_field_serialization(field_factory())
 
 
-@pytest.mark.skipif(sys.version_info < (3, 10), reason="Union type syntax supported only in 3.10+")
 def test_field_union_type_serialization():
     field = fields.PydanticSchemaField(schema=(InnerSchema | None), null=True, default=None)
     _test_field_serialization(field)
 
 
-@pytest.mark.skipif(sys.version_info >= (3, 9), reason="Should test against builtin generic types")
-@pytest.mark.parametrize(
-    "field",
-    [
-        fields.PydanticSchemaField(schema=ty.List[InnerSchema], default=list),
-        fields.PydanticSchemaField(schema=ty.Dict[str, InnerSchema], default=dict),
-        fields.PydanticSchemaField(schema=ty.Sequence[InnerSchema], default=list),
-        fields.PydanticSchemaField(schema=ty.Mapping[str, InnerSchema], default=dict),
-    ],
-)
-def test_field_typing_annotations_serialization(field):
-    _test_field_serialization(field)
-
-
-@pytest.mark.skipif(
-    sys.version_info < (3, 9),
-    reason="Typing-to-builtin migrations is reasonable only on py >= 3.9",
-)
 @pytest.mark.parametrize(
     "old_field, new_field",
     [

tests/test_migration_serializers.py

@@ -17,27 +17,16 @@
 except ImportError:
     annotationlib = None
 
-if sys.version_info < (3, 9):
-    test_types = [
-        str,
-        list,
-        t.List[str],
-        t.Union[te.Literal["foo"], t.List[str]],
-        t.List[t.Union[int, bool]],
-        t.Tuple[t.List[te.Literal[1]], t.Union[str, te.Literal["foo"]]],
-        t.ForwardRef("str"),
-    ]
-else:
-    test_types = [
-        str,
-        list,
-        list[str],
-        t.Literal["foo"],
-        t.Union[t.Literal["foo"], list[str]],
-        list[t.Union[int, bool]],
-        tuple[list[t.Literal[1]], t.Union[str, t.Literal["foo"]]],
-        t.ForwardRef("str"),
-    ]
+test_types = [
+    str,
+    list,
+    list[str],
+    t.Literal["foo"],
+    t.Union[t.Literal["foo"], list[str]],
+    list[t.Union[int, bool]],
+    tuple[list[t.Literal[1]], t.Union[str, t.Literal["foo"]]],
+    t.ForwardRef("str"),
+]
 
 
 @pytest.mark.parametrize("raw_type", test_types)

tests/v1/test_base.py

@@ -107,7 +107,6 @@ def test_concrete_types(type_, encoded, decoded):
     assert decoder.decode(existing_encoded) == decoded
 
 
-@pytest.mark.skipif(sys.version_info < (3, 9), reason="Should test against builtin generic types")
 @pytest.mark.parametrize(
     "type_factory, encoded, decoded",
     [

tests/v2/test_types.py

@@ -1,29 +1,24 @@
-import sys
 import pydantic
 import pytest
 import typing as ty
 
 from ..conftest import InnerSchema, SampleDataclass
 
 types = pytest.importorskip("django_pydantic_field.v2.types")
-skip_unsupported_builtin_subscription = pytest.mark.skipif(
-    sys.version_info < (3, 9),
-    reason="Built-in type subscription supports only in 3.9+",
-)
 
 
 # fmt: off
 @pytest.mark.parametrize(
     "ctor, args, kwargs",
     [
-        pytest.param(types.SchemaAdapter, ["list[int]", None, None, None], {}, marks=skip_unsupported_builtin_subscription),
-        pytest.param(types.SchemaAdapter, ["list[int]", {"strict": True}, None, None], {}, marks=skip_unsupported_builtin_subscription),
+        pytest.param(types.SchemaAdapter, ["list[int]", None, None, None], {}),
+        pytest.param(types.SchemaAdapter, ["list[int]", {"strict": True}, None, None], {}),
         (types.SchemaAdapter, [ty.List[int], None, None, None], {}),
         (types.SchemaAdapter, [ty.List[int], {"strict": True}, None, None], {}),
         (types.SchemaAdapter, [None, None, InnerSchema, "stub_int"], {}),
         (types.SchemaAdapter, [None, None, SampleDataclass, "stub_int"], {}),
-        pytest.param(types.SchemaAdapter.from_type, ["list[int]"], {}, marks=skip_unsupported_builtin_subscription),
-        pytest.param(types.SchemaAdapter.from_type, ["list[int]", {"strict": True}], {}, marks=skip_unsupported_builtin_subscription),
+        pytest.param(types.SchemaAdapter.from_type, ["list[int]"], {}),
+        pytest.param(types.SchemaAdapter.from_type, ["list[int]", {"strict": True}], {}),
         (types.SchemaAdapter.from_type, [ty.List[int]], {}),
         (types.SchemaAdapter.from_type, [ty.List[int], {"strict": True}], {}),
         (types.SchemaAdapter.from_annotation, [InnerSchema, "stub_int"], {}),