Updated type annotations to match typeshed (#77)

agronholm · Aug 14, 2023 · 516ade1 · 516ade1
1 parent 8b8791b
commit 516ade1
Show file tree

Hide file tree

Showing 2 changed files with 77 additions and 29 deletions.
diff --git a/CHANGES.rst b/CHANGES.rst
@@ -4,13 +4,16 @@ Version history
 This library adheres to `Semantic Versioning 2.0 <http://semver.org/>`_.
 
 **UNRELEASED**
-- `catch()` now raises a `TypeError` if passed an async exception handler instead of
-  just giving a `RuntimeWarning` about the coroutine never being awaited. (#66, PR by
+
+- ``catch()`` now raises a ``TypeError`` if passed an async exception handler instead of
+  just giving a ``RuntimeWarning`` about the coroutine never being awaited. (#66, PR by
   John Litborn)
 - Fixed plain ``raise`` statement in an exception handler callback to work like a
   ``raise`` in an ``except*`` block
 - Fixed new exception group not being chained to the original exception when raising an
   exception group from exceptions raised in handler callbacks
+- Fixed type annotations of the ``derive()``, ``subgroup()`` and ``split()`` methods to
+  match the ones in typeshed
 
 **1.1.2**
 

diff --git a/src/exceptiongroup/_exceptions.py b/src/exceptiongroup/_exceptions.py
@@ -105,6 +105,12 @@ def exceptions(
     ) -> tuple[_BaseExceptionT_co | BaseExceptionGroup[_BaseExceptionT_co], ...]:
         return tuple(self._exceptions)
 
+    @overload
+    def subgroup(
+        self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+    ) -> ExceptionGroup[_ExceptionT] | None:
+        ...
+
     @overload
     def subgroup(
         self, __condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...]
@@ -113,16 +119,16 @@ def subgroup(
 
     @overload
     def subgroup(
-        self: Self, __condition: Callable[[_BaseExceptionT_co], bool]
-    ) -> Self | None:
+        self, __condition: Callable[[_BaseExceptionT_co | Self], bool]
+    ) -> BaseExceptionGroup[_BaseExceptionT_co] | None:
         ...
 
     def subgroup(
-        self: Self,
+        self,
         __condition: type[_BaseExceptionT]
         | tuple[type[_BaseExceptionT], ...]
-        | Callable[[_BaseExceptionT_co], bool],
-    ) -> BaseExceptionGroup[_BaseExceptionT] | Self | None:
+        | Callable[[_BaseExceptionT_co | Self], bool],
+    ) -> BaseExceptionGroup[_BaseExceptionT] | None:
         condition = get_condition_filter(__condition)
         modified = False
         if condition(self):
@@ -155,25 +161,49 @@ def subgroup(
 
     @overload
     def split(
-        self: Self,
-        __condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...],
-    ) -> tuple[BaseExceptionGroup[_BaseExceptionT] | None, Self | None]:
+        self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+    ) -> tuple[
+        ExceptionGroup[_ExceptionT] | None,
+        BaseExceptionGroup[_BaseExceptionT_co] | None,
+    ]:
         ...
 
     @overload
     def split(
-        self: Self, __condition: Callable[[_BaseExceptionT_co], bool]
-    ) -> tuple[Self | None, Self | None]:
+        self, __condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...]
+    ) -> tuple[
+        BaseExceptionGroup[_BaseExceptionT] | None,
+        BaseExceptionGroup[_BaseExceptionT_co] | None,
+    ]:
+        ...
+
+    @overload
+    def split(
+        self, __condition: Callable[[_BaseExceptionT_co | Self], bool]
+    ) -> tuple[
+        BaseExceptionGroup[_BaseExceptionT_co] | None,
+        BaseExceptionGroup[_BaseExceptionT_co] | None,
+    ]:
         ...
 
     def split(
-        self: Self,
+        self,
         __condition: type[_BaseExceptionT]
         | tuple[type[_BaseExceptionT], ...]
         | Callable[[_BaseExceptionT_co], bool],
     ) -> (
-        tuple[BaseExceptionGroup[_BaseExceptionT] | None, Self | None]
-        | tuple[Self | None, Self | None]
+        tuple[
+            ExceptionGroup[_ExceptionT] | None,
+            BaseExceptionGroup[_BaseExceptionT_co] | None,
+        ]
+        | tuple[
+            BaseExceptionGroup[_BaseExceptionT] | None,
+            BaseExceptionGroup[_BaseExceptionT_co] | None,
+        ]
+        | tuple[
+            BaseExceptionGroup[_BaseExceptionT_co] | None,
+            BaseExceptionGroup[_BaseExceptionT_co] | None,
+        ]
     ):
         condition = get_condition_filter(__condition)
         if condition(self):
@@ -210,7 +240,19 @@ def split(
 
         return matching_group, nonmatching_group
 
-    def derive(self: Self, __excs: Sequence[_BaseExceptionT_co]) -> Self:
+    @overload
+    def derive(self, __excs: Sequence[_ExceptionT]) -> ExceptionGroup[_ExceptionT]:
+        ...
+
+    @overload
+    def derive(
+        self, __excs: Sequence[_BaseExceptionT]
+    ) -> BaseExceptionGroup[_BaseExceptionT]:
+        ...
+
+    def derive(
+        self, __excs: Sequence[_BaseExceptionT]
+    ) -> BaseExceptionGroup[_BaseExceptionT]:
         eg = BaseExceptionGroup(self.message, __excs)
         if hasattr(self, "__notes__"):
             # Create a new list so that add_note() only affects one exceptiongroup
@@ -246,37 +288,40 @@ def subgroup(
 
         @overload
         def subgroup(
-            self: Self, __condition: Callable[[_ExceptionT_co], bool]
-        ) -> Self | None:
+            self, __condition: Callable[[_ExceptionT_co | Self], bool]
+        ) -> ExceptionGroup[_ExceptionT_co] | None:
             ...
 
         def subgroup(
-            self: Self,
+            self,
             __condition: type[_ExceptionT]
             | tuple[type[_ExceptionT], ...]
             | Callable[[_ExceptionT_co], bool],
-        ) -> ExceptionGroup[_ExceptionT] | Self | None:
+        ) -> ExceptionGroup[_ExceptionT] | None:
             return super().subgroup(__condition)
 
-        @overload  # type: ignore[override]
+        @overload
         def split(
-            self: Self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
-        ) -> tuple[ExceptionGroup[_ExceptionT] | None, Self | None]:
+            self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+        ) -> tuple[
+            ExceptionGroup[_ExceptionT] | None, ExceptionGroup[_ExceptionT_co] | None
+        ]:
             ...
 
         @overload
         def split(
-            self: Self, __condition: Callable[[_ExceptionT_co], bool]
-        ) -> tuple[Self | None, Self | None]:
+            self, __condition: Callable[[_ExceptionT_co | Self], bool]
+        ) -> tuple[
+            ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None
+        ]:
             ...
 
         def split(
             self: Self,
             __condition: type[_ExceptionT]
             | tuple[type[_ExceptionT], ...]
             | Callable[[_ExceptionT_co], bool],
-        ) -> (
-            tuple[ExceptionGroup[_ExceptionT] | None, Self | None]
-            | tuple[Self | None, Self | None]
-        ):
+        ) -> tuple[
+            ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None
+        ]:
             return super().split(__condition)