feat: SigComparision -> SigPair

dol/signatures.py

@@ -712,7 +712,10 @@ def extract_arguments(
 
     if include_all_when_var_keywords_in_params:
         if (
-            next((p.name for p in params if p.kind == Parameter.VAR_KEYWORD), None,)
+            next(
+                (p.name for p in params if p.kind == Parameter.VAR_KEYWORD),
+                None,
+            )
             is not None
         ):
             param_kwargs.update(remaining_kwargs)
@@ -2945,7 +2948,9 @@ def extract_args_and_kwargs(
             ignore_kind=_ignore_kind,
         )
         return self.mk_args_and_kwargs(
-            arguments, allow_partial=_allow_partial, args_limit=_args_limit,
+            arguments,
+            allow_partial=_allow_partial,
+            args_limit=_args_limit,
         )
 
     def source_arguments(
@@ -3110,7 +3115,9 @@ def source_args_and_kwargs(
             **kwargs,
         )
         return self.mk_args_and_kwargs(
-            arguments, allow_partial=_allow_partial, args_limit=_args_limit,
+            arguments,
+            allow_partial=_allow_partial,
+            args_limit=_args_limit,
         )
 
 
@@ -4247,32 +4254,23 @@ def zip(*iterables):
         zip(*iterables) --> A zip object yielding tuples until an input is exhausted.
         """
 
-    def bool(x: Any, /) -> bool:
-        ...
+    def bool(x: Any, /) -> bool: ...
 
-    def bytearray(iterable_of_ints: Iterable[int], /):
-        ...
+    def bytearray(iterable_of_ints: Iterable[int], /): ...
 
-    def classmethod(function: Callable, /):
-        ...
+    def classmethod(function: Callable, /): ...
 
-    def int(x, base=10, /):
-        ...
+    def int(x, base=10, /): ...
 
-    def iter(callable: Callable, sentinel=None, /):
-        ...
+    def iter(callable: Callable, sentinel=None, /): ...
 
-    def next(iterator: Iterator, default=None, /):
-        ...
+    def next(iterator: Iterator, default=None, /): ...
 
-    def staticmethod(function: Callable, /):
-        ...
+    def staticmethod(function: Callable, /): ...
 
-    def str(bytes_or_buffer, encoding=None, errors=None, /):
-        ...
+    def str(bytes_or_buffer, encoding=None, errors=None, /): ...
 
-    def super(type_, obj=None, /):
-        ...
+    def super(type_, obj=None, /): ...
 
     # def type(name, bases=None, dict=None, /):
     #     ...
@@ -4442,14 +4440,11 @@ class sigs_for_type_name:
     signatures (through ``inspect.signature``),
     """
 
-    def itemgetter(iterable: Iterable[VT], /) -> Union[VT, Tuple[VT]]:
-        ...
+    def itemgetter(iterable: Iterable[VT], /) -> Union[VT, Tuple[VT]]: ...
 
-    def attrgetter(iterable: Iterable[VT], /) -> Union[VT, Tuple[VT]]:
-        ...
+    def attrgetter(iterable: Iterable[VT], /) -> Union[VT, Tuple[VT]]: ...
 
-    def methodcaller(obj: Any) -> Any:
-        ...
+    def methodcaller(obj: Any) -> Any: ...
 
 
 ############# Tools for testing #########################################################
@@ -4494,7 +4489,9 @@ def param_for_kind(
     lower_kind = kind.lower()
     setattr(param_for_kind, lower_kind, partial(param_for_kind, kind=kind))
     setattr(
-        param_for_kind, 'with_default', partial(param_for_kind, with_default=True),
+        param_for_kind,
+        'with_default',
+        partial(param_for_kind, with_default=True),
     )
     setattr(
         getattr(param_for_kind, lower_kind),
@@ -4546,7 +4543,10 @@ def mk_func_comparator_based_on_signature_comparator(
 
 
 def _keyed_comparator(
-    comparator: Comparator, key: KeyFunction, x: CT, y: CT,
+    comparator: Comparator,
+    key: KeyFunction,
+    x: CT,
+    y: CT,
 ) -> Comparison:
     """Apply a comparator after transforming inputs through a key function.
 
@@ -4560,7 +4560,10 @@ def _keyed_comparator(
     return comparator(key(x), key(y))
 
 
-def keyed_comparator(comparator: Comparator, key: KeyFunction,) -> Comparator:
+def keyed_comparator(
+    comparator: Comparator,
+    key: KeyFunction,
+) -> Comparator:
     """Create a key-function enabled binary operator.
 
     In various places in python functionality is extended by allowing a key function.
@@ -4922,7 +4925,7 @@ def validate_param_compatibility():
 
 
 @dataclass
-class SigComparison:
+class SigPair:
     """
     Class to compare two signatures.
 
@@ -4944,7 +4947,7 @@ def shared_names(self):
 
         >>> sig1 = Sig(lambda a, b, c: None)
         >>> sig2 = Sig(lambda b, c, d: None)
-        >>> comp = SigComparison(sig1, sig2)
+        >>> comp = SigPair(sig1, sig2)
         >>> comp.shared_names
         ['b', 'c']
         """
@@ -4957,7 +4960,7 @@ def names_missing_in_sig2(self):
 
         >>> sig1 = Sig(lambda a, b, c: None)
         >>> sig2 = Sig(lambda b, c, d: None)
-        >>> comp = SigComparison(sig1, sig2)
+        >>> comp = SigPair(sig1, sig2)
         >>> comp.names_missing_in_sig2
         ['a']
         """
@@ -4970,7 +4973,7 @@ def names_missing_in_sig1(self):
 
         >>> sig1 = Sig(lambda a, b, c: None)
         >>> sig2 = Sig(lambda b, c, d: None)
-        >>> comp = SigComparison(sig1, sig2)
+        >>> comp = SigPair(sig1, sig2)
         >>> comp.names_missing_in_sig1
         ['d']
         """
@@ -4987,19 +4990,23 @@ def are_call_compatible(
 
         >>> sig1 = Sig(lambda a, b, c=3: None)
         >>> sig2 = Sig(lambda a, b: None)
-        >>> comp = SigComparison(sig1, sig2)
+        >>> comp = SigPair(sig1, sig2)
         >>> comp.are_call_compatible()
         False
 
-        >>> comp = SigComparison(sig2, sig1)
+        >>> comp = SigPair(sig2, sig1)
         >>> comp.are_call_compatible()
         True
         """
         return is_call_compatible_with(
             self.sig1, self.sig2, param_comparator=param_comparator
         )
 
-    def param_comparison(self, comparator=param_comparator, aggregation=all,) -> bool:
+    def param_comparison(
+        self,
+        comparator=param_comparator,
+        aggregation=all,
+    ) -> bool:
         """
         Compare parameters between the two signatures using the provided comparator function.
 
@@ -5009,7 +5016,7 @@ def param_comparison(self, comparator=param_comparator, aggregation=all,) -> boo
 
         >>> sig1 = Sig('(a, b: int, c=3)')
         >>> sig2 = Sig('(a, *, b=2, d=4)')
-        >>> comp = SigComparison(sig1, sig2)
+        >>> comp = SigPair(sig1, sig2)
         >>> comp.param_comparison()
         False
         """
@@ -5027,7 +5034,7 @@ def param_differences(self) -> dict:
 
         >>> sig1 = Sig('(a, b: int, c=3)')
         >>> sig2 = Sig('(a, *, b=2, d=4)')
-        >>> comp = SigComparison(sig1, sig2)
+        >>> comp = SigPair(sig1, sig2)
         >>> result = comp.param_differences()
         >>> expected = {
         ...     'a': {},