Require Python 3.10 and support pytest 9

pytest 9.0.0 began requiring this version, so pytest-mypy-testing now
fails when targeting earlier versions.

This also requires mypy 1.17.0 in tests, due to
python/mypy#19179.

Author: cjwatson

.github/workflows/tests.yml

@@ -24,10 +24,8 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.9", "3.13", "3.14", "3.14t"]
+        python-version: ["3.10", "3.13", "3.14", "3.14t"]
         include:
-          - os: ubuntu-latest
-            python-version: "3.10"
           - os: ubuntu-latest
             python-version: "3.11"
           - os: ubuntu-latest

pyproject.toml

@@ -20,7 +20,7 @@ classifiers = [
     "Programming Language :: Python",
     "Typing :: Typed",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 dynamic = ["version"]
 
 [project.urls]
@@ -33,11 +33,11 @@ Tracker = "https://github.com/ipython/traitlets/issues"
 [project.optional-dependencies]
 test = [
     "argcomplete>=3.0.3",
-    "mypy>=1.7.0",
+    "mypy>=1.17.0",
     "pre-commit",
     "pytest-mock",
     "pytest-mypy-testing",
-    "pytest>=7.0,<8.2",
+    "pytest>=7.0,<10.0",
 ]
 docs = [
     "myst-parser",
@@ -86,7 +86,7 @@ build = [
 
 [tool.mypy]
 files = "traitlets"
-python_version = "3.9"
+python_version = "3.10"
 strict = true
 enable_error_code = ["ignore-without-code", "redundant-expr", "truthy-bool"]
 pretty = true

tests/test_typing.py

@@ -185,27 +185,27 @@ class T(HasTraits):
 
     t = T()
     reveal_type(
-        Unicode(  # R: traitlets.traitlets.Unicode[builtins.str, Union[builtins.str, builtins.bytes]]
+        Unicode(  # R: traitlets.traitlets.Unicode[builtins.str, builtins.str | builtins.bytes]
             "foo"
         )
     )
     reveal_type(
-        Unicode(  # R: traitlets.traitlets.Unicode[builtins.str, Union[builtins.str, builtins.bytes]]
+        Unicode(  # R: traitlets.traitlets.Unicode[builtins.str, builtins.str | builtins.bytes]
             ""
         ).tag(sync=True)
     )
     reveal_type(
-        Unicode(  # R: traitlets.traitlets.Unicode[Union[builtins.str, None], Union[builtins.str, builtins.bytes, None]]
+        Unicode(  # R: traitlets.traitlets.Unicode[builtins.str | None, builtins.str | builtins.bytes | None]
             None, allow_none=True
         )
     )
     reveal_type(
-        Unicode(  # R: traitlets.traitlets.Unicode[Union[builtins.str, None], Union[builtins.str, builtins.bytes, None]]
+        Unicode(  # R: traitlets.traitlets.Unicode[builtins.str | None, builtins.str | builtins.bytes | None]
             None, allow_none=True
         ).tag(sync=True)
     )
     reveal_type(
-        T.export_format  # R: traitlets.traitlets.Unicode[builtins.str, Union[builtins.str, builtins.bytes]]
+        T.export_format  # R: traitlets.traitlets.Unicode[builtins.str, builtins.str | builtins.bytes]
     )
     reveal_type(t.export_format)  # R: builtins.str
 
@@ -312,37 +312,37 @@ class T(HasTraits):
 
     t = T()
     reveal_type(
-        Bool(True)  # R: traitlets.traitlets.Bool[builtins.bool, Union[builtins.bool, builtins.int]]
+        Bool(True)  # R: traitlets.traitlets.Bool[builtins.bool, builtins.bool | builtins.int]
     )
     reveal_type(
-        Bool(  # R: traitlets.traitlets.Bool[builtins.bool, Union[builtins.bool, builtins.int]]
+        Bool(  # R: traitlets.traitlets.Bool[builtins.bool, builtins.bool | builtins.int]
             True
         ).tag(sync=True)
     )
     reveal_type(
-        Bool(  # R: traitlets.traitlets.Bool[Union[builtins.bool, None], Union[builtins.bool, builtins.int, None]]
+        Bool(  # R: traitlets.traitlets.Bool[builtins.bool | None, builtins.bool | builtins.int | None]
             None, allow_none=True
         )
     )
     reveal_type(
-        Bool(  # R: traitlets.traitlets.Bool[Union[builtins.bool, None], Union[builtins.bool, builtins.int, None]]
+        Bool(  # R: traitlets.traitlets.Bool[builtins.bool | None, builtins.bool | builtins.int | None]
             None, allow_none=True
         ).tag(sync=True)
     )
     reveal_type(
-        T.b  # R: traitlets.traitlets.Bool[builtins.bool, Union[builtins.bool, builtins.int]]
+        T.b  # R: traitlets.traitlets.Bool[builtins.bool, builtins.bool | builtins.int]
     )
     reveal_type(t.b)  # R: builtins.bool
-    reveal_type(t.ob)  # R: Union[builtins.bool, None]
+    reveal_type(t.ob)  # R: builtins.bool | None
     reveal_type(
-        T.b  # R: traitlets.traitlets.Bool[builtins.bool, Union[builtins.bool, builtins.int]]
+        T.b  # R: traitlets.traitlets.Bool[builtins.bool, builtins.bool | builtins.int]
     )
     reveal_type(
-        T.ob  # R: traitlets.traitlets.Bool[Union[builtins.bool, None], Union[builtins.bool, builtins.int, None]]
+        T.ob  # R: traitlets.traitlets.Bool[builtins.bool | None, builtins.bool | builtins.int | None]
     )
-    # we would expect this to be Optional[Union[bool, int]], but...
-    t.b = "foo"  # E: Incompatible types in assignment (expression has type "str", variable has type "Union[bool, int]")  [assignment]
-    t.b = None  # E: Incompatible types in assignment (expression has type "None", variable has type "Union[bool, int]")  [assignment]
+    # we would expect this to be bool | int | None, but...
+    t.b = "foo"  # E: Incompatible types in assignment (expression has type "str", variable has type "bool | int")  [assignment]
+    t.b = None  # E: Incompatible types in assignment (expression has type "None", variable has type "bool | int")  [assignment]
 
 
 @pytest.mark.mypy_testing
@@ -355,21 +355,21 @@ class T(HasTraits):
     reveal_type(Int(True))  # R: traitlets.traitlets.Int[builtins.int, builtins.int]
     reveal_type(Int(True).tag(sync=True))  # R: traitlets.traitlets.Int[builtins.int, builtins.int]
     reveal_type(
-        Int(  # R: traitlets.traitlets.Int[Union[builtins.int, None], Union[builtins.int, None]]
+        Int(  # R: traitlets.traitlets.Int[builtins.int | None, builtins.int | None]
             None, allow_none=True
         )
     )
     reveal_type(
-        Int(  # R: traitlets.traitlets.Int[Union[builtins.int, None], Union[builtins.int, None]]
+        Int(  # R: traitlets.traitlets.Int[builtins.int | None, builtins.int | None]
             None, allow_none=True
         ).tag(sync=True)
     )
     reveal_type(T.i)  # R: traitlets.traitlets.Int[builtins.int, builtins.int]
     reveal_type(t.i)  # R: builtins.int
-    reveal_type(t.oi)  # R: Union[builtins.int, None]
+    reveal_type(t.oi)  # R: builtins.int | None
     reveal_type(T.i)  # R: traitlets.traitlets.Int[builtins.int, builtins.int]
     reveal_type(
-        T.oi  # R: traitlets.traitlets.Int[Union[builtins.int, None], Union[builtins.int, None]]
+        T.oi  # R: traitlets.traitlets.Int[builtins.int | None, builtins.int | None]
     )
     t.i = "foo"  # E: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]
     t.i = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")  [assignment]
@@ -386,18 +386,18 @@ class T(HasTraits):
     reveal_type(CInt(42))  # R: traitlets.traitlets.CInt[builtins.int, Any]
     reveal_type(CInt(42).tag(sync=True))  # R: traitlets.traitlets.CInt[builtins.int, Any]
     reveal_type(
-        CInt(None, allow_none=True)  # R: traitlets.traitlets.CInt[Union[builtins.int, None], Any]
+        CInt(None, allow_none=True)  # R: traitlets.traitlets.CInt[builtins.int | None, Any]
     )
     reveal_type(
-        CInt(  # R: traitlets.traitlets.CInt[Union[builtins.int, None], Any]
+        CInt(  # R: traitlets.traitlets.CInt[builtins.int | None, Any]
             None, allow_none=True
         ).tag(sync=True)
     )
     reveal_type(T.i)  # R: traitlets.traitlets.CInt[builtins.int, Any]
     reveal_type(t.i)  # R: builtins.int
-    reveal_type(t.oi)  # R: Union[builtins.int, None]
+    reveal_type(t.oi)  # R: builtins.int | None
     reveal_type(T.i)  # R: traitlets.traitlets.CInt[builtins.int, Any]
-    reveal_type(T.oi)  # R: traitlets.traitlets.CInt[Union[builtins.int, None], Any]
+    reveal_type(T.oi)  # R: traitlets.traitlets.CInt[builtins.int | None, Any]
 
 
 @pytest.mark.mypy_testing
@@ -416,17 +416,17 @@ class T(HasTraits):
             sync=True
         )
     )
-    reveal_type(t.otcp)  # R: Union[tuple[builtins.str, builtins.int], None]
+    reveal_type(t.otcp)  # R: tuple[builtins.str, builtins.int] | None
     reveal_type(
-        T.otcp  # R: traitlets.traitlets.TCPAddress[Union[tuple[builtins.str, builtins.int], None], Union[tuple[builtins.str, builtins.int], None]]
+        T.otcp  # R: traitlets.traitlets.TCPAddress[tuple[builtins.str, builtins.int] | None, tuple[builtins.str, builtins.int] | None]
     )
     reveal_type(
-        T.otcp.tag(  # R: traitlets.traitlets.TCPAddress[Union[tuple[builtins.str, builtins.int], None], Union[tuple[builtins.str, builtins.int], None]]
+        T.otcp.tag(  # R: traitlets.traitlets.TCPAddress[tuple[builtins.str, builtins.int] | None, tuple[builtins.str, builtins.int] | None]
             sync=True
         )
     )
     t.tcp = "foo"  # E: Incompatible types in assignment (expression has type "str", variable has type "tuple[str, int]")  [assignment]
-    t.otcp = "foo"  # E: Incompatible types in assignment (expression has type "str", variable has type "Optional[tuple[str, int]]")  [assignment]
+    t.otcp = "foo"  # E: Incompatible types in assignment (expression has type "str", variable has type "tuple[str, int] | None")  [assignment]
     t.tcp = None  # E: Incompatible types in assignment (expression has type "None", variable has type "tuple[str, int]")  [assignment]
 
 
@@ -441,14 +441,14 @@ class T(HasTraits):
     reveal_type(t.inst)  # R: tests.test_typing.Foo
     reveal_type(T.inst)  # R: traitlets.traitlets.Instance[tests.test_typing.Foo]
     reveal_type(T.inst.tag(sync=True))  # R: traitlets.traitlets.Instance[tests.test_typing.Foo]
-    reveal_type(t.oinst)  # R: Union[tests.test_typing.Foo, None]
-    reveal_type(t.oinst_string)  # R: Union[Any, None]
-    reveal_type(T.oinst)  # R: traitlets.traitlets.Instance[Union[tests.test_typing.Foo, None]]
+    reveal_type(t.oinst)  # R: tests.test_typing.Foo | None
+    reveal_type(t.oinst_string)  # R: Any | None
+    reveal_type(T.oinst)  # R: traitlets.traitlets.Instance[tests.test_typing.Foo | None]
     reveal_type(
-        T.oinst.tag(  # R: traitlets.traitlets.Instance[Union[tests.test_typing.Foo, None]]
+        T.oinst.tag(  # R: traitlets.traitlets.Instance[tests.test_typing.Foo | None]
             sync=True
         )
     )
     t.inst = "foo"  # E: Incompatible types in assignment (expression has type "str", variable has type "Foo")  [assignment]
-    t.oinst = "foo"  # E: Incompatible types in assignment (expression has type "str", variable has type "Optional[Foo]")  [assignment]
+    t.oinst = "foo"  # E: Incompatible types in assignment (expression has type "str", variable has type "Foo | None")  [assignment]
     t.inst = None  # E: Incompatible types in assignment (expression has type "None", variable has type "Foo")  [assignment]