Fix CI (docs build, mypy tests, downstream) (#943)

Co-authored-by: krassowski <5832902+krassowski@users.noreply.github.com>

Author: Carreau

.github/workflows/downstream.yml

@@ -19,7 +19,7 @@ jobs:
       - uses: jupyterlab/maintainer-tools/.github/actions/downstream-test@v1
         with:
           package_name: ipython
-          package_spec: -e ".[test]"
+          package_spec: -e .[test]
 
   nbconvert:
     runs-on: ubuntu-latest
@@ -30,7 +30,7 @@ jobs:
       - uses: jupyterlab/maintainer-tools/.github/actions/downstream-test@v1
         with:
           package_name: nbconvert
-          package_spec: -e ".[test]"
+          package_spec: -e .[test]
 
   jupyter_server:
     runs-on: ubuntu-latest

.github/workflows/tests.yml

@@ -31,7 +31,7 @@ jobs:
           - os: ubuntu-latest
             python-version: "3.12"
           - os: ubuntu-latest
-            python-version: "pypy-3.10"
+            python-version: "pypy-3.11"
 
     steps:
       - uses: actions/checkout@v4

pyproject.toml

@@ -33,9 +33,11 @@ Tracker = "https://github.com/ipython/traitlets/issues"
 [project.optional-dependencies]
 test = [
     "argcomplete>=3.0.3",
-    "mypy>=1.7.0",
-    # see https://github.com/python/mypy/issues/20454
-    "mypy>=1.7.0,<1.19 ; platform_python_implementation == 'PyPy'",
+    # See https://github.com/python/mypy/issues/20329 for PyPy support issue.
+    # Also, test assertions will need to be updated for 1.20+ because
+    # `reveal_type()` representations were simplified in
+    # https://github.com/python/mypy/pull/20929
+    "mypy>=1.17.0,<1.19",
     "pre-commit",
     "pytest-mock",
     "pytest-mypy-testing",
@@ -88,7 +90,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 Optional[bool | int], 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]

traitlets/config/application.py

@@ -216,7 +216,7 @@ def _classes_inc_parents(
 
     log_datefmt = Unicode(
         "%Y-%m-%d %H:%M:%S",
-        help="The date format used by logging formatters for `asctime`",
+        help="The date format used by logging formatters for `logging.Formatter` ``datefmt`` parameter",
     ).tag(config=True)
 
     log_format = Unicode(