unnecessarily strict return types

Author: max-muoto

stdlib/@tests/test_cases/sqlite3/check_aggregations.py

@@ -75,6 +75,48 @@ def finalize(self) -> int:
 con.create_aggregate("sumint", 1, WindowSumIntMultiArgs)
 con.create_aggregate("sumint", 2, WindowSumIntMultiArgs)
 
+# n_arg=-1 requires *args to handle any number of arguments
+if sys.version_info >= (3, 11):
+    con.create_window_function("sumint_varargs", -1, WindowSumIntMultiArgs)
+
+con.create_aggregate("sumint_varargs", -1, WindowSumIntMultiArgs)
+
+
+# n_arg=-1 should reject fixed-arity methods
+class FixedArityAggregate:
+    def __init__(self) -> None:
+        self.total = 0
+
+    def step(self, a: int, b: int) -> None:
+        self.total += a + b
+
+    def finalize(self) -> int:
+        return self.total
+
+
+con.create_aggregate("bad_varargs", -1, FixedArityAggregate)  # type: ignore[arg-type]
+
+
+class FixedArityWindowAggregate:
+    def __init__(self) -> None:
+        self.total = 0
+
+    def step(self, a: int, b: int) -> None:
+        self.total += a + b
+
+    def inverse(self, a: int, b: int) -> None:
+        self.total -= a + b
+
+    def value(self) -> int:
+        return self.total
+
+    def finalize(self) -> int:
+        return self.total
+
+
+if sys.version_info >= (3, 11):
+    con.create_window_function("bad_varargs", -1, FixedArityWindowAggregate)  # type: ignore[arg-type]
+
 
 # Test case: Fixed parameter aggregates (the common case in practice)
 class FixedTwoParamAggregate:

stdlib/sqlite3/__init__.pyi

@@ -217,6 +217,8 @@ if sys.version_info < (3, 10):
 _CursorT = TypeVar("_CursorT", bound=Cursor)
 _SqliteData: TypeAlias = str | ReadableBuffer | int | float | None
 _SQLType = TypeVar("_SQLType", bound=_SqliteData)
+_SQLType_contra = TypeVar("_SQLType_contra", bound=_SqliteData, contravariant=True)
+
 # Data that is passed through adapters can be of any type accepted by an adapter.
 _AdaptedInputData: TypeAlias = _SqliteData | Any
 # The Mapping must really be a dict, but making it invariant is too annoying.
@@ -226,9 +228,9 @@ _IsolationLevel: TypeAlias = Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | Non
 _RowFactoryOptions: TypeAlias = type[Row] | Callable[[Cursor, Row], object] | None
 
 @type_check_only
-class _SingleParamAggregateProtocol(Protocol[_SQLType]):
-    def step(self, param: _SQLType, /) -> object: ...
-    def finalize(self) -> _SQLType: ...
+class _SingleParamAggregateProtocol(Protocol):
+    def step(self, param: _SqliteData, /) -> object: ...
+    def finalize(self) -> _SqliteData: ...
 
 @type_check_only
 class _AnyParamAggregateProtocol(Protocol):
@@ -237,11 +239,16 @@ class _AnyParamAggregateProtocol(Protocol):
     def finalize(self) -> _SqliteData: ...
 
 @type_check_only
-class _SingleParamWindowAggregateClass(Protocol[_SQLType]):
-    def step(self, param: _SQLType, /) -> object: ...
-    def inverse(self, param: _SQLType, /) -> object: ...
-    def value(self) -> _SQLType: ...
-    def finalize(self) -> _SQLType: ...
+class _AnyArgsAggregateProtocol(Protocol):
+    def step(self, *args: _SqliteData) -> object: ...
+    def finalize(self) -> _SqliteData: ...
+
+@type_check_only
+class _SingleParamWindowAggregateClass(Protocol[_SQLType_contra]):
+    def step(self, param: _SQLType_contra, /) -> object: ...
+    def inverse(self, param: _SQLType_contra, /) -> object: ...
+    def value(self) -> _SqliteData: ...
+    def finalize(self) -> _SqliteData: ...
 
 @type_check_only
 class _AnyParamWindowAggregateClass(Protocol):
@@ -252,6 +259,13 @@ class _AnyParamWindowAggregateClass(Protocol):
     def value(self) -> _SqliteData: ...
     def finalize(self) -> _SqliteData: ...
 
+@type_check_only
+class _AnyArgsWindowAggregateClass(Protocol):
+    def step(self, *args: _SqliteData) -> object: ...
+    def inverse(self, *args: _SqliteData) -> object: ...
+    def value(self) -> _SqliteData: ...
+    def finalize(self) -> _SqliteData: ...
+
 # These classes are implemented in the C module _sqlite3. At runtime, they're imported
 # from there into sqlite3.dbapi2 and from that module to here. However, they
 # consider themselves to live in the sqlite3.* namespace, so we'll define them here.
@@ -338,7 +352,11 @@ class Connection:
     def commit(self) -> None: ...
     @overload
     def create_aggregate(
-        self, name: str, n_arg: Literal[1], aggregate_class: Callable[[], _SingleParamAggregateProtocol[_SQLType]]
+        self, name: str, n_arg: Literal[1], aggregate_class: Callable[[], _SingleParamAggregateProtocol]
+    ) -> None: ...
+    @overload
+    def create_aggregate(
+        self, name: str, n_arg: Literal[-1], aggregate_class: Callable[[], _AnyArgsAggregateProtocol]
     ) -> None: ...
     @overload
     def create_aggregate(self, name: str, n_arg: int, aggregate_class: Callable[[], _AnyParamAggregateProtocol]) -> None: ...
@@ -351,7 +369,15 @@ class Connection:
             self,
             name: str,
             num_params: Literal[1],
-            aggregate_class: Callable[[], _SingleParamWindowAggregateClass[_SQLType]] | None,
+            aggregate_class: Callable[[], _SingleParamWindowAggregateClass[_SQLType_contra]] | None,
+            /,
+        ) -> None: ...
+        @overload
+        def create_window_function(
+            self,
+            name: str,
+            num_params: Literal[-1],
+            aggregate_class: Callable[[], _AnyArgsWindowAggregateClass] | None,
             /,
         ) -> None: ...
         @overload