Typing in tests.

Author: hunterhogan

.vscode/code-spell-dictionary-workspace.txt

@@ -1,24 +1,60 @@
 accountids
+addclass
+addmethod
+addpair
+addstatic
+addx
+aeiou
+alist
 arctan
 backgroundm
+badsubmodulename
+basestring
+BCDE
+blist
+cccbbbaaa
 ccount
 CIBUILDWHEEL
+classmethods
+cmap
+cmul
 comparables
 connectee
 Cython
 cythonization
 cythonize
 Dact
+doctests
+doesnot
 eehhhh
 embedsignature
 freethreading
 frozensets
+getzero
+indollars
+inspectbroken
 iseven
+juxtfunc
+Khhhaaaaannnnn
 kwdefaults
 leetspeak
 modname
+mycurry
+myfunc
+newdoc
+newmodule
+newparam
+newqualname
+oldd
+otherfunc
 Rocklin
+rsample
+sequenceiterator
+subclassable
+testlines
+tlzthisisabadname
 tobytes
 Transformee
 transformees
 Truncator
+unhash

humpy_toolz/tests/ruff.toml

@@ -0,0 +1,27 @@
+extend = "../../ruff.toml"
+
+[lint]
+ignore = [
+	"A004",
+	"B007",
+	"B018",
+	"B904",
+	"C410",
+	"E721",
+	"E731",
+	"EM101",
+	"F841",
+	"PIE807",
+	"PLC0415",
+	"PLW0108",
+	"RUF005",
+	"S102",
+	"S301",
+	"S311",
+	"SIM201",
+	"SIM202",
+	"SLF001",
+	"TC003",
+	"UP031",
+	"UP034",
+]

humpy_toolz/tests/test_curried.py

@@ -5,41 +5,41 @@
 import humpy_toolz
 import humpy_toolz.curried
 
-def test_take():
+def test_take() -> None:
     assert list(take(2)([1, 2, 3])) == [1, 2]
 
-def test_first():
+def test_first() -> None:
     assert first is humpy_toolz.itertoolz.first
 
-def test_merge():
+def test_merge() -> None:
     assert merge(factory=lambda: defaultdict(int))({1: 1}) == {1: 1}
     assert merge({1: 1}) == {1: 1}
     assert merge({1: 1}, factory=lambda: defaultdict(int)) == {1: 1}
 
-def test_merge_with():
+def test_merge_with() -> None:
     assert merge_with(sum)({1: 1}, {1: 2}) == {1: 3}
 
-def test_merge_with_list():
+def test_merge_with_list() -> None:
     assert merge_with(sum, [{'a': 1}, {'a': 2}]) == {'a': 3}
 
-def test_sorted():
+def test_sorted() -> None:
     assert sorted(key=second)([(1, 2), (2, 1)]) == [(2, 1), (1, 2)]
 
-def test_reduce():
+def test_reduce() -> None:
     assert reduce(add)((1, 2, 3)) == 6
 
-def test_module_name():
+def test_module_name() -> None:
     assert humpy_toolz.curried.__name__ == 'humpy_toolz.curried'
 
-def should_curry(func):
+def should_curry(func: object) -> bool:
     if not callable(func) or isinstance(func, humpy_toolz.curry):
         return False
     nargs = humpy_toolz.functoolz.num_required_args(func)
     if nargs is None or nargs > 1:
         return True
     return nargs == 1 and humpy_toolz.functoolz.has_keywords(func)
 
-def test_curried_operator():
+def test_curried_operator() -> None:
     import operator
     for k, v in vars(cop).items():
         if not callable(v):
@@ -54,11 +54,11 @@ def test_curried_operator():
                     pass
                 else:
                     continue
-                raise AssertionError('toolz.curried.operator.%s is not curried!' % k)
+                raise AssertionError('humpy_toolz.curried.operator.%s is not curried!' % k)
         assert should_curry(getattr(operator, k)) == isinstance(v, humpy_toolz.curry), k
     assert len(set(vars(cop)) & {'add', 'sub', 'mul'}) == 3
 
-def test_curried_namespace():
+def test_curried_namespace() -> None:
     exceptions = import_module('humpy_toolz.curried.exceptions')
     namespace = {}
 

humpy_toolz/tests/test_curried_doctests.py

@@ -1,7 +1,7 @@
 import doctest
 import humpy_toolz
 
-def test_doctests():
+def test_doctests() -> None:
     humpy_toolz.__test__ = {}
     for name, func in vars(humpy_toolz).items():
         if isinstance(func, humpy_toolz.curry):

humpy_toolz/tests/test_dicttoolz.py

@@ -1,15 +1,16 @@
 from collections import defaultdict as _defaultdict
-from collections.abc import Mapping
+from collections.abc import Callable, ItemsView, Iterator, KeysView, Mapping, ValuesView
 from humpy_toolz.dicttoolz import (
 	assoc, assoc_in, dissoc, itemfilter, itemmap, keyfilter, keymap, merge, merge_with, update_in, valfilter, valmap)
 from humpy_toolz.functoolz import identity
 from humpy_toolz.utils import raises
+from typing import Any, ClassVar
 import os
 
-def inc(x):
+def inc(x: int) -> int:
     return x + 1
 
-def iseven(i):
+def iseven(i: int) -> bool:
     return i % 2 == 0
 
 class TestDict:
@@ -19,18 +20,18 @@ class TestDict:
         D: callable that inputs a dict and creates or returns a MutableMapping
         kw: kwargs dict to specify "factory" keyword (if applicable)
     """
-    D = dict
-    kw = {}
+    D: ClassVar[Callable[..., Any]] = dict
+    kw: ClassVar[dict[str, Any]] = {}
 
-    def test_merge(self):
+    def test_merge(self) -> None:
         D, kw = (self.D, self.kw)
         assert merge(D({1: 1, 2: 2}), D({3: 4}), **kw) == D({1: 1, 2: 2, 3: 4})
 
-    def test_merge_iterable_arg(self):
+    def test_merge_iterable_arg(self) -> None:
         D, kw = (self.D, self.kw)
         assert merge([D({1: 1, 2: 2}), D({3: 4})], **kw) == D({1: 1, 2: 2, 3: 4})
 
-    def test_merge_with(self):
+    def test_merge_with(self) -> None:
         D, kw = (self.D, self.kw)
         dicts = (D({1: 1, 2: 2}), D({1: 10, 2: 20}))
         assert merge_with(sum, *dicts, **kw) == D({1: 11, 2: 22})
@@ -40,39 +41,39 @@ def test_merge_with(self):
         assert merge_with(tuple, *dicts, **kw) == D({1: (1, 10), 2: (2, 20), 3: (3,)})
         assert not merge_with(sum)
 
-    def test_merge_with_iterable_arg(self):
+    def test_merge_with_iterable_arg(self) -> None:
         D, kw = (self.D, self.kw)
         dicts = (D({1: 1, 2: 2}), D({1: 10, 2: 20}))
         assert merge_with(sum, *dicts, **kw) == D({1: 11, 2: 22})
         assert merge_with(sum, dicts, **kw) == D({1: 11, 2: 22})
         assert merge_with(sum, iter(dicts), **kw) == D({1: 11, 2: 22})
 
-    def test_valmap(self):
+    def test_valmap(self) -> None:
         D, kw = (self.D, self.kw)
         assert valmap(inc, D({1: 1, 2: 2}), **kw) == D({1: 2, 2: 3})
 
-    def test_keymap(self):
+    def test_keymap(self) -> None:
         D, kw = (self.D, self.kw)
         assert keymap(inc, D({1: 1, 2: 2}), **kw) == D({2: 1, 3: 2})
 
-    def test_itemmap(self):
+    def test_itemmap(self) -> None:
         D, kw = (self.D, self.kw)
         assert itemmap(reversed, D({1: 2, 2: 4}), **kw) == D({2: 1, 4: 2})
 
-    def test_valfilter(self):
+    def test_valfilter(self) -> None:
         D, kw = (self.D, self.kw)
         assert valfilter(iseven, D({1: 2, 2: 3}), **kw) == D({1: 2})
 
-    def test_keyfilter(self):
+    def test_keyfilter(self) -> None:
         D, kw = (self.D, self.kw)
         assert keyfilter(iseven, D({1: 2, 2: 3}), **kw) == D({2: 3})
 
-    def test_itemfilter(self):
+    def test_itemfilter(self) -> None:
         D, kw = (self.D, self.kw)
         assert itemfilter(lambda item: iseven(item[0]), D({1: 2, 2: 3}), **kw) == D({2: 3})
         assert itemfilter(lambda item: iseven(item[1]), D({1: 2, 2: 3}), **kw) == D({1: 2})
 
-    def test_assoc(self):
+    def test_assoc(self) -> None:
         D, kw = (self.D, self.kw)
         assert assoc(D({}), 'a', 1, **kw) == D({'a': 1})
         assert assoc(D({'a': 1}), 'a', 3, **kw) == D({'a': 3})
@@ -82,7 +83,7 @@ def test_assoc(self):
         assoc(d, 'x', 2, **kw)
         assert d is oldd
 
-    def test_dissoc(self):
+    def test_dissoc(self) -> None:
         D, kw = (self.D, self.kw)
         assert dissoc(D({'a': 1}), 'a', **kw) == D({})
         assert dissoc(D({'a': 1, 'b': 2}), 'a', **kw) == D({'b': 2})
@@ -95,7 +96,7 @@ def test_dissoc(self):
         assert d is oldd
         assert d2 is not oldd
 
-    def test_assoc_in(self):
+    def test_assoc_in(self) -> None:
         D, kw = (self.D, self.kw)
         assert assoc_in(D({'a': 1}), ['a'], 2, **kw) == D({'a': 2})
         assert assoc_in(D({'a': D({'b': 1})}), ['a', 'b'], 2, **kw) == D({'a': D({'b': 2})})
@@ -106,7 +107,7 @@ def test_assoc_in(self):
         assert d is oldd
         assert d2 is not oldd
 
-    def test_update_in(self):
+    def test_update_in(self) -> None:
         D, kw = (self.D, self.kw)
         assert update_in(D({'a': 0}), ['a'], inc, **kw) == D({'a': 1})
         assert update_in(D({'a': 0, 'b': 1}), ['b'], str, **kw) == D({'a': 0, 'b': '1'})
@@ -122,7 +123,7 @@ def test_update_in(self):
         update_in(d, ['x'], inc, **kw)
         assert d is oldd
 
-    def test_factory(self):
+    def test_factory(self) -> None:
         D, kw = (self.D, self.kw)
         assert merge(defaultdict(int, D({1: 2})), D({2: 3})) == {1: 2, 2: 3}
         assert merge(defaultdict(int, D({1: 2})), D({2: 3}), factory=lambda: defaultdict(int)) == defaultdict(int, D({1: 2, 2: 3}))
@@ -131,7 +132,7 @@ def test_factory(self):
 
 class defaultdict(_defaultdict):
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return super().__eq__(other) and isinstance(other, _defaultdict) and (self.default_factory == other.default_factory)
 
 class TestDefaultDict(TestDict):
@@ -143,50 +144,50 @@ class TestDefaultDict(TestDict):
     """
 
     @staticmethod
-    def D(dict_):
+    def D(dict_: dict[Any, Any]) -> defaultdict:
         return defaultdict(int, dict_)
     kw = {'factory': lambda: defaultdict(int)}
 
 class CustomMapping:
     """Define methods of the MutableMapping protocol required by dicttoolz"""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         self._d = dict(*args, **kwargs)
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: Any) -> Any:
         return self._d[key]
 
-    def __setitem__(self, key, val):
+    def __setitem__(self, key: Any, val: Any) -> None:
         self._d[key] = val
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: Any) -> None:
         del self._d[key]
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Any]:
         return iter(self._d)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._d)
 
-    def __contains__(self, key):
+    def __contains__(self, key: object) -> bool:
         return key in self._d
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return isinstance(other, CustomMapping) and self._d == other._d
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return not isinstance(other, CustomMapping) or self._d != other._d
 
-    def keys(self):
+    def keys(self) -> KeysView[Any]:
         return self._d.keys()
 
-    def values(self):
+    def values(self) -> ValuesView[Any]:
         return self._d.values()
 
-    def items(self):
+    def items(self) -> ItemsView[Any, Any]:
         return self._d.items()
 
-    def update(self, *args, **kwargs):
+    def update(self, *args: Any, **kwargs: Any) -> None:
         self._d.update(*args, **kwargs)
 
 class TestCustomMapping(TestDict):
@@ -199,25 +200,25 @@ class TestCustomMapping(TestDict):
     D = CustomMapping
     kw = {'factory': lambda: CustomMapping()}
 
-def test_environ():
+def test_environ() -> None:
     assert keymap(identity, os.environ) == os.environ
     assert valmap(identity, os.environ) == os.environ
     assert itemmap(identity, os.environ) == os.environ
 
-def test_merge_with_non_dict_mappings():
+def test_merge_with_non_dict_mappings() -> None:
 
     class Foo(Mapping):
 
-        def __init__(self, d):
+        def __init__(self, d: dict[Any, Any]) -> None:
             self.d = d
 
-        def __iter__(self):
+        def __iter__(self) -> Iterator[Any]:
             return iter(self.d)
 
-        def __getitem__(self, key):
+        def __getitem__(self, key: Any) -> Any:
             return self.d[key]
 
-        def __len__(self):
+        def __len__(self) -> int:
             return len(self.d)
     d = Foo({1: 1})
     assert merge(d) is d or merge(d) == {1: 1}