Repository: dgilland/pydash (language: python)

Issue:
Use ruff
Would you be open for a PR switching all the lint and formatting tools to use [ruff](https://github.com/astral-sh/ruff) instead?

It does what `flake8`, `pylint`, `isort` and `black` does in a single tool and it is a lot faster. After getting used to it I often get a bit annoyed at how slow `pylint` is.


Discussion / hints:
Yes, `ruff` would be most welcomed!

Would also be nice to move tool configs from `setup.cfg` to `pyproject.toml`. The ultimate goal being to drop `setup.py` and `setup.cfg` in favor of defining the project metadata/build-info in `pyproject.toml` using setuptools's https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html.

Fix patch:
diff --git a/docs/conf.py b/docs/conf.py
index 5fb5554..f3f681a 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -19,7 +19,7 @@
 pkg_info = importlib.metadata.metadata("pydash")
 
 project = pkg_info["Name"]
-author = pkg_info["Author"]
+author = pkg_info["Author-email"]
 description = pkg_info["Summary"]
 copyright = "2013, " + author
 
diff --git a/pylintrc b/pylintrc
deleted file mode 100644
index 7c8886c..0000000
--- a/pylintrc
+++ /dev/null
@@ -1,106 +0,0 @@
-[MASTER]
-
-# A comma-separated list of package or module names from where C extensions may
-# be loaded. Extensions are loading into the active Python interpreter and may
-# run arbitrary code.
-extension-pkg-whitelist=math,unicodedata
-
-# Specify a score threshold to be exceeded before program exits with error.
-fail-under=10
-
-# Add files or directories to the blacklist. They should be base names, not
-# paths.
-ignore=CVS
-
-# Add files or directories matching the regex patterns to the blacklist. The
-# regex matches against base names, not paths.
-#ignore-patterns=
-
-# Python code to execute, usually for sys.path manipulation such as
-# pygtk.require().
-#init-hook=
-
-# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
-# number of processors available to use.
-#jobs=0
-# Temporarily disable multiprocessing since it duplicates violations due to bug: https://github.com/PyCQA/pylint/issues/3584
-jobs=1
-
-# Control the amount of potential inferred values when inferring a single
-# object. This can help the performance when dealing with large functions or
-# complex, nested conditions.
-limit-inference-results=100
-
-# List of plugins (as comma separated values of python module names) to load,
-# usually to register additional checkers.
-load-plugins=
-
-# Pickle collected data for later comparisons.
-persistent=yes
-
-# When enabled, pylint would attempt to guess common misconfiguration and emit
-# user-friendly hints instead of false-positive error messages.
-suggestion-mode=yes
-
-# Allow loading of arbitrary C extensions. Extensions are imported into the
-# active Python interpreter and may run arbitrary code.
-unsafe-load-any-extension=no
-
-
-[MESSAGES CONTROL]
-
-# Only show warnings with the listed confidence levels. Leave empty to show
-# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED.
-confidence=
-
-# Enable the message, report, category or checker with the given id(s). You can
-# either give multiple identifier separated by comma (,) or put this option
-# multiple time (only on the command line, not in the configuration file where
-# it should appear only once). See also the "--disable" option for examples.
-# NOTE: Only check for errors. Style/other conventions are not being checked.
-enable=E,F
-
-# Disable the message, report, category or checker with the given id(s). You
-# can either give multiple identifiers separated by comma (,) or put this
-# option multiple times (only on the command line, not in the configuration
-# file where it should appear only once). You can also use "--disable=all" to
-# disable everything first and then reenable specific checks. For example, if
-# you want to run only the similarities checker, you can use "--disable=all
-# --enable=similarities". If you want to run only the classes checker, but have
-# no Warning level messages displayed, use "--disable=all --enable=classes
-# --disable=W".
-disable=C,R,W
-
-
-[REPORTS]
-
-# Python expression which should return a score less than or equal to 10. You
-# have access to the variables 'error', 'warning', 'refactor', and 'convention'
-# which contain the number of messages in each category, as well as 'statement'
-# which is the total number of statements analyzed. This score is used by the
-# global evaluation report (RP0004).
-evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
-
-# Template used to display messages. This is a python new-style format string
-# used to format the message information. See doc for all details.
-#msg-template=
-
-# Set the output format. Available formats are text, parseable, colorized, json
-# and msvs (visual studio). You can also give a reporter class, e.g.
-# mypackage.mymodule.MyReporterClass.
-output-format=text
-
-# Tells whether to display a full report or only the messages.
-reports=no
-
-# Activate the evaluation score.
-# NOTE: Since we're only checking errors, we don't really need to worry about a score.
-score=no
-
-
-########################################################################################
-# NOTE: All other sections of pylintrc have been removed since we are only interested in
-# checking pylint errors and not other style conventions. Those could be added from
-# https://github.com/PyCQA/pylint/blob/master/pylintrc or by borrowing from
-# $ pylint --generate-rcfile
-########################################################################################
diff --git a/pyproject.toml b/pyproject.toml
index 4632439..73fcf9d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,23 +1,144 @@
 [build-system]
-requires = [
-    "setuptools>=46.4",
-    "wheel",
-]
+requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
+[project]
+name = "pydash"
+dynamic = ["version"]
+authors = [{ name = "Derrick Gilland", email = "dgilland@gmail.com" }]
+description = 'The kitchen sink of Python utility libraries for doing "stuff" in a functional way. Based on the Lo-Dash Javascript library.'
+readme = "README.rst"
+license = { file = "LICENSE.rst" }
+keywords = ["pydash", "utility", "functional", "lodash", "underscore"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "License :: OSI Approved :: MIT License",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Utilities",
+]
+requires-python = ">=3.8"
+dependencies = ["typing-extensions>3.10,!=4.6.0"]
+
+[project.urls]
+Homepage = "https://github.com/dgilland/pydash"
+Documentation = "https://pydash.readthedocs.org"
+Repository = "https://github.com/dgilland/pydash"
+Issues = "https://github.com/dgilland/pydash/issues"
+Changelog = "https://github.com/dgilland/pydash/blob/develop/CHANGELOG.rst"
+
+[project.optional-dependencies]
+dev = [
+  "build",
+  "coverage",
+  "ruff",
+  "furo",
+  "invoke",
+  "mypy",
+  "pytest",
+  "pytest-mypy-testing",
+  "pytest-cov",
+  "sphinx",
+  "tox",
+  "twine",
+  "wheel",
+  "sphinx-autodoc-typehints",
+]
+
+[tool.setuptools.dynamic]
+version = { attr = "pydash.__version__" }
+
+[tool.distutils.bdist_wheel]
+python-tag = "py3"
 
-[tool.black]
+[tool.ruff]
+src = ["src"]
+extend-exclude = [".cache", "tests/pytest_mypy_testing"]
+extend-include = ["*.pyi"]
 line-length = 100
-include = '\.pyi?$'
-exclude = '''
-/(
-    \.git
-  | \.mypy_cache
-  | \.tox
-  | \.venv
-  | \.cache
-  | _build
-  | build
-  | dist
-)/
-'''
+# target the lowest supported version to avoid introducing unsupported syntax
+target-version = "py38"
+
+[tool.ruff.lint]
+select = [
+  # flake8
+  "F",
+  "E",
+  "W",
+  # flake8-bugbear
+  "B",
+  # pylint
+  "PL",
+]
+# F811 - redefinition of unused `name` from line `N`
+# E203 - whitespace before ':'
+# E701 - multiple statements on one line (colon)
+# PLR2004 - Magic value used in comparison, consider replacing `...` with a constant variable
+# PLW2901 - `...` loop variable `...` overwritten by assignment target
+# PLR0913 - Too many arguments in function definition
+ignore = ["F811", "E203", "E701", "PLR2004", "PLW2901", "PLR0913"]
+
+[tool.ruff.lint.extend-per-file-ignores]
+# Exceptions for the type stub
+# F403 - `from module import *` used; unable to detect undefined names
+# F405 - name may be undefined, or defined from star imports
+# E501 - line too long
+"*.pyi" = ["F403", "F405", "E501"]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+combine-as-imports = true
+force-sort-within-sections = true
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.mypy]
+mypy_path = ["src"]
+python_version = "3.8"
+exclude = [
+    "tests/pytest_mypy_testing",
+]
+show_column_numbers = true
+show_error_context = false
+ignore_missing_imports = true
+warn_return_any = false
+strict_optional = true
+warn_no_return = true
+warn_redundant_casts = false
+warn_unused_ignores = false
+
+[tool.pytest.ini_options]
+addopts = [
+    "--verbose",
+    "--doctest-modules",
+    "--no-cov-on-fail",
+    "--cov-fail-under=100",
+    "--cov-report=term-missing",
+    "--cov-report=xml:build/coverage/coverage.xml",
+    "--cov-report=html:build/coverage",
+    "--junitxml=build/testresults/junit.xml",
+]
+
+[tool.coverage.run]
+omit = [
+    "*/tests/*",
+    "*/test_*",
+    "*/_compat.py",
+    "*/types.py",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "@t.overload"
+]
diff --git a/scripts/chaining_type_generator.py b/scripts/chaining_type_generator.py
index d983fb2..595bb7f 100644
--- a/scripts/chaining_type_generator.py
+++ b/scripts/chaining_type_generator.py
@@ -58,7 +58,7 @@
     SupportsSub,
 )
 
-Value_coT = t.TypeVar("Value_coT", covariant=True)
+ValueT_co = t.TypeVar("ValueT_co", covariant=True)
 T = t.TypeVar("T")
 T1 = t.TypeVar("T1")
 T2 = t.TypeVar("T2")
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 5e41c17..0000000
--- a/setup.cfg
+++ /dev/null
@@ -1,120 +0,0 @@
-[metadata]
-name = pydash
-version = attr: pydash.__version__
-author = Derrick Gilland
-author_email = dgilland@gmail.com
-url = https://github.com/dgilland/pydash
-description = The kitchen sink of Python utility libraries for doing "stuff" in a functional way. Based on the Lo-Dash Javascript library.
-long_description = file: README.rst, CHANGELOG.rst, LICENSE.rst
-keywords = pydash utility functional lodash underscore
-license = MIT License
-classifiers =
-    Development Status :: 5 - Production/Stable
-    License :: OSI Approved :: MIT License
-    Intended Audience :: Developers
-    Operating System :: OS Independent
-    Programming Language :: Python
-    Programming Language :: Python :: 3
-    Programming Language :: Python :: 3.8
-    Programming Language :: Python :: 3.9
-    Programming Language :: Python :: 3.10
-    Programming Language :: Python :: 3.11
-    Programming Language :: Python :: 3.12
-    Topic :: Software Development :: Libraries
-    Topic :: Software Development :: Libraries :: Python Modules
-    Topic :: Utilities
-
-[options]
-package_dir =
-    = src
-packages = find:
-python_requires = >=3.8
-include_package_data = True
-install_requires =
-    typing-extensions>=3.10,!=4.6.0
-
-[options.packages.find]
-where = src
-
-[options.extras_require]
-dev =
-    black
-    build
-    coverage
-    docformatter
-    flake8
-    flake8-black
-    flake8-bugbear
-    flake8-isort
-    furo
-    invoke
-    isort
-    mypy
-    pylint
-    pytest
-    pytest-mypy-testing
-    pytest-cov
-    sphinx
-    tox
-    twine
-    wheel
-    sphinx-autodoc-typehints
-
-
-[bdist_wheel]
-python_tag = py3
-
-[flake8]
-exclude = .tox,venv,env
-max_line_length = 100
-max_complexity = 12
-# F811 - redefinition of unused `name` from line `N`
-# E203 - whitespace before ':'
-# W503 - line break before binary operator
-# E701 - multiple statements on one line (colon)
-# E704 - multiple statements on one line (def)
-ignore = F811,E203,W503,E701,E704
-
-[mypy]
-show_column_numbers = True
-show_error_context = False
-ignore_missing_imports = True
-warn_return_any = False
-strict_optional = True
-warn_no_return = True
-warn_redundant_casts = False
-warn_unused_ignores = False
-
-[tool:isort]
-line_length = 100
-multi_line_output = 3
-lines_after_imports = 2
-combine_as_imports = true
-include_trailing_comma = true
-force_sort_within_sections = true
-
-[tool:pytest]
-junit_family = xunit2
-filterwarnings =
-    ignore::pytest.PytestRemovedIn8Warning:pytest_pylint.*
-addopts =
-    --verbose
-    --doctest-modules
-    --no-cov-on-fail
-    --cov-fail-under=100
-    --cov-report=term-missing
-    --cov-report=xml:build/coverage/coverage.xml
-    --cov-report=html:build/coverage
-    --junitxml=build/testresults/junit.xml
-
-[coverage:run]
-omit =
-    */tests/*
-    */test_*
-    */_compat.py
-    */types.py
-
-[coverage:report]
-exclude_lines =
-    pragma: no cover
-    @t.overload
diff --git a/src/pydash/arrays.py b/src/pydash/arrays.py
index c3e8a14..d9540a5 100644
--- a/src/pydash/arrays.py
+++ b/src/pydash/arrays.py
@@ -137,7 +137,7 @@ def compact(array: t.Iterable[t.Union[T, None]]) -> t.List[T]:
 
     Example:
 
-        >>> compact(['', 1, 0, True, False, None])
+        >>> compact(["", 1, 0, True, False, None])
         [1, True]
 
     .. versionadded:: 1.0.0
@@ -194,13 +194,15 @@ def difference_by(
     array: t.Iterable[T],
     *others: t.Iterable[T],
     iteratee: t.Union[IterateeObjT, t.Callable[[T], t.Any], None],
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def difference_by(
     array: t.Iterable[T], *others: t.Union[IterateeObjT, t.Iterable[T], t.Callable[[T], t.Any]]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def difference_by(array, *others, **kwargs):
@@ -249,13 +251,15 @@ def difference_with(
     array: t.Iterable[T],
     *others: t.Iterable[T2],
     comparator: t.Union[t.Callable[[T, T2], t.Any], None],
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def difference_with(
     array: t.Iterable[T], *others: t.Union[t.Iterable[T2], t.Callable[[T, T2], t.Any]]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def difference_with(array, *others, **kwargs):
@@ -277,8 +281,8 @@ def difference_with(array, *others, **kwargs):
 
     Example:
 
-        >>> array = ['apple', 'banana', 'pear']
-        >>> others = (['avocado', 'pumpkin'], ['peach'])
+        >>> array = ["apple", "banana", "pear"]
+        >>> others = (["avocado", "pumpkin"], ["peach"])
         >>> comparator = lambda a, b: a[0] == b[0]
         >>> difference_with(array, *others, comparator=comparator)
         ['banana']
@@ -361,19 +365,23 @@ def drop_right(array: t.Sequence[T], n: int = 1) -> t.List[T]:
 @t.overload
 def drop_right_while(
     array: t.Sequence[T], predicate: t.Callable[[T, int, t.List[T]], t.Any]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
-def drop_right_while(array: t.Sequence[T], predicate: t.Callable[[T, int], t.Any]) -> t.List[T]: ...
+def drop_right_while(array: t.Sequence[T], predicate: t.Callable[[T, int], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def drop_right_while(array: t.Sequence[T], predicate: t.Callable[[T], t.Any]) -> t.List[T]: ...
+def drop_right_while(array: t.Sequence[T], predicate: t.Callable[[T], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def drop_right_while(array: t.Sequence[T], predicate: None = None) -> t.List[T]: ...
+def drop_right_while(array: t.Sequence[T], predicate: None = None) -> t.List[T]:
+    ...
 
 
 def drop_right_while(array, predicate=None):
@@ -409,19 +417,23 @@ def drop_right_while(array, predicate=None):
 @t.overload
 def drop_while(
     array: t.Sequence[T], predicate: t.Callable[[T, int, t.List[T]], t.Any]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
-def drop_while(array: t.Sequence[T], predicate: t.Callable[[T, int], t.Any]) -> t.List[T]: ...
+def drop_while(array: t.Sequence[T], predicate: t.Callable[[T, int], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def drop_while(array: t.Sequence[T], predicate: t.Callable[[T], t.Any]) -> t.List[T]: ...
+def drop_while(array: t.Sequence[T], predicate: t.Callable[[T], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def drop_while(array: t.Sequence[T], predicate: None = None) -> t.List[T]: ...
+def drop_while(array: t.Sequence[T], predicate: None = None) -> t.List[T]:
+    ...
 
 
 def drop_while(array, predicate=None):
@@ -532,23 +544,28 @@ def fill(
 
 
 @t.overload
-def find_index(array: t.Iterable[T], predicate: t.Callable[[T, int, t.List[T]], t.Any]) -> int: ...
+def find_index(array: t.Iterable[T], predicate: t.Callable[[T, int, t.List[T]], t.Any]) -> int:
+    ...
 
 
 @t.overload
-def find_index(array: t.Iterable[T], predicate: t.Callable[[T, int], t.Any]) -> int: ...
+def find_index(array: t.Iterable[T], predicate: t.Callable[[T, int], t.Any]) -> int:
+    ...
 
 
 @t.overload
-def find_index(array: t.Iterable[T], predicate: t.Callable[[T], t.Any]) -> int: ...
+def find_index(array: t.Iterable[T], predicate: t.Callable[[T], t.Any]) -> int:
+    ...
 
 
 @t.overload
-def find_index(array: t.Iterable[t.Any], predicate: IterateeObjT) -> int: ...
+def find_index(array: t.Iterable[t.Any], predicate: IterateeObjT) -> int:
+    ...
 
 
 @t.overload
-def find_index(array: t.Iterable[t.Any], predicate: None = None) -> int: ...
+def find_index(array: t.Iterable[t.Any], predicate: None = None) -> int:
+    ...
 
 
 def find_index(array, predicate=None):
@@ -577,25 +594,28 @@ def find_index(array, predicate=None):
 
 
 @t.overload
-def find_last_index(
-    array: t.Iterable[T], predicate: t.Callable[[T, int, t.List[T]], t.Any]
-) -> int: ...
+def find_last_index(array: t.Iterable[T], predicate: t.Callable[[T, int, t.List[T]], t.Any]) -> int:
+    ...
 
 
 @t.overload
-def find_last_index(array: t.Iterable[T], predicate: t.Callable[[T, int], t.Any]) -> int: ...
+def find_last_index(array: t.Iterable[T], predicate: t.Callable[[T, int], t.Any]) -> int:
+    ...
 
 
 @t.overload
-def find_last_index(array: t.Iterable[T], predicate: t.Callable[[T], t.Any]) -> int: ...
+def find_last_index(array: t.Iterable[T], predicate: t.Callable[[T], t.Any]) -> int:
+    ...
 
 
 @t.overload
-def find_last_index(array: t.Iterable[t.Any], predicate: IterateeObjT) -> int: ...
+def find_last_index(array: t.Iterable[t.Any], predicate: IterateeObjT) -> int:
+    ...
 
 
 @t.overload
-def find_last_index(array: t.Iterable[t.Any], predicate: None = None) -> int: ...
+def find_last_index(array: t.Iterable[t.Any], predicate: None = None) -> int:
+    ...
 
 
 def find_last_index(array, predicate=None):
@@ -624,11 +644,13 @@ def find_last_index(array, predicate=None):
 
 
 @t.overload
-def flatten(array: t.Iterable[t.Iterable[T]]) -> t.List[T]: ...
+def flatten(array: t.Iterable[t.Iterable[T]]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def flatten(array: t.Iterable[T]) -> t.List[T]: ...
+def flatten(array: t.Iterable[T]) -> t.List[T]:
+    ...
 
 
 def flatten(array):
@@ -707,13 +729,13 @@ def flatten_depth(array: t.Iterable, depth: int = 1) -> t.List:
 
 
 @t.overload
-def from_pairs(pairs: t.Iterable[t.Tuple[T, T2]]) -> t.Dict[T, T2]: ...
+def from_pairs(pairs: t.Iterable[t.Tuple[T, T2]]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def from_pairs(
-    pairs: t.Iterable[t.List[t.Union[T, T2]]]
-) -> t.Dict[t.Union[T, T2], t.Union[T, T2]]: ...
+def from_pairs(pairs: t.Iterable[t.List[t.Union[T, T2]]]) -> t.Dict[t.Union[T, T2], t.Union[T, T2]]:
+    ...
 
 
 def from_pairs(pairs):
@@ -728,7 +750,7 @@ def from_pairs(pairs):
 
     Example:
 
-        >>> from_pairs([['a', 1], ['b', 2]]) == {'a': 1, 'b': 2}
+        >>> from_pairs([["a", 1], ["b", 2]]) == {"a": 1, "b": 2}
         True
 
     .. versionadded:: 4.0.0
@@ -807,11 +829,13 @@ def initial(array: t.Sequence[T]) -> t.Sequence[T]:
 
 
 @t.overload
-def intercalate(array: t.Iterable[t.Iterable[T]], separator: T2) -> t.List[t.Union[T, T2]]: ...
+def intercalate(array: t.Iterable[t.Iterable[T]], separator: T2) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 @t.overload
-def intercalate(array: t.Iterable[T], separator: T2) -> t.List[t.Union[T, T2]]: ...
+def intercalate(array: t.Iterable[T], separator: T2) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 def intercalate(array, separator):
@@ -827,7 +851,7 @@ def intercalate(array, separator):
 
     Example:
 
-        >>> intercalate([1, [2], [3], 4], 'x')
+        >>> intercalate([1, [2], [3], 4], "x")
         [1, 'x', 2, 'x', 3, 'x', 4]
 
 
@@ -889,13 +913,15 @@ def intersection_by(
     array: t.Sequence[T],
     *others: t.Iterable[t.Any],
     iteratee: t.Union[t.Callable[[T], t.Any], IterateeObjT],
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def intersection_by(
     array: t.Sequence[T], *others: t.Union[t.Iterable[t.Any], t.Callable[[T], t.Any], IterateeObjT]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def intersection_by(array, *others, **kwargs):
@@ -944,13 +970,15 @@ def intersection_by(array, *others, **kwargs):
 @t.overload
 def intersection_with(
     array: t.Sequence[T], *others: t.Iterable[T2], comparator: t.Callable[[T, T2], t.Any]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def intersection_with(
     array: t.Sequence[T], *others: t.Union[t.Iterable[T2], t.Callable[[T, T2], t.Any]]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def intersection_with(array, *others, **kwargs):
@@ -972,8 +1000,8 @@ def intersection_with(array, *others, **kwargs):
 
     Example:
 
-        >>> array = ['apple', 'banana', 'pear']
-        >>> others = (['avocado', 'pumpkin'], ['peach'])
+        >>> array = ["apple", "banana", "pear"]
+        >>> others = (["avocado", "pumpkin"], ["peach"])
         >>> comparator = lambda a, b: a[0] == b[0]
         >>> intersection_with(array, *others, comparator=comparator)
         ['pear']
@@ -1011,7 +1039,7 @@ def intersperse(array: t.Iterable[T], separator: T2) -> t.List[t.Union[T, T2]]:
 
     Example:
 
-        >>> intersperse([1, [2], [3], 4], 'x')
+        >>> intersperse([1, [2], [3], 4], "x")
         [1, 'x', [2], 'x', [3], 'x', 4]
 
     .. versionadded:: 2.0.0
@@ -1084,37 +1112,44 @@ def last_index_of(
 def mapcat(
     array: t.Iterable[T],
     iteratee: t.Callable[[T, int, t.List[T]], t.Union[t.List[T2], t.List[t.List[T2]]]],
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def mapcat(array: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]) -> t.List[T2]: ...
+def mapcat(array: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def mapcat(
     array: t.Iterable[T], iteratee: t.Callable[[T, int], t.Union[t.List[T2], t.List[t.List[T2]]]]
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def mapcat(array: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.List[T2]: ...
+def mapcat(array: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def mapcat(
     array: t.Iterable[T], iteratee: t.Callable[[T], t.Union[t.List[T2], t.List[t.List[T2]]]]
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def mapcat(array: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.List[T2]: ...
+def mapcat(array: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def mapcat(
     array: t.Iterable[t.Union[t.List[T], t.List[t.List[T]]]], iteratee: None = None
-) -> t.List[t.Union[T, t.List[T]]]: ...
+) -> t.List[t.Union[T, t.List[T]]]:
+    ...
 
 
 def mapcat(array, iteratee=None):
@@ -1271,8 +1306,8 @@ def pull_all_by(
 
     Example:
 
-        >>> array = [{'x': 1}, {'x': 2}, {'x': 3}, {'x': 1}]
-        >>> pull_all_by(array, [{'x': 1}, {'x': 3}], 'x')
+        >>> array = [{"x": 1}, {"x": 2}, {"x": 3}, {"x": 1}]
+        >>> pull_all_by(array, [{"x": 1}, {"x": 3}], "x")
         [{'x': 2}]
 
     .. versionadded:: 4.0.0
@@ -1302,13 +1337,13 @@ def pull_all_with(
 
     Example:
 
-        >>> array = [{'x': 1, 'y': 2}, {'x': 3, 'y': 4}, {'x': 5, 'y': 6}]
-        >>> res = pull_all_with(array, [{'x': 3, 'y': 4}], lambda a, b: a == b)
-        >>> res == [{'x': 1, 'y': 2}, {'x': 5, 'y': 6}]
+        >>> array = [{"x": 1, "y": 2}, {"x": 3, "y": 4}, {"x": 5, "y": 6}]
+        >>> res = pull_all_with(array, [{"x": 3, "y": 4}], lambda a, b: a == b)
+        >>> res == [{"x": 1, "y": 2}, {"x": 5, "y": 6}]
         True
-        >>> array = [{'x': 1, 'y': 2}, {'x': 3, 'y': 4}, {'x': 5, 'y': 6}]
-        >>> res = pull_all_with(array, [{'x': 3, 'y': 4}], lambda a, b: a != b)
-        >>> res == [{'x': 3, 'y': 4}]
+        >>> array = [{"x": 1, "y": 2}, {"x": 3, "y": 4}, {"x": 5, "y": 6}]
+        >>> res = pull_all_with(array, [{"x": 3, "y": 4}], lambda a, b: a != b)
+        >>> res == [{"x": 3, "y": 4}]
         True
 
     .. versionadded:: 4.0.0
@@ -1508,19 +1543,22 @@ def sort(
     comparator: None = None,
     key: None = None,
     reverse: bool = False,
-) -> t.List["SupportsRichComparisonT"]: ...
+) -> t.List["SupportsRichComparisonT"]:
+    ...
 
 
 @t.overload
 def sort(
     array: t.List[T], comparator: t.Callable[[T, T], int], *, reverse: bool = False
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def sort(
     array: t.List[T], *, key: t.Callable[[T], "SupportsRichComparisonT"], reverse: bool = False
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def sort(array, comparator=None, key=None, reverse=False):
@@ -1608,7 +1646,8 @@ def sorted_index_by(
     array: t.Sequence[T],
     value: T,
     iteratee: t.Union[IterateeObjT, t.Callable[[T], "SupportsRichComparisonT"]],
-) -> int: ...
+) -> int:
+    ...
 
 
 @t.overload
@@ -1616,7 +1655,8 @@ def sorted_index_by(
     array: t.Sequence["SupportsRichComparisonT"],
     value: "SupportsRichComparisonT",
     iteratee: None = None,
-) -> int: ...
+) -> int:
+    ...
 
 
 def sorted_index_by(array, value, iteratee=None):
@@ -1635,10 +1675,10 @@ def sorted_index_by(array, value, iteratee=None):
 
     Example:
 
-        >>> array = [{'x': 4}, {'x': 5}]
-        >>> sorted_index_by(array, {'x': 4}, lambda o: o['x'])
+        >>> array = [{"x": 4}, {"x": 5}]
+        >>> sorted_index_by(array, {"x": 4}, lambda o: o["x"])
         0
-        >>> sorted_index_by(array, {'x': 4}, 'x')
+        >>> sorted_index_by(array, {"x": 4}, "x")
         0
 
     .. versionadded:: 4.0.0
@@ -1714,7 +1754,8 @@ def sorted_last_index_by(
     array: t.Sequence[T],
     value: T,
     iteratee: t.Union[IterateeObjT, t.Callable[[T], "SupportsRichComparisonT"]],
-) -> int: ...
+) -> int:
+    ...
 
 
 @t.overload
@@ -1722,7 +1763,8 @@ def sorted_last_index_by(
     array: t.Sequence["SupportsRichComparisonT"],
     value: "SupportsRichComparisonT",
     iteratee: None = None,
-) -> int: ...
+) -> int:
+    ...
 
 
 def sorted_last_index_by(array, value, iteratee=None):
@@ -1741,10 +1783,10 @@ def sorted_last_index_by(array, value, iteratee=None):
 
     Example:
 
-        >>> array = [{'x': 4}, {'x': 5}]
-        >>> sorted_last_index_by(array, {'x': 4}, lambda o: o['x'])
+        >>> array = [{"x": 4}, {"x": 5}]
+        >>> sorted_last_index_by(array, {"x": 4}, lambda o: o["x"])
         1
-        >>> sorted_last_index_by(array, {'x': 4}, 'x')
+        >>> sorted_last_index_by(array, {"x": 4}, "x")
         1
     """
     if iteratee:
@@ -2003,21 +2045,23 @@ def take_right(array: t.Sequence[T], n: int = 1) -> t.Sequence[T]:
 @t.overload
 def take_right_while(
     array: t.Sequence[T], predicate: t.Callable[[T, int, t.List[T]], t.Any]
-) -> t.Sequence[T]: ...
+) -> t.Sequence[T]:
+    ...
 
 
 @t.overload
-def take_right_while(
-    array: t.Sequence[T], predicate: t.Callable[[T, int], t.Any]
-) -> t.Sequence[T]: ...
+def take_right_while(array: t.Sequence[T], predicate: t.Callable[[T, int], t.Any]) -> t.Sequence[T]:
+    ...
 
 
 @t.overload
-def take_right_while(array: t.Sequence[T], predicate: t.Callable[[T], t.Any]) -> t.Sequence[T]: ...
+def take_right_while(array: t.Sequence[T], predicate: t.Callable[[T], t.Any]) -> t.Sequence[T]:
+    ...
 
 
 @t.overload
-def take_right_while(array: t.Sequence[T], predicate: None = None) -> t.Sequence[T]: ...
+def take_right_while(array: t.Sequence[T], predicate: None = None) -> t.Sequence[T]:
+    ...
 
 
 def take_right_while(array, predicate=None):
@@ -2053,19 +2097,23 @@ def take_right_while(array, predicate=None):
 @t.overload
 def take_while(
     array: t.Sequence[T], predicate: t.Callable[[T, int, t.List[T]], t.Any]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
-def take_while(array: t.Sequence[T], predicate: t.Callable[[T, int], t.Any]) -> t.List[T]: ...
+def take_while(array: t.Sequence[T], predicate: t.Callable[[T, int], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def take_while(array: t.Sequence[T], predicate: t.Callable[[T], t.Any]) -> t.List[T]: ...
+def take_while(array: t.Sequence[T], predicate: t.Callable[[T], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def take_while(array: t.Sequence[T], predicate: None = None) -> t.List[T]: ...
+def take_while(array: t.Sequence[T], predicate: None = None) -> t.List[T]:
+    ...
 
 
 def take_while(array, predicate=None):
@@ -2099,11 +2147,13 @@ def take_while(array, predicate=None):
 
 
 @t.overload
-def union(array: t.Sequence[T]) -> t.List[T]: ...
+def union(array: t.Sequence[T]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def union(array: t.Sequence[T], *others: t.Sequence[T2]) -> t.List[t.Union[T, T2]]: ...
+def union(array: t.Sequence[T], *others: t.Sequence[T2]) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 def union(array, *others):
@@ -2133,13 +2183,15 @@ def union(array, *others):
 @t.overload
 def union_by(
     array: t.Sequence[T], *others: t.Iterable[T], iteratee: t.Callable[[T], t.Any]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def union_by(
     array: t.Sequence[T], *others: t.Union[t.Iterable[T], t.Callable[[T], t.Any]]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def union_by(array, *others, **kwargs):
@@ -2177,13 +2229,15 @@ def union_by(array, *others, **kwargs):
 @t.overload
 def union_with(
     array: t.Sequence[T], *others: t.Iterable[T2], comparator: t.Callable[[T, T2], t.Any]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def union_with(
     array: t.Sequence[T], *others: t.Union[t.Iterable[T2], t.Callable[[T, T2], t.Any]]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def union_with(array, *others, **kwargs):
@@ -2363,14 +2417,16 @@ def unzip_with(
         t.Callable[[T, T], T2],
         t.Callable[[T], T2],
     ],
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def unzip_with(
     array: t.Iterable[t.Iterable[T]],
     iteratee: None = None,
-) -> t.List[t.List[T]]: ...
+) -> t.List[t.List[T]]:
+    ...
 
 
 def unzip_with(array, iteratee=None):
@@ -2455,13 +2511,15 @@ def xor_by(
     array: t.Iterable[T],
     *lists: t.Iterable[T],
     iteratee: t.Union[t.Callable[[T], t.Any], IterateeObjT],
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def xor_by(
     array: t.Iterable[T], *lists: t.Union[t.Iterable[T], t.Callable[[T], t.Any]]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def xor_by(array, *lists, **kwargs):
@@ -2486,7 +2544,7 @@ def xor_by(array, *lists, **kwargs):
 
         >>> xor_by([2.1, 1.2], [2.3, 3.4], round)
         [1.2, 3.4]
-        >>> xor_by([{'x': 1}], [{'x': 2}, {'x': 1}], 'x')
+        >>> xor_by([{"x": 1}], [{"x": 2}, {"x": 1}], "x")
         [{'x': 2}]
 
     .. versionadded:: 4.0.0
@@ -2511,13 +2569,15 @@ def xor_by(array, *lists, **kwargs):
 @t.overload
 def xor_with(
     array: t.Sequence[T], *lists: t.Iterable[T2], comparator: t.Callable[[T, T2], t.Any]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def xor_with(
     array: t.Sequence[T], *lists: t.Union[t.Iterable[T2], t.Callable[[T, T2], t.Any]]
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def xor_with(array, *lists, **kwargs):
@@ -2539,9 +2599,9 @@ def xor_with(array, *lists, **kwargs):
 
     Example:
 
-        >>> objects = [{'x': 1, 'y': 2}, {'x': 2, 'y': 1}]
-        >>> others = [{'x': 1, 'y': 1}, {'x': 1, 'y': 2}]
-        >>> expected = [{'y': 1, 'x': 2}, {'y': 1, 'x': 1}]
+        >>> objects = [{"x": 1, "y": 2}, {"x": 2, "y": 1}]
+        >>> others = [{"x": 1, "y": 1}, {"x": 1, "y": 2}]
+        >>> expected = [{"y": 1, "x": 2}, {"y": 1, "x": 1}]
         >>> xor_with(objects, others, lambda a, b: a == b) == expected
         True
 
@@ -2587,17 +2647,20 @@ def zip_(*arrays: t.Iterable[T]) -> t.List[t.List[T]]:
 
 
 @t.overload
-def zip_object(keys: t.Iterable[t.Tuple[T, T2]], values: None = None) -> t.Dict[T, T2]: ...
+def zip_object(keys: t.Iterable[t.Tuple[T, T2]], values: None = None) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
 def zip_object(
     keys: t.Iterable[t.List[t.Union[T, T2]]], values: None = None
-) -> t.Dict[t.Union[T, T2], t.Union[T, T2]]: ...
+) -> t.Dict[t.Union[T, T2], t.Union[T, T2]]:
+    ...
 
 
 @t.overload
-def zip_object(keys: t.Iterable[T], values: t.List[T2]) -> t.Dict[T, T2]: ...
+def zip_object(keys: t.Iterable[T], values: t.List[T2]) -> t.Dict[T, T2]:
+    ...
 
 
 def zip_object(keys, values=None):
@@ -2643,8 +2706,8 @@ def zip_object_deep(keys: t.Iterable[t.Any], values: t.Union[t.List[t.Any], None
 
     Example:
 
-        >>> expected = {'a': {'b': {'c': 1, 'd': 2}}}
-        >>> zip_object_deep(['a.b.c', 'a.b.d'], [1, 2]) == expected
+        >>> expected = {"a": {"b": {"c": 1, "d": 2}}}
+        >>> zip_object_deep(["a.b.c", "a.b.d"], [1, 2]) == expected
         True
 
     .. versionadded:: 4.0.0
@@ -2668,11 +2731,13 @@ def zip_with(
         t.Callable[[T, T], T2],
         t.Callable[[T], T2],
     ],
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def zip_with(*arrays: t.Iterable[T]) -> t.List[t.List[T]]: ...
+def zip_with(*arrays: t.Iterable[T]) -> t.List[t.List[T]]:
+    ...
 
 
 @t.overload
@@ -2684,7 +2749,8 @@ def zip_with(
         t.Callable[[T, T], T2],
         t.Callable[[T], T2],
     ],
-) -> t.List[t.Union[t.List[T], T2]]: ...
+) -> t.List[t.Union[t.List[T], T2]]:
+    ...
 
 
 def zip_with(*arrays, **kwargs):
@@ -2763,7 +2829,7 @@ def iterintersperse(iterable, separator):
         yield item
 
 
-def iterunique(array, comparator=None, iteratee=None):  # noqa: C901
+def iterunique(array, comparator=None, iteratee=None):  # noqa: PLR0912
     """Yield each unique item in array."""
     if not array:  # pragma: no cover
         return
diff --git a/src/pydash/chaining/all_funcs.pyi b/src/pydash/chaining/all_funcs.pyi
index eb22d5c..c1e3145 100644
--- a/src/pydash/chaining/all_funcs.pyi
+++ b/src/pydash/chaining/all_funcs.pyi
@@ -3,35 +3,26 @@
 
 import re
 import typing as t
-
-from _typeshed import (
-    SupportsAdd,
-    SupportsDunderGE,
-    SupportsDunderGT,
-    SupportsDunderLE,
-    SupportsDunderLT,
-    SupportsRichComparison,
-    SupportsRichComparisonT,
-    SupportsSub,
-)
 from typing_extensions import Concatenate, Literal, ParamSpec, Type
 
 import pydash as pyd
 from pydash.chaining.chaining import Chain
+from pydash.types import *
+from pydash.helpers import Unset, UNSET
 from pydash.functions import (
     After,
     Ary,
     Before,
-    CurryFive,
-    CurryFour,
     CurryOne,
-    CurryRightFive,
-    CurryRightFour,
+    CurryTwo,
+    CurryThree,
+    CurryFour,
+    CurryFive,
     CurryRightOne,
-    CurryRightThree,
     CurryRightTwo,
-    CurryThree,
-    CurryTwo,
+    CurryRightThree,
+    CurryRightFour,
+    CurryRightFive,
     Debounce,
     Disjoin,
     Flow,
@@ -44,11 +35,20 @@ from pydash.functions import (
     Spread,
     Throttle,
 )
-from pydash.helpers import UNSET, Unset
-from pydash.types import *
 from pydash.utilities import MemoizedFunc
 
-Value_coT = t.TypeVar("Value_coT", covariant=True)
+from _typeshed import (
+    SupportsDunderGE,
+    SupportsDunderGT,
+    SupportsDunderLE,
+    SupportsDunderLT,
+    SupportsRichComparison,
+    SupportsAdd,
+    SupportsRichComparisonT,
+    SupportsSub,
+)
+
+ValueT_co = t.TypeVar("ValueT_co", covariant=True)
 T = t.TypeVar("T")
 T1 = t.TypeVar("T1")
 T2 = t.TypeVar("T2")
@@ -80,12 +80,12 @@ class AllFuncs:
     def difference_by(
         self: "Chain[t.Iterable[T]]",
         *others: t.Iterable[T],
-        iteratee: t.Union[IterateeObjT, t.Callable[[T], t.Any], None]
+        iteratee: t.Union[IterateeObjT, t.Callable[[T], t.Any], None],
     ) -> "Chain[t.List[T]]": ...
     @t.overload
     def difference_by(
         self: "Chain[t.Iterable[T]]",
-        *others: t.Union[IterateeObjT, t.Iterable[T], t.Callable[[T], t.Any]]
+        *others: t.Union[IterateeObjT, t.Iterable[T], t.Callable[[T], t.Any]],
     ) -> "Chain[t.List[T]]": ...
     def difference_by(self, *others, **kwargs):
         return self._wrap(pyd.difference_by)(*others, **kwargs)
@@ -94,7 +94,7 @@ class AllFuncs:
     def difference_with(
         self: "Chain[t.Iterable[T]]",
         *others: t.Iterable[T2],
-        comparator: t.Union[t.Callable[[T, T2], t.Any], None]
+        comparator: t.Union[t.Callable[[T, T2], t.Any], None],
     ) -> "Chain[t.List[T]]": ...
     @t.overload
     def difference_with(
@@ -252,12 +252,12 @@ class AllFuncs:
     def intersection_by(
         self: "Chain[t.Sequence[T]]",
         *others: t.Iterable[t.Any],
-        iteratee: t.Union[t.Callable[[T], t.Any], IterateeObjT]
+        iteratee: t.Union[t.Callable[[T], t.Any], IterateeObjT],
     ) -> "Chain[t.List[T]]": ...
     @t.overload
     def intersection_by(
         self: "Chain[t.Sequence[T]]",
-        *others: t.Union[t.Iterable[t.Any], t.Callable[[T], t.Any], IterateeObjT]
+        *others: t.Union[t.Iterable[t.Any], t.Callable[[T], t.Any], IterateeObjT],
     ) -> "Chain[t.List[T]]": ...
     def intersection_by(self, *others, **kwargs):
         return self._wrap(pyd.intersection_by)(*others, **kwargs)
@@ -266,7 +266,7 @@ class AllFuncs:
     def intersection_with(
         self: "Chain[t.Sequence[T]]",
         *others: t.Iterable[T2],
-        comparator: t.Callable[[T, T2], t.Any]
+        comparator: t.Callable[[T, T2], t.Any],
     ) -> "Chain[t.List[T]]": ...
     @t.overload
     def intersection_with(
@@ -373,6 +373,7 @@ class AllFuncs:
         self: "Chain[SequenceT]", start: int = 0, end: t.Union[int, None] = None
     ) -> "Chain[SequenceT]":
         return self._wrap(pyd.slice_)(start, end)
+
     slice = slice_
 
     @t.overload
@@ -391,7 +392,7 @@ class AllFuncs:
         self: "Chain[t.List[T]]",
         *,
         key: t.Callable[[T], "SupportsRichComparisonT"],
-        reverse: bool = False
+        reverse: bool = False,
     ) -> "Chain[t.List[T]]": ...
     def sort(self, comparator=None, key=None, reverse=False):
         return self._wrap(pyd.sort)(comparator, key, reverse)
@@ -536,7 +537,7 @@ class AllFuncs:
     def union_with(
         self: "Chain[t.Sequence[T]]",
         *others: t.Iterable[T2],
-        comparator: t.Callable[[T, T2], t.Any]
+        comparator: t.Callable[[T, T2], t.Any],
     ) -> "Chain[t.List[T]]": ...
     @t.overload
     def union_with(
@@ -591,7 +592,7 @@ class AllFuncs:
     def xor_by(
         self: "Chain[t.Iterable[T]]",
         *lists: t.Iterable[T],
-        iteratee: t.Union[t.Callable[[T], t.Any], IterateeObjT]
+        iteratee: t.Union[t.Callable[[T], t.Any], IterateeObjT],
     ) -> "Chain[t.List[T]]": ...
     @t.overload
     def xor_by(
@@ -613,6 +614,7 @@ class AllFuncs:
 
     def zip_(self: "Chain[t.Iterable[T]]", *arrays: t.Iterable[T]) -> "Chain[t.List[t.List[T]]]":
         return self._wrap(pyd.zip_)(*arrays)
+
     zip = zip_
 
     @t.overload
@@ -642,7 +644,7 @@ class AllFuncs:
             t.Callable[[T, T, int], T2],
             t.Callable[[T, T], T2],
             t.Callable[[T], T2],
-        ]
+        ],
     ) -> "Chain[t.List[T2]]": ...
     @t.overload
     def zip_with(
@@ -657,7 +659,7 @@ class AllFuncs:
             t.Callable[[T, T, int], T2],
             t.Callable[[T, T], T2],
             t.Callable[[T], T2],
-        ]
+        ],
     ) -> "Chain[t.List[t.Union[t.List[T], T2]]]": ...
     def zip_with(self, *arrays, **kwargs):
         return self._wrap(pyd.zip_with)(*arrays, **kwargs)
@@ -756,6 +758,7 @@ class AllFuncs:
     ) -> "Chain[t.List[T]]": ...
     def filter_(self, predicate=None):
         return self._wrap(pyd.filter_)(predicate)
+
     filter = filter_
 
     @t.overload
@@ -1082,6 +1085,7 @@ class AllFuncs:
     ) -> "Chain[t.List]": ...
     def map_(self, iteratee=None):
         return self._wrap(pyd.map_)(iteratee)
+
     map = map_
 
     def nest(self: "Chain[t.Iterable]", *properties: t.Any) -> "Chain[t.Any]":
@@ -1214,6 +1218,7 @@ class AllFuncs:
     ) -> "Chain[T]": ...
     def reduce_(self, iteratee=None, accumulator=None):
         return self._wrap(pyd.reduce_)(iteratee, accumulator)
+
     reduce = reduce_
 
     @t.overload
@@ -1738,6 +1743,7 @@ class AllFuncs:
     def sum_(self: "Chain[t.Iterable['SupportsAdd[int, T]']]") -> "Chain[T]": ...
     def sum_(self):
         return self._wrap(pyd.sum_)()
+
     sum = sum_
 
     @t.overload
@@ -1855,6 +1861,7 @@ class AllFuncs:
     ) -> "Chain[t.Union['SupportsRichComparisonT', T]]": ...
     def max_(self, default=UNSET):
         return self._wrap(pyd.max_)(default)
+
     max = max_
 
     @t.overload
@@ -1874,14 +1881,14 @@ class AllFuncs:
         self: "Chain[t.Mapping[t.Any, T2]]",
         iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
         *,
-        default: T
+        default: T,
     ) -> "Chain[t.Union[T2, T]]": ...
     @t.overload
     def max_by(
         self: "Chain[t.Mapping[t.Any, 'SupportsRichComparisonT']]",
         iteratee: None = None,
         *,
-        default: T
+        default: T,
     ) -> "Chain[t.Union['SupportsRichComparisonT', T]]": ...
     @t.overload
     def max_by(
@@ -1900,7 +1907,7 @@ class AllFuncs:
         self: "Chain[t.Iterable[T2]]",
         iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
         *,
-        default: T
+        default: T,
     ) -> "Chain[t.Union[T2, T]]": ...
     @t.overload
     def max_by(
@@ -1966,6 +1973,7 @@ class AllFuncs:
     ) -> "Chain[t.Union['SupportsRichComparisonT', T]]": ...
     def min_(self, default=UNSET):
         return self._wrap(pyd.min_)(default)
+
     min = min_
 
     @t.overload
@@ -1985,14 +1993,14 @@ class AllFuncs:
         self: "Chain[t.Mapping[t.Any, T2]]",
         iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
         *,
-        default: T
+        default: T,
     ) -> "Chain[t.Union[T2, T]]": ...
     @t.overload
     def min_by(
         self: "Chain[t.Mapping[t.Any, 'SupportsRichComparisonT']]",
         iteratee: None = None,
         *,
-        default: T
+        default: T,
     ) -> "Chain[t.Union['SupportsRichComparisonT', T]]": ...
     @t.overload
     def min_by(
@@ -2011,7 +2019,7 @@ class AllFuncs:
         self: "Chain[t.Iterable[T2]]",
         iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
         *,
-        default: T
+        default: T,
     ) -> "Chain[t.Union[T2, T]]": ...
     @t.overload
     def min_by(
@@ -2067,6 +2075,7 @@ class AllFuncs:
     def round_(self: "Chain[SupportsRound[NumberT]]", precision: int = 0) -> "Chain[float]": ...
     def round_(self, precision=0):
         return self._wrap(pyd.round_)(precision)
+
     round = round_
 
     @t.overload
@@ -2161,31 +2170,31 @@ class AllFuncs:
     def assign_with(
         self: "Chain[t.Mapping[T, T2]]",
         *sources: t.Mapping[T3, t.Any],
-        customizer: t.Callable[[t.Union[T2, None]], T5]
+        customizer: t.Callable[[t.Union[T2, None]], T5],
     ) -> "Chain[t.Dict[t.Union[T, T3], t.Union[T2, T5]]]": ...
     @t.overload
     def assign_with(
         self: "Chain[t.Mapping[T, T2]]",
         *sources: t.Mapping[T3, T4],
-        customizer: t.Callable[[t.Union[T2, None], T4], T5]
+        customizer: t.Callable[[t.Union[T2, None], T4], T5],
     ) -> "Chain[t.Dict[t.Union[T, T3], t.Union[T2, T5]]]": ...
     @t.overload
     def assign_with(
         self: "Chain[t.Mapping[T, T2]]",
         *sources: t.Mapping[T3, T4],
-        customizer: t.Callable[[t.Union[T2, None], T4, T3], T5]
+        customizer: t.Callable[[t.Union[T2, None], T4, T3], T5],
     ) -> "Chain[t.Dict[t.Union[T, T3], t.Union[T2, T5]]]": ...
     @t.overload
     def assign_with(
         self: "Chain[t.Mapping[T, T2]]",
         *sources: t.Mapping[T3, T4],
-        customizer: t.Callable[[t.Union[T2, None], T4, T3, t.Dict[T, T2]], T5]
+        customizer: t.Callable[[t.Union[T2, None], T4, T3, t.Dict[T, T2]], T5],
     ) -> "Chain[t.Dict[t.Union[T, T3], t.Union[T2, T5]]]": ...
     @t.overload
     def assign_with(
         self: "Chain[t.Mapping[T, T2]]",
         *sources: t.Mapping[T3, T4],
-        customizer: t.Callable[[t.Union[T2, None], T4, T3, t.Dict[T, T2], t.Dict[T3, T4]], T5]
+        customizer: t.Callable[[t.Union[T2, None], T4, T3, t.Dict[T, T2], t.Dict[T3, T4]], T5],
     ) -> "Chain[t.Dict[t.Union[T, T3], t.Union[T2, T5]]]": ...
     @t.overload
     def assign_with(
@@ -2638,6 +2647,7 @@ class AllFuncs:
 
     def set_(self: "Chain[T]", path: PathT, value: t.Any) -> "Chain[T]":
         return self._wrap(pyd.set_)(path, value)
+
     set = set_
 
     def set_with(
@@ -3242,12 +3252,12 @@ class AllFuncs:
     @t.overload
     def cond(
         self: "Chain[t.List[t.Tuple[t.Callable[P, t.Any], t.Callable[P, T]]]]",
-        *extra_pairs: t.Tuple[t.Callable[P, t.Any], t.Callable[P, T]]
+        *extra_pairs: t.Tuple[t.Callable[P, t.Any], t.Callable[P, T]],
     ) -> "Chain[t.Callable[P, T]]": ...
     @t.overload
     def cond(
         self: "Chain[t.List[t.List[t.Callable[P, t.Any]]]]",
-        *extra_pairs: t.List[t.Callable[P, t.Any]]
+        *extra_pairs: t.List[t.Callable[P, t.Any]],
     ) -> "Chain[t.Callable[P, t.Any]]": ...
     def cond(self, *extra_pairs):
         return self._wrap(pyd.cond)(*extra_pairs)
@@ -3367,6 +3377,7 @@ class AllFuncs:
 
     def property_(self: "Chain[PathT]") -> "Chain[t.Callable[[t.Any], t.Any]]":
         return self._wrap(pyd.property_)()
+
     property = property_
 
     def properties(self: "Chain[t.Any]", *paths: t.Any) -> "Chain[t.Callable[[t.Any], t.Any]]":
@@ -3388,7 +3399,7 @@ class AllFuncs:
         self: "Chain[t.Union[float, int]]",
         stop: t.Union[float, int] = 1,
         *,
-        floating: Literal[True]
+        floating: Literal[True],
     ) -> "Chain[float]": ...
     def random(
         self: "Chain[t.Union[float, int]]", stop: t.Union[float, int] = 1, floating: bool = False
@@ -3403,6 +3414,7 @@ class AllFuncs:
     ) -> "Chain[t.Generator[int, None, None]]": ...
     def range_(self, *args):
         return self._wrap(pyd.range_)(*args)
+
     range = range_
 
     @t.overload
diff --git a/src/pydash/chaining/chaining.py b/src/pydash/chaining/chaining.py
index b0db638..71ab9db 100644
--- a/src/pydash/chaining/chaining.py
+++ b/src/pydash/chaining/chaining.py
@@ -19,26 +19,26 @@
     "thru",
 )
 
-Value_coT = t.TypeVar("Value_coT", covariant=True)
+ValueT_co = t.TypeVar("ValueT_co", covariant=True)
 T = t.TypeVar("T")
 T2 = t.TypeVar("T2")
 
 
-class Chain(AllFuncs, t.Generic[Value_coT]):
+class Chain(AllFuncs, t.Generic[ValueT_co]):
     """Enables chaining of :attr:`module` functions."""
 
     #: Object that contains attribute references to available methods.
     module = pyd
     invalid_method_exception = InvalidMethod
 
-    def __init__(self, value: t.Union[Value_coT, Unset] = UNSET) -> None:
+    def __init__(self, value: t.Union[ValueT_co, Unset] = UNSET) -> None:
         self._value = value
 
     def _wrap(self, func) -> "ChainWrapper":
         """Implement `AllFuncs` interface."""
         return ChainWrapper(self._value, func)
 
-    def value(self) -> Value_coT:
+    def value(self) -> ValueT_co:
         """
         Return current value of the chain operations.
 
@@ -56,7 +56,7 @@ def to_string(self) -> str:
         """
         return self.module.to_string(self.value())
 
-    def commit(self) -> "Chain[Value_coT]":
+    def commit(self) -> "Chain[ValueT_co]":
         """
         Executes the chained sequence and returns the wrapped result.
 
@@ -66,7 +66,7 @@ def commit(self) -> "Chain[Value_coT]":
         """
         return Chain(self.value())
 
-    def plant(self, value: t.Any) -> "Chain[Value_coT]":
+    def plant(self, value: t.Any) -> "Chain[ValueT_co]":
         """
         Return a clone of the chained sequence planting `value` as the wrapped value.
 
@@ -88,12 +88,13 @@ def plant(self, value: t.Any) -> "Chain[Value_coT]":
 
         for wrap in wrappers:
             clone = ChainWrapper(clone._value, wrap.method)(  # type: ignore
-                *wrap.args, **wrap.kwargs  # type: ignore
+                *wrap.args,  # type: ignore
+                **wrap.kwargs,  # type: ignore
             )
 
         return clone
 
-    def __call__(self, value) -> Value_coT:
+    def __call__(self, value) -> ValueT_co:
         """
         Return result of passing `value` through chained methods.
 
@@ -109,10 +110,10 @@ def __call__(self, value) -> Value_coT:
         return value
 
 
-class ChainWrapper(t.Generic[Value_coT]):
+class ChainWrapper(t.Generic[ValueT_co]):
     """Wrap :class:`Chain` method call within a :class:`ChainWrapper` context."""
 
-    def __init__(self, value: Value_coT, method) -> None:
+    def __init__(self, value: ValueT_co, method) -> None:
         self._value = value
         self.method = method
         self.args = ()
@@ -173,7 +174,7 @@ def __getattr__(self, attr):
         """Proxy to :meth:`Chain.get_method`."""
         return Chain.get_method(attr)
 
-    def __call__(self, value: t.Union[Value_coT, Unset] = UNSET) -> Chain[Value_coT]:
+    def __call__(self, value: t.Union[ValueT_co, Unset] = UNSET) -> Chain[ValueT_co]:
         """Return a new instance of :class:`Chain` with `value` as the seed."""
         return Chain(value)
 
@@ -203,7 +204,8 @@ def chain(value: t.Union[T, Unset] = UNSET) -> Chain[T]:
         >>> summer.value()
         10
 
-        >>> def echo(item): print(item)
+        >>> def echo(item):
+        ...     print(item)
         >>> summer = chain([1, 2, 3, 4]).for_each(echo).sum()
         >>> committed = summer.commit()
         1
@@ -250,7 +252,8 @@ def tap(value: T, interceptor: t.Callable[[T], t.Any]) -> T:
     Example:
 
         >>> data = []
-        >>> def log(value): data.append(value)
+        >>> def log(value):
+        ...     data.append(value)
         >>> chain([1, 2, 3, 4]).map(lambda x: x * 2).tap(log).value()
         [2, 4, 6, 8]
         >>> data
diff --git a/src/pydash/collections.py b/src/pydash/collections.py
index 44ca8a1..4e3db9e 100644
--- a/src/pydash/collections.py
+++ b/src/pydash/collections.py
@@ -55,19 +55,23 @@
 
 
 @t.overload
-def at(collection: t.Mapping[T, T2], *paths: T) -> t.List[t.Union[T2, None]]: ...
+def at(collection: t.Mapping[T, T2], *paths: T) -> t.List[t.Union[T2, None]]:
+    ...
 
 
 @t.overload
-def at(collection: t.Mapping[T, t.Any], *paths: t.Union[T, t.Iterable[T]]) -> t.List[t.Any]: ...
+def at(collection: t.Mapping[T, t.Any], *paths: t.Union[T, t.Iterable[T]]) -> t.List[t.Any]:
+    ...
 
 
 @t.overload
-def at(collection: t.Iterable[T], *paths: int) -> t.List[t.Union[T, None]]: ...
+def at(collection: t.Iterable[T], *paths: int) -> t.List[t.Union[T, None]]:
+    ...
 
 
 @t.overload
-def at(collection: t.Iterable[t.Any], *paths: t.Union[int, t.Iterable[int]]) -> t.List[t.Any]: ...
+def at(collection: t.Iterable[t.Any], *paths: t.Union[int, t.Iterable[int]]) -> t.List[t.Any]:
+    ...
 
 
 def at(collection, *paths):
@@ -87,9 +91,9 @@ def at(collection, *paths):
 
         >>> at([1, 2, 3, 4], 0, 2)
         [1, 3]
-        >>> at({'a': 1, 'b': 2, 'c': 3, 'd': 4}, 'a', 'c')
+        >>> at({"a": 1, "b": 2, "c": 3, "d": 4}, "a", "c")
         [1, 3]
-        >>> at({'a': 1, 'b': 2, 'c': {'d': {'e': 3}}}, 'a', ['c', 'd', 'e'])
+        >>> at({"a": 1, "b": 2, "c": {"d": {"e": 3}}}, "a", ["c", "d", "e"])
         [1, 3]
 
     .. versionadded:: 1.0.0
@@ -101,43 +105,47 @@ def at(collection, *paths):
 
 
 @t.overload
-def count_by(collection: t.Mapping[t.Any, T2], iteratee: None = None) -> t.Dict[T2, int]: ...
+def count_by(collection: t.Mapping[t.Any, T2], iteratee: None = None) -> t.Dict[T2, int]:
+    ...
 
 
 @t.overload
 def count_by(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], T3]
-) -> t.Dict[T3, int]: ...
+) -> t.Dict[T3, int]:
+    ...
 
 
 @t.overload
-def count_by(
-    collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]
-) -> t.Dict[T3, int]: ...
+def count_by(collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]) -> t.Dict[T3, int]:
+    ...
 
 
 @t.overload
-def count_by(
-    collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], T3]
-) -> t.Dict[T3, int]: ...
+def count_by(collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], T3]) -> t.Dict[T3, int]:
+    ...
 
 
 @t.overload
-def count_by(collection: t.Iterable[T], iteratee: None = None) -> t.Dict[T, int]: ...
+def count_by(collection: t.Iterable[T], iteratee: None = None) -> t.Dict[T, int]:
+    ...
 
 
 @t.overload
 def count_by(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]
-) -> t.Dict[T2, int]: ...
+) -> t.Dict[T2, int]:
+    ...
 
 
 @t.overload
-def count_by(collection: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.Dict[T2, int]: ...
+def count_by(collection: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.Dict[T2, int]:
+    ...
 
 
 @t.overload
-def count_by(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, int]: ...
+def count_by(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, int]:
+    ...
 
 
 def count_by(collection, iteratee=None):
@@ -156,9 +164,9 @@ def count_by(collection, iteratee=None):
 
         >>> results = count_by([1, 2, 1, 2, 3, 4])
         >>> assert results == {1: 2, 2: 2, 3: 1, 4: 1}
-        >>> results = count_by(['a', 'A', 'B', 'b'], lambda x: x.lower())
-        >>> assert results == {'a': 2, 'b': 2}
-        >>> results = count_by({'a': 1, 'b': 1, 'c': 3, 'd': 3})
+        >>> results = count_by(["a", "A", "B", "b"], lambda x: x.lower())
+        >>> assert results == {"a": 2, "b": 2}
+        >>> results = count_by({"a": 1, "b": 1, "c": 3, "d": 3})
         >>> assert results == {1: 2, 3: 2}
 
     .. versionadded:: 1.0.0
@@ -192,17 +200,17 @@ def every(
 
     Example:
 
-        >>> every([1, True, 'hello'])
+        >>> every([1, True, "hello"])
         True
-        >>> every([1, False, 'hello'])
+        >>> every([1, False, "hello"])
         False
-        >>> every([{'a': 1}, {'a': True}, {'a': 'hello'}], 'a')
+        >>> every([{"a": 1}, {"a": True}, {"a": "hello"}], "a")
         True
-        >>> every([{'a': 1}, {'a': False}, {'a': 'hello'}], 'a')
+        >>> every([{"a": 1}, {"a": False}, {"a": "hello"}], "a")
         False
-        >>> every([{'a': 1}, {'a': 1}], {'a': 1})
+        >>> every([{"a": 1}, {"a": 1}], {"a": 1})
         True
-        >>> every([{'a': 1}, {'a': 2}], {'a': 1})
+        >>> every([{"a": 1}, {"a": 2}], {"a": 1})
         False
 
     .. versionadded:: 1.0.0
@@ -221,42 +229,48 @@ def every(
 def filter_(
     collection: t.Mapping[T, T2],
     predicate: t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], IterateeObjT, None] = None,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def filter_(
     collection: t.Mapping[T, T2],
     predicate: t.Union[t.Callable[[T2, T], t.Any], IterateeObjT, None] = None,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def filter_(
     collection: t.Mapping[t.Any, T2],
     predicate: t.Union[t.Callable[[T2], t.Any], IterateeObjT, None] = None,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def filter_(
     collection: t.Iterable[T],
     predicate: t.Union[t.Callable[[T, int, t.List[T]], t.Any], IterateeObjT, None] = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def filter_(
     collection: t.Iterable[T],
     predicate: t.Union[t.Callable[[T, int], t.Any], IterateeObjT, None] = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def filter_(
     collection: t.Iterable[T],
     predicate: t.Union[t.Callable[[T], t.Any], IterateeObjT, None] = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def filter_(collection, predicate=None):
@@ -273,8 +287,8 @@ def filter_(collection, predicate=None):
 
     Example:
 
-        >>> results = filter_([{'a': 1}, {'b': 2}, {'a': 1, 'b': 3}], {'a': 1})
-        >>> assert results == [{'a': 1}, {'a': 1, 'b': 3}]
+        >>> results = filter_([{"a": 1}, {"b": 2}, {"a": 1, "b": 3}], {"a": 1})
+        >>> assert results == [{"a": 1}, {"a": 1, "b": 3}]
         >>> filter_([1, 2, 3, 4], lambda x: x >= 3)
         [3, 4]
 
@@ -290,42 +304,48 @@ def filter_(collection, predicate=None):
 def find(
     collection: t.Dict[T, T2],
     predicate: t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T2, None]: ...
+) -> t.Union[T2, None]:
+    ...
 
 
 @t.overload
 def find(
     collection: t.Dict[T, T2],
     predicate: t.Union[t.Callable[[T2, T], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T2, None]: ...
+) -> t.Union[T2, None]:
+    ...
 
 
 @t.overload
 def find(
     collection: t.Dict[T, T2],
     predicate: t.Union[t.Callable[[T2], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T2, None]: ...
+) -> t.Union[T2, None]:
+    ...
 
 
 @t.overload
 def find(
     collection: t.List[T],
     predicate: t.Union[t.Callable[[T, int, t.List[T]], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T, None]: ...
+) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
 def find(
     collection: t.List[T],
     predicate: t.Union[t.Callable[[T, int], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T, None]: ...
+) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
 def find(
     collection: t.List[T],
     predicate: t.Union[t.Callable[[T], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T, None]: ...
+) -> t.Union[T, None]:
+    ...
 
 
 def find(collection, predicate=None):
@@ -344,7 +364,7 @@ def find(collection, predicate=None):
 
         >>> find([1, 2, 3, 4], lambda x: x >= 3)
         3
-        >>> find([{'a': 1}, {'b': 2}, {'a': 1, 'b': 2}], {'a': 1})
+        >>> find([{"a": 1}, {"b": 2}, {"a": 1, "b": 2}], {"a": 1})
         {'a': 1}
 
     .. versionadded:: 1.0.0
@@ -360,42 +380,48 @@ def find(collection, predicate=None):
 def find_last(
     collection: t.Dict[T, T2],
     predicate: t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T2, None]: ...
+) -> t.Union[T2, None]:
+    ...
 
 
 @t.overload
 def find_last(
     collection: t.Dict[T, T2],
     predicate: t.Union[t.Callable[[T2, T], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T2, None]: ...
+) -> t.Union[T2, None]:
+    ...
 
 
 @t.overload
 def find_last(
     collection: t.Dict[t.Any, T2],
     predicate: t.Union[t.Callable[[T2], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T2, None]: ...
+) -> t.Union[T2, None]:
+    ...
 
 
 @t.overload
 def find_last(
     collection: t.List[T],
     predicate: t.Union[t.Callable[[T, int, t.List[T]], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T, None]: ...
+) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
 def find_last(
     collection: t.List[T],
     predicate: t.Union[t.Callable[[T, int], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T, None]: ...
+) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
 def find_last(
     collection: t.List[T],
     predicate: t.Union[t.Callable[[T], t.Any], IterateeObjT, None] = None,
-) -> t.Union[T, None]: ...
+) -> t.Union[T, None]:
+    ...
 
 
 def find_last(collection, predicate=None):
@@ -431,81 +457,95 @@ def find_last(collection, predicate=None):
 @t.overload
 def flat_map(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], t.Iterable[T3]]
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
 def flat_map(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], t.Iterable[T3]]
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
 def flat_map(
     collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], t.Iterable[T3]]
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
 def flat_map(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], T3]
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
-def flat_map(collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]) -> t.List[T3]: ...
+def flat_map(collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]) -> t.List[T3]:
+    ...
 
 
 @t.overload
-def flat_map(collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], T3]) -> t.List[T3]: ...
+def flat_map(collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], T3]) -> t.List[T3]:
+    ...
 
 
 @t.overload
-def flat_map(collection: t.Mapping[t.Any, t.Iterable[T2]], iteratee: None = None) -> t.List[T2]: ...
+def flat_map(collection: t.Mapping[t.Any, t.Iterable[T2]], iteratee: None = None) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def flat_map(collection: t.Mapping[t.Any, T2], iteratee: None = None) -> t.List[T2]: ...
+def flat_map(collection: t.Mapping[t.Any, T2], iteratee: None = None) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def flat_map(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], t.Iterable[T2]]
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def flat_map(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int], t.Iterable[T2]]
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def flat_map(
-    collection: t.Iterable[T], iteratee: t.Callable[[T], t.Iterable[T2]]
-) -> t.List[T2]: ...
+def flat_map(collection: t.Iterable[T], iteratee: t.Callable[[T], t.Iterable[T2]]) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def flat_map(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def flat_map(collection: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.List[T2]: ...
+def flat_map(collection: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def flat_map(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.List[T2]: ...
+def flat_map(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def flat_map(collection: t.Iterable[t.Iterable[T]], iteratee: None = None) -> t.List[T]: ...
+def flat_map(collection: t.Iterable[t.Iterable[T]], iteratee: None = None) -> t.List[T]:
+    ...
 
 
 @t.overload
-def flat_map(collection: t.Iterable[T], iteratee: None = None) -> t.List[T]: ...
+def flat_map(collection: t.Iterable[T], iteratee: None = None) -> t.List[T]:
+    ...
 
 
 def flat_map(collection, iteratee=None):
@@ -536,38 +576,44 @@ def flat_map(collection, iteratee=None):
 def flat_map_deep(
     collection: t.Mapping[T, T2],
     iteratee: t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], None] = None,
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
 def flat_map_deep(
     collection: t.Mapping[T, T2], iteratee: t.Union[t.Callable[[T2, T], t.Any], None] = None
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
 def flat_map_deep(
     collection: t.Mapping[t.Any, T2], iteratee: t.Union[t.Callable[[T2], t.Any], None] = None
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
 def flat_map_deep(
     collection: t.Iterable[T],
     iteratee: t.Union[t.Callable[[T, int, t.List[T]], t.Any], None] = None,
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
 def flat_map_deep(
     collection: t.Iterable[T], iteratee: t.Union[t.Callable[[T, int], t.Any], None] = None
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
 def flat_map_deep(
     collection: t.Iterable[T], iteratee: t.Union[t.Callable[[T], t.Any], None] = None
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 def flat_map_deep(collection: t.Iterable, iteratee=None):
@@ -597,7 +643,8 @@ def flat_map_depth(
     collection: t.Mapping[T, T2],
     iteratee: t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], None] = None,
     depth: int = 1,
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
@@ -605,7 +652,8 @@ def flat_map_depth(
     collection: t.Mapping[T, T2],
     iteratee: t.Union[t.Callable[[T2, T], t.Any], None] = None,
     depth: int = 1,
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
@@ -613,7 +661,8 @@ def flat_map_depth(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Union[t.Callable[[T2], t.Any], None] = None,
     depth: int = 1,
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
@@ -621,7 +670,8 @@ def flat_map_depth(
     collection: t.Iterable[T],
     iteratee: t.Union[t.Callable[[T, int, t.List[T]], t.Any], None] = None,
     depth: int = 1,
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
@@ -629,7 +679,8 @@ def flat_map_depth(
     collection: t.Iterable[T],
     iteratee: t.Union[t.Callable[[T, int], t.Any], None] = None,
     depth: int = 1,
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
@@ -637,7 +688,8 @@ def flat_map_depth(
     collection: t.Iterable[T],
     iteratee: t.Union[t.Callable[[T], t.Any], None] = None,
     depth: int = 1,
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 def flat_map_depth(collection, iteratee=None, depth=1):
@@ -669,42 +721,48 @@ def flat_map_depth(collection, iteratee=None, depth=1):
 def for_each(
     collection: t.Dict[T, T2],
     iteratee: t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], IterateeObjT, None] = None,
-) -> t.Dict[T, T2]: ...
+) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
 def for_each(
     collection: t.Dict[T, T2],
     iteratee: t.Union[t.Callable[[T2, T], t.Any], IterateeObjT, None] = None,
-) -> t.Dict[T, T2]: ...
+) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
 def for_each(
     collection: t.Dict[T, T2],
     iteratee: t.Union[t.Callable[[T2], t.Any], IterateeObjT, None] = None,
-) -> t.Dict[T, T2]: ...
+) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
 def for_each(
     collection: t.List[T],
     iteratee: t.Union[t.Callable[[T, int, t.List[T]], t.Any], IterateeObjT, None] = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def for_each(
     collection: t.List[T],
     iteratee: t.Union[t.Callable[[T, int], t.Any], IterateeObjT, None] = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def for_each(
     collection: t.List[T],
     iteratee: t.Union[t.Callable[[T], t.Any], IterateeObjT, None] = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def for_each(collection, iteratee=None):
@@ -721,7 +779,8 @@ def for_each(collection, iteratee=None):
     Example:
 
         >>> results = {}
-        >>> def cb(x): results[x] = x ** 2
+        >>> def cb(x):
+        ...     results[x] = x**2
         >>> for_each([1, 2, 3, 4], cb)
         [1, 2, 3, 4]
         >>> assert results == {1: 1, 2: 4, 3: 9, 4: 16}
@@ -739,42 +798,48 @@ def for_each(collection, iteratee=None):
 def for_each_right(
     collection: t.Dict[T, T2],
     iteratee: t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], IterateeObjT],
-) -> t.Dict[T, T2]: ...
+) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
 def for_each_right(
     collection: t.Dict[T, T2],
     iteratee: t.Union[t.Callable[[T2, T], t.Any], IterateeObjT],
-) -> t.Dict[T, T2]: ...
+) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
 def for_each_right(
     collection: t.Dict[T, T2],
     iteratee: t.Union[t.Callable[[T2], t.Any], IterateeObjT],
-) -> t.Dict[T, T2]: ...
+) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
 def for_each_right(
     collection: t.List[T],
     iteratee: t.Union[t.Callable[[T, int, t.List[T]], t.Any], IterateeObjT],
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def for_each_right(
     collection: t.List[T],
     iteratee: t.Union[t.Callable[[T, int], t.Any], IterateeObjT],
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def for_each_right(
     collection: t.List[T],
     iteratee: t.Union[t.Callable[[T], t.Any], IterateeObjT],
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def for_each_right(collection, iteratee):
@@ -791,11 +856,12 @@ def for_each_right(collection, iteratee):
 
     Example:
 
-        >>> results = {'total': 1}
-        >>> def cb(x): results['total'] = x * results['total']
+        >>> results = {"total": 1}
+        >>> def cb(x):
+        ...     results["total"] = x * results["total"]
         >>> for_each_right([1, 2, 3, 4], cb)
         [1, 2, 3, 4]
-        >>> assert results == {'total': 24}
+        >>> assert results == {"total": 24}
 
     .. versionadded:: 1.0.0
 
@@ -810,13 +876,15 @@ def for_each_right(collection, iteratee):
 
 
 @t.overload
-def group_by(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, t.List[T]]: ...
+def group_by(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, t.List[T]]:
+    ...
 
 
 @t.overload
 def group_by(
     collection: t.Iterable[T], iteratee: t.Union[IterateeObjT, None] = None
-) -> t.Dict[t.Any, t.List[T]]: ...
+) -> t.Dict[t.Any, t.List[T]]:
+    ...
 
 
 def group_by(collection, iteratee=None):
@@ -871,7 +939,7 @@ def includes(collection: t.Union[t.Sequence, t.Dict], target: t.Any, from_index:
         True
         >>> includes([1, 2, 3, 4], 2, from_index=2)
         False
-        >>> includes({'a': 1, 'b': 2, 'c': 3, 'd': 4}, 2)
+        >>> includes({"a": 1, "b": 2, "c": 3, "d": 4}, 2)
         True
 
     .. versionadded:: 1.0.0
@@ -908,9 +976,9 @@ def invoke_map(collection: t.Iterable, path: PathT, *args: t.Any, **kwargs: t.An
 
     Example:
 
-        >>> items = [{'a': [{'b': 1}]}, {'a': [{'c': 2}]}]
-        >>> expected = [{'b': 1}.items(), {'c': 2}.items()]
-        >>> invoke_map(items, 'a[0].items') == expected
+        >>> items = [{"a": [{"b": 1}]}, {"a": [{"c": 2}]}]
+        >>> expected = [{"b": 1}.items(), {"c": 2}.items()]
+        >>> invoke_map(items, "a[0].items") == expected
         True
 
     .. versionadded:: 4.0.0
@@ -919,11 +987,13 @@ def invoke_map(collection: t.Iterable, path: PathT, *args: t.Any, **kwargs: t.An
 
 
 @t.overload
-def key_by(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, T]: ...
+def key_by(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, T]:
+    ...
 
 
 @t.overload
-def key_by(collection: t.Iterable, iteratee: t.Union[IterateeObjT, None] = None) -> t.Dict: ...
+def key_by(collection: t.Iterable, iteratee: t.Union[IterateeObjT, None] = None) -> t.Dict:
+    ...
 
 
 def key_by(collection, iteratee=None):
@@ -940,8 +1010,8 @@ def key_by(collection, iteratee=None):
 
     Example:
 
-        >>> results = key_by([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}], 'a')
-        >>> assert results == {1: {'a': 1, 'b': 2}, 3: {'a': 3, 'b': 4}}
+        >>> results = key_by([{"a": 1, "b": 2}, {"a": 3, "b": 4}], "a")
+        >>> assert results == {1: {"a": 1, "b": 2}, 3: {"a": 3, "b": 4}}
 
 
     .. versionadded:: 1.0.0
@@ -959,35 +1029,40 @@ def key_by(collection, iteratee=None):
 
 
 @t.overload
-def map_(collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], T3]) -> t.List[T3]: ...
+def map_(collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], T3]) -> t.List[T3]:
+    ...
 
 
 @t.overload
-def map_(collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]) -> t.List[T3]: ...
+def map_(collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]) -> t.List[T3]:
+    ...
 
 
 @t.overload
 def map_(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], T3]
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
-def map_(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.List[T2]: ...
+def map_(collection: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def map_(collection: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.List[T2]: ...
+def map_(collection: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def map_(
-    collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]
-) -> t.List[T2]: ...
+def map_(collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def map_(collection: t.Iterable, iteratee: t.Union[IterateeObjT, None] = None) -> t.List: ...
+def map_(collection: t.Iterable, iteratee: t.Union[IterateeObjT, None] = None) -> t.List:
+    ...
 
 
 def map_(collection, iteratee=None):
@@ -1010,13 +1085,13 @@ def map_(collection, iteratee=None):
 
         >>> map_([1, 2, 3, 4], str)
         ['1', '2', '3', '4']
-        >>> map_([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}, {'a': 5, 'b': 6}], 'a')
+        >>> map_([{"a": 1, "b": 2}, {"a": 3, "b": 4}, {"a": 5, "b": 6}], "a")
         [1, 3, 5]
-        >>> map_([[[0, 1]], [[2, 3]], [[4, 5]]], '0.1')
+        >>> map_([[[0, 1]], [[2, 3]], [[4, 5]]], "0.1")
         [1, 3, 5]
-        >>> map_([{'a': {'b': 1}}, {'a': {'b': 2}}], 'a.b')
+        >>> map_([{"a": {"b": 1}}, {"a": {"b": 2}}], "a.b")
         [1, 2]
-        >>> map_([{'a': {'b': [0, 1]}}, {'a': {'b': [2, 3]}}], 'a.b[1]')
+        >>> map_([{"a": {"b": [0, 1]}}, {"a": {"b": [2, 3]}}], "a.b[1]")
         [1, 3]
 
     .. versionadded:: 1.0.0
@@ -1075,7 +1150,8 @@ def order_by(
     keys: t.Iterable[t.Union[str, int]],
     orders: t.Union[t.Iterable[bool], bool],
     reverse: bool = False,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1084,7 +1160,8 @@ def order_by(
     keys: t.Iterable[str],
     orders: None = None,
     reverse: bool = False,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1093,7 +1170,8 @@ def order_by(
     keys: t.Iterable[t.Union[str, int]],
     orders: t.Union[t.Iterable[bool], bool],
     reverse: bool = False,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
@@ -1102,7 +1180,8 @@ def order_by(
     keys: t.Iterable[str],
     orders: None = None,
     reverse: bool = False,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def order_by(collection, keys, orders=None, reverse=False):
@@ -1190,8 +1269,7 @@ def comparison(left, right):
             result = cmp(func(left), func(right))
             if result:
                 return mult * result
-        else:
-            return 0
+        return 0
 
     return sorted(collection, key=cmp_to_key(comparison), reverse=reverse)
 
@@ -1199,49 +1277,55 @@ def comparison(left, right):
 @t.overload
 def partition(
     collection: t.Mapping[T, T2], predicate: t.Callable[[T2, T, t.Dict[T, T2]], t.Any]
-) -> t.List[t.List[T2]]: ...
+) -> t.List[t.List[T2]]:
+    ...
 
 
 @t.overload
 def partition(
     collection: t.Mapping[T, T2], predicate: t.Callable[[T2, T], t.Any]
-) -> t.List[t.List[T2]]: ...
+) -> t.List[t.List[T2]]:
+    ...
 
 
 @t.overload
 def partition(
     collection: t.Mapping[t.Any, T2], predicate: t.Callable[[T2], t.Any]
-) -> t.List[t.List[T2]]: ...
+) -> t.List[t.List[T2]]:
+    ...
 
 
 @t.overload
 def partition(
     collection: t.Mapping[t.Any, T2], predicate: t.Union[IterateeObjT, None] = None
-) -> t.List[t.List[T2]]: ...
+) -> t.List[t.List[T2]]:
+    ...
 
 
 @t.overload
 def partition(
     collection: t.Iterable[T], predicate: t.Callable[[T, int, t.List[T]], t.Any]
-) -> t.List[t.List[T]]: ...
+) -> t.List[t.List[T]]:
+    ...
 
 
 @t.overload
 def partition(
     collection: t.Iterable[T], predicate: t.Callable[[T, int], t.Any]
-) -> t.List[t.List[T]]: ...
+) -> t.List[t.List[T]]:
+    ...
 
 
 @t.overload
-def partition(
-    collection: t.Iterable[T], predicate: t.Callable[[T], t.Any]
-) -> t.List[t.List[T]]: ...
+def partition(collection: t.Iterable[T], predicate: t.Callable[[T], t.Any]) -> t.List[t.List[T]]:
+    ...
 
 
 @t.overload
 def partition(
     collection: t.Iterable[T], predicate: t.Union[IterateeObjT, None] = None
-) -> t.List[t.List[T]]: ...
+) -> t.List[t.List[T]]:
+    ...
 
 
 def partition(collection, predicate=None):
@@ -1296,15 +1380,15 @@ def pluck(collection: t.Iterable, path: PathT) -> t.List:
 
     Example:
 
-        >>> pluck([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}, {'a': 5, 'b': 6}], 'a')
+        >>> pluck([{"a": 1, "b": 2}, {"a": 3, "b": 4}, {"a": 5, "b": 6}], "a")
         [1, 3, 5]
-        >>> pluck([[[0, 1]], [[2, 3]], [[4, 5]]], '0.1')
+        >>> pluck([[[0, 1]], [[2, 3]], [[4, 5]]], "0.1")
         [1, 3, 5]
-        >>> pluck([{'a': {'b': 1}}, {'a': {'b': 2}}], 'a.b')
+        >>> pluck([{"a": {"b": 1}}, {"a": {"b": 2}}], "a.b")
         [1, 2]
-        >>> pluck([{'a': {'b': [0, 1]}}, {'a': {'b': [2, 3]}}], 'a.b.1')
+        >>> pluck([{"a": {"b": [0, 1]}}, {"a": {"b": [2, 3]}}], "a.b.1")
         [1, 3]
-        >>> pluck([{'a': {'b': [0, 1]}}, {'a': {'b': [2, 3]}}], ['a', 'b', 1])
+        >>> pluck([{"a": {"b": [0, 1]}}, {"a": {"b": [2, 3]}}], ["a", "b", 1])
         [1, 3]
 
     .. versionadded:: 1.0.0
@@ -1323,7 +1407,8 @@ def reduce_(
     collection: t.Mapping[T, T2],
     iteratee: t.Callable[[T3, T2, T], T3],
     accumulator: T3,
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
@@ -1331,7 +1416,8 @@ def reduce_(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T3, T2], T3],
     accumulator: T3,
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
@@ -1339,7 +1425,8 @@ def reduce_(
     collection: t.Mapping,
     iteratee: t.Callable[[T3], T3],
     accumulator: T3,
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
@@ -1347,7 +1434,8 @@ def reduce_(
     collection: t.Mapping[T, T2],
     iteratee: t.Callable[[T2, T2, T], T2],
     accumulator: None = None,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1355,7 +1443,8 @@ def reduce_(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T2, T2], T2],
     accumulator: None = None,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1363,7 +1452,8 @@ def reduce_(
     collection: t.Mapping,
     iteratee: t.Callable[[T], T],
     accumulator: None = None,
-) -> T: ...
+) -> T:
+    ...
 
 
 @t.overload
@@ -1371,7 +1461,8 @@ def reduce_(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T2, T, int], T2],
     accumulator: T2,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1379,7 +1470,8 @@ def reduce_(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T2, T], T2],
     accumulator: T2,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1387,7 +1479,8 @@ def reduce_(
     collection: t.Iterable,
     iteratee: t.Callable[[T2], T2],
     accumulator: T2,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1395,7 +1488,8 @@ def reduce_(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T, T, int], T],
     accumulator: None = None,
-) -> T: ...
+) -> T:
+    ...
 
 
 @t.overload
@@ -1403,7 +1497,8 @@ def reduce_(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T, T], T],
     accumulator: None = None,
-) -> T: ...
+) -> T:
+    ...
 
 
 @t.overload
@@ -1411,13 +1506,15 @@ def reduce_(
     collection: t.Iterable,
     iteratee: t.Callable[[T], T],
     accumulator: None = None,
-) -> T: ...
+) -> T:
+    ...
 
 
 @t.overload
 def reduce_(
     collection: t.Iterable[T], iteratee: None = None, accumulator: t.Union[T, None] = None
-) -> T: ...
+) -> T:
+    ...
 
 
 def reduce_(collection, iteratee=None, accumulator=None):
@@ -1450,8 +1547,8 @@ def reduce_(collection, iteratee=None, accumulator=None):
     if accumulator is None:
         try:
             _, accumulator = next(iterable)
-        except StopIteration:
-            raise TypeError("reduce_() of empty sequence with no initial value")
+        except StopIteration as exc:
+            raise TypeError("reduce_() of empty sequence with no initial value") from exc
 
     result = accumulator
 
@@ -1472,7 +1569,8 @@ def reduce_right(
     collection: t.Mapping[T, T2],
     iteratee: t.Callable[[T3, T2, T], T3],
     accumulator: T3,
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
@@ -1480,7 +1578,8 @@ def reduce_right(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T3, T2], T3],
     accumulator: T3,
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
@@ -1488,7 +1587,8 @@ def reduce_right(
     collection: t.Mapping,
     iteratee: t.Callable[[T3], T3],
     accumulator: T3,
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
@@ -1496,7 +1596,8 @@ def reduce_right(
     collection: t.Mapping[T, T2],
     iteratee: t.Callable[[T2, T2, T], T2],
     accumulator: None = None,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1504,7 +1605,8 @@ def reduce_right(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T2, T2], T2],
     accumulator: None = None,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1512,7 +1614,8 @@ def reduce_right(
     collection: t.Mapping,
     iteratee: t.Callable[[T], T],
     accumulator: None = None,
-) -> T: ...
+) -> T:
+    ...
 
 
 @t.overload
@@ -1520,7 +1623,8 @@ def reduce_right(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T2, T, int], T2],
     accumulator: T2,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1528,7 +1632,8 @@ def reduce_right(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T2, T], T2],
     accumulator: T2,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1536,7 +1641,8 @@ def reduce_right(
     collection: t.Iterable,
     iteratee: t.Callable[[T2], T2],
     accumulator: T2,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -1544,7 +1650,8 @@ def reduce_right(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T, T, int], T],
     accumulator: None = None,
-) -> T: ...
+) -> T:
+    ...
 
 
 @t.overload
@@ -1552,7 +1659,8 @@ def reduce_right(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T, T], T],
     accumulator: None = None,
-) -> T: ...
+) -> T:
+    ...
 
 
 @t.overload
@@ -1560,13 +1668,15 @@ def reduce_right(
     collection: t.Iterable,
     iteratee: t.Callable[[T], T],
     accumulator: None = None,
-) -> T: ...
+) -> T:
+    ...
 
 
 @t.overload
 def reduce_right(
     collection: t.Iterable[T], iteratee: None = None, accumulator: t.Union[T, None] = None
-) -> T: ...
+) -> T:
+    ...
 
 
 def reduce_right(collection, iteratee=None, accumulator=None):
@@ -1585,7 +1695,7 @@ def reduce_right(collection, iteratee=None, accumulator=None):
 
     Example:
 
-        >>> reduce_right([1, 2, 3, 4], lambda total, x: total ** x)
+        >>> reduce_right([1, 2, 3, 4], lambda total, x: total**x)
         4096
 
     .. versionadded:: 1.0.0
@@ -1608,7 +1718,8 @@ def reductions(
     iteratee: t.Callable[[T3, T2, T], T3],
     accumulator: T3,
     from_right: bool = False,
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
@@ -1617,7 +1728,8 @@ def reductions(
     iteratee: t.Callable[[T3, T2], T3],
     accumulator: T3,
     from_right: bool = False,
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
@@ -1626,7 +1738,8 @@ def reductions(
     iteratee: t.Callable[[T3], T3],
     accumulator: T3,
     from_right: bool = False,
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
@@ -1635,7 +1748,8 @@ def reductions(
     iteratee: t.Callable[[T2, T2, T], T2],
     accumulator: None = None,
     from_right: bool = False,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1644,7 +1758,8 @@ def reductions(
     iteratee: t.Callable[[T2, T2], T2],
     accumulator: None = None,
     from_right: bool = False,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1653,7 +1768,8 @@ def reductions(
     iteratee: t.Callable[[T], T],
     accumulator: None = None,
     from_right: bool = False,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
@@ -1662,7 +1778,8 @@ def reductions(
     iteratee: t.Callable[[T2, T, int], T2],
     accumulator: T2,
     from_right: bool = False,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1671,7 +1788,8 @@ def reductions(
     iteratee: t.Callable[[T2, T], T2],
     accumulator: T2,
     from_right: bool = False,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1680,7 +1798,8 @@ def reductions(
     iteratee: t.Callable[[T2], T2],
     accumulator: T2,
     from_right: bool = False,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1689,7 +1808,8 @@ def reductions(
     iteratee: t.Callable[[T, T, int], T],
     accumulator: None = None,
     from_right: bool = False,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
@@ -1698,7 +1818,8 @@ def reductions(
     iteratee: t.Callable[[T, T], T],
     accumulator: None = None,
     from_right: bool = False,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
@@ -1707,7 +1828,8 @@ def reductions(
     iteratee: t.Callable[[T], T],
     accumulator: None = None,
     from_right: bool = False,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
@@ -1716,7 +1838,8 @@ def reductions(
     iteratee: None = None,
     accumulator: t.Union[T, None] = None,
     from_right: bool = False,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def reductions(collection, iteratee=None, accumulator=None, from_right=False):
@@ -1768,7 +1891,8 @@ def reductions_right(
     collection: t.Mapping[T, T2],
     iteratee: t.Callable[[T3, T2, T], T3],
     accumulator: T3,
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
@@ -1776,7 +1900,8 @@ def reductions_right(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T3, T2], T3],
     accumulator: T3,
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
@@ -1784,7 +1909,8 @@ def reductions_right(
     collection: t.Mapping,
     iteratee: t.Callable[[T3], T3],
     accumulator: T3,
-) -> t.List[T3]: ...
+) -> t.List[T3]:
+    ...
 
 
 @t.overload
@@ -1792,7 +1918,8 @@ def reductions_right(
     collection: t.Mapping[T, T2],
     iteratee: t.Callable[[T2, T2, T], T2],
     accumulator: None = None,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1800,7 +1927,8 @@ def reductions_right(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T2, T2], T2],
     accumulator: None = None,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1808,7 +1936,8 @@ def reductions_right(
     collection: t.Mapping,
     iteratee: t.Callable[[T], T],
     accumulator: None = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
@@ -1816,7 +1945,8 @@ def reductions_right(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T2, T, int], T2],
     accumulator: T2,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1824,7 +1954,8 @@ def reductions_right(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T2, T], T2],
     accumulator: T2,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1832,7 +1963,8 @@ def reductions_right(
     collection: t.Iterable,
     iteratee: t.Callable[[T2], T2],
     accumulator: T2,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -1840,7 +1972,8 @@ def reductions_right(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T, T, int], T],
     accumulator: None = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
@@ -1848,7 +1981,8 @@ def reductions_right(
     collection: t.Iterable[T],
     iteratee: t.Callable[[T, T], T],
     accumulator: None = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
@@ -1856,13 +1990,15 @@ def reductions_right(
     collection: t.Iterable,
     iteratee: t.Callable[[T], T],
     accumulator: None = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def reductions_right(
     collection: t.Iterable[T], iteratee: None = None, accumulator: t.Union[T, None] = None
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def reductions_right(collection, iteratee=None, accumulator=None):
@@ -1881,7 +2017,7 @@ def reductions_right(collection, iteratee=None, accumulator=None):
 
     Example:
 
-        >>> reductions_right([1, 2, 3, 4], lambda total, x: total ** x)
+        >>> reductions_right([1, 2, 3, 4], lambda total, x: total**x)
         [64, 4096, 4096]
 
     Note:
@@ -1897,42 +2033,48 @@ def reductions_right(collection, iteratee=None, accumulator=None):
 def reject(
     collection: t.Mapping[T, T2],
     predicate: t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], IterateeObjT, None] = None,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def reject(
     collection: t.Mapping[T, T2],
     predicate: t.Union[t.Callable[[T2, T], t.Any], IterateeObjT, None] = None,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def reject(
     collection: t.Mapping[t.Any, T2],
     predicate: t.Union[t.Callable[[T2], t.Any], IterateeObjT, None] = None,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
 def reject(
     collection: t.Iterable[T],
     predicate: t.Union[t.Callable[[T, int, t.List[T]], t.Any], IterateeObjT, None] = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def reject(
     collection: t.Iterable[T],
     predicate: t.Union[t.Callable[[T, int], t.Any], IterateeObjT, None] = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 @t.overload
 def reject(
     collection: t.Iterable[T],
     predicate: t.Union[t.Callable[[T], t.Any], IterateeObjT, None] = None,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def reject(collection, predicate=None):
@@ -1951,9 +2093,9 @@ def reject(collection, predicate=None):
 
         >>> reject([1, 2, 3, 4], lambda x: x >= 3)
         [1, 2]
-        >>> reject([{'a': 0}, {'a': 1}, {'a': 2}], 'a')
+        >>> reject([{"a": 0}, {"a": 1}, {"a": 2}], "a")
         [{'a': 0}]
-        >>> reject([{'a': 0}, {'a': 1}, {'a': 2}], {'a': 1})
+        >>> reject([{"a": 0}, {"a": 1}, {"a": 2}], {"a": 1})
         [{'a': 0}, {'a': 2}]
 
     .. versionadded:: 1.0.0
@@ -2011,11 +2153,13 @@ def sample_size(collection: t.Sequence[T], n: t.Union[int, None] = None) -> t.Li
 
 
 @t.overload
-def shuffle(collection: t.Mapping[t.Any, T]) -> t.List[T]: ...
+def shuffle(collection: t.Mapping[t.Any, T]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def shuffle(collection: t.Iterable[T]) -> t.List[T]: ...
+def shuffle(collection: t.Iterable[T]) -> t.List[T]:
+    ...
 
 
 def shuffle(collection):
@@ -2115,7 +2259,8 @@ def sort_by(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Union[t.Callable[[T2], t.Any], IterateeObjT, None] = None,
     reverse: bool = False,
-) -> t.List[T2]: ...
+) -> t.List[T2]:
+    ...
 
 
 @t.overload
@@ -2123,7 +2268,8 @@ def sort_by(
     collection: t.Iterable[T],
     iteratee: t.Union[t.Callable[[T], t.Any], IterateeObjT, None] = None,
     reverse: bool = False,
-) -> t.List[T]: ...
+) -> t.List[T]:
+    ...
 
 
 def sort_by(collection, iteratee=None, reverse=False):
@@ -2141,11 +2287,11 @@ def sort_by(collection, iteratee=None, reverse=False):
 
     Example:
 
-        >>> sort_by({'a': 2, 'b': 3, 'c': 1})
+        >>> sort_by({"a": 2, "b": 3, "c": 1})
         [1, 2, 3]
-        >>> sort_by({'a': 2, 'b': 3, 'c': 1}, reverse=True)
+        >>> sort_by({"a": 2, "b": 3, "c": 1}, reverse=True)
         [3, 2, 1]
-        >>> sort_by([{'a': 2}, {'a': 3}, {'a': 1}], 'a')
+        >>> sort_by([{"a": 2}, {"a": 3}, {"a": 1}], "a")
         [{'a': 1}, {'a': 2}, {'a': 3}]
 
     .. versionadded:: 1.0.0
diff --git a/src/pydash/functions.py b/src/pydash/functions.py
index 88a1a84..9eaccfb 100644
--- a/src/pydash/functions.py
+++ b/src/pydash/functions.py
@@ -133,7 +133,8 @@ def __init__(
         func5: t.Callable[[T5], T],
         *,
         from_right: bool = True,
-    ) -> None: ...
+    ) -> None:
+        ...
 
     @t.overload
     def __init__(
@@ -144,7 +145,8 @@ def __init__(
         func4: t.Callable[[T4], T],
         *,
         from_right: bool = True,
-    ) -> None: ...
+    ) -> None:
+        ...
 
     @t.overload
     def __init__(
@@ -154,15 +156,18 @@ def __init__(
         func3: t.Callable[[T3], T],
         *,
         from_right: bool = True,
-    ) -> None: ...
+    ) -> None:
+        ...
 
     @t.overload
     def __init__(
         self, func1: t.Callable[P, T2], func2: t.Callable[[T2], T], *, from_right: bool = True
-    ) -> None: ...
+    ) -> None:
+        ...
 
     @t.overload
-    def __init__(self, func1: t.Callable[P, T], *, from_right: bool = True) -> None: ...
+    def __init__(self, func1: t.Callable[P, T], *, from_right: bool = True) -> None:
+        ...
 
     def __init__(self, *funcs, from_right: bool = True) -> None:  # type: ignore
         self.funcs = funcs
@@ -247,10 +252,12 @@ def __call__(self, arg_one: T1) -> T:
 
 class CurryTwo(Curry[T1, CurryOne[T2, T]]):
     @t.overload
-    def __call__(self, arg_one: T1) -> CurryOne[T2, T]: ...
+    def __call__(self, arg_one: T1) -> CurryOne[T2, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T1, arg_two: T2) -> T: ...
+    def __call__(self, arg_one: T1, arg_two: T2) -> T:
+        ...
 
     def __call__(self, *args, **kwargs):
         return super().__call__(*args, **kwargs)  # pragma: no cover
@@ -258,13 +265,16 @@ def __call__(self, *args, **kwargs):
 
 class CurryThree(Curry[T1, CurryTwo[T2, T3, T]]):
     @t.overload
-    def __call__(self, arg_one: T1) -> CurryTwo[T2, T3, T]: ...
+    def __call__(self, arg_one: T1) -> CurryTwo[T2, T3, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T1, arg_two: T2) -> CurryOne[T3, T]: ...
+    def __call__(self, arg_one: T1, arg_two: T2) -> CurryOne[T3, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3) -> T: ...
+    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3) -> T:
+        ...
 
     def __call__(self, *args, **kwargs):
         return super().__call__(*args, **kwargs)  # pragma: no cover
@@ -272,16 +282,20 @@ def __call__(self, *args, **kwargs):
 
 class CurryFour(Curry[T1, CurryThree[T2, T3, T4, T]]):
     @t.overload
-    def __call__(self, arg_one: T1) -> CurryThree[T2, T3, T4, T]: ...
+    def __call__(self, arg_one: T1) -> CurryThree[T2, T3, T4, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T1, arg_two: T2) -> CurryTwo[T3, T4, T]: ...
+    def __call__(self, arg_one: T1, arg_two: T2) -> CurryTwo[T3, T4, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3) -> CurryOne[T4, T]: ...
+    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3) -> CurryOne[T4, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3, arg_four: T4) -> T: ...
+    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3, arg_four: T4) -> T:
+        ...
 
     def __call__(self, *args, **kwargs):
         return super().__call__(*args, **kwargs)  # pragma: no cover
@@ -289,23 +303,24 @@ def __call__(self, *args, **kwargs):
 
 class CurryFive(Curry[T1, CurryFour[T2, T3, T4, T5, T]]):
     @t.overload
-    def __call__(self, arg_one: T1) -> CurryFour[T2, T3, T4, T5, T]: ...
+    def __call__(self, arg_one: T1) -> CurryFour[T2, T3, T4, T5, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T1, arg_two: T2) -> CurryThree[T3, T4, T5, T]: ...
+    def __call__(self, arg_one: T1, arg_two: T2) -> CurryThree[T3, T4, T5, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3) -> CurryTwo[T4, T5, T]: ...
+    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3) -> CurryTwo[T4, T5, T]:
+        ...
 
     @t.overload
-    def __call__(
-        self, arg_one: T1, arg_two: T2, arg_three: T3, arg_four: T4
-    ) -> CurryOne[T5, T]: ...
+    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3, arg_four: T4) -> CurryOne[T5, T]:
+        ...
 
     @t.overload
-    def __call__(
-        self, arg_one: T1, arg_two: T2, arg_three: T3, arg_four: T4, arg_five: T5
-    ) -> T: ...
+    def __call__(self, arg_one: T1, arg_two: T2, arg_three: T3, arg_four: T4, arg_five: T5) -> T:
+        ...
 
     def __call__(self, *args, **kwargs):
         return super().__call__(*args, **kwargs)  # pragma: no cover
@@ -325,10 +340,12 @@ def __call__(self, arg_one: T5) -> T:
 
 class CurryRightTwo(CurryRight[T5, CurryRightOne[T4, T]]):
     @t.overload
-    def __call__(self, arg_one: T5) -> CurryRightOne[T4, T]: ...
+    def __call__(self, arg_one: T5) -> CurryRightOne[T4, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T5, arg_two: T4) -> T: ...
+    def __call__(self, arg_one: T5, arg_two: T4) -> T:
+        ...
 
     def __call__(self, *args, **kwargs):
         return super().__call__(*args, **kwargs)  # pragma: no cover
@@ -336,13 +353,16 @@ def __call__(self, *args, **kwargs):
 
 class CurryRightThree(CurryRight[T5, CurryRightTwo[T4, T3, T]]):
     @t.overload
-    def __call__(self, arg_one: T5) -> CurryRightTwo[T4, T3, T]: ...
+    def __call__(self, arg_one: T5) -> CurryRightTwo[T4, T3, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T5, arg_two: T4) -> CurryRightOne[T3, T]: ...
+    def __call__(self, arg_one: T5, arg_two: T4) -> CurryRightOne[T3, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T5, arg_two: T4, arg_three: T3) -> T: ...
+    def __call__(self, arg_one: T5, arg_two: T4, arg_three: T3) -> T:
+        ...
 
     def __call__(self, *args, **kwargs):
         return super().__call__(*args, **kwargs)  # pragma: no cover
@@ -350,16 +370,20 @@ def __call__(self, *args, **kwargs):
 
 class CurryRightFour(CurryRight[T5, CurryRightThree[T4, T3, T2, T]]):
     @t.overload
-    def __call__(self, arg_one: T5) -> CurryRightThree[T4, T3, T2, T]: ...
+    def __call__(self, arg_one: T5) -> CurryRightThree[T4, T3, T2, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T5, arg_two: T4) -> CurryRightTwo[T3, T2, T]: ...
+    def __call__(self, arg_one: T5, arg_two: T4) -> CurryRightTwo[T3, T2, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T5, arg_two: T4, arg_three: T3) -> CurryRightOne[T2, T]: ...
+    def __call__(self, arg_one: T5, arg_two: T4, arg_three: T3) -> CurryRightOne[T2, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T5, arg_two: T4, arg_three: T3, arg_four: T2) -> T: ...
+    def __call__(self, arg_one: T5, arg_two: T4, arg_three: T3, arg_four: T2) -> T:
+        ...
 
     def __call__(self, *args, **kwargs):
         return super().__call__(*args, **kwargs)  # pragma: no cover
@@ -367,23 +391,26 @@ def __call__(self, *args, **kwargs):
 
 class CurryRightFive(CurryRight[T5, CurryRightFour[T4, T3, T2, T1, T]]):
     @t.overload
-    def __call__(self, arg_one: T5) -> CurryRightFour[T4, T3, T2, T1, T]: ...
+    def __call__(self, arg_one: T5) -> CurryRightFour[T4, T3, T2, T1, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T5, arg_two: T4) -> CurryRightThree[T3, T2, T1, T]: ...
+    def __call__(self, arg_one: T5, arg_two: T4) -> CurryRightThree[T3, T2, T1, T]:
+        ...
 
     @t.overload
-    def __call__(self, arg_one: T5, arg_two: T4, arg_three: T3) -> CurryRightTwo[T2, T1, T]: ...
+    def __call__(self, arg_one: T5, arg_two: T4, arg_three: T3) -> CurryRightTwo[T2, T1, T]:
+        ...
 
     @t.overload
     def __call__(
         self, arg_one: T5, arg_two: T4, arg_three: T3, arg_four: T2
-    ) -> CurryRightOne[T1, T]: ...
+    ) -> CurryRightOne[T1, T]:
+        ...
 
     @t.overload
-    def __call__(
-        self, arg_one: T5, arg_two: T4, arg_three: T3, arg_four: T2, arg_five: T1
-    ) -> T: ...
+    def __call__(self, arg_one: T5, arg_two: T4, arg_three: T3, arg_four: T2, arg_five: T1) -> T:
+        ...
 
     def __call__(self, *args, **kwargs):
         return super().__call__(*args, **kwargs)  # pragma: no cover
@@ -754,31 +781,34 @@ def conjoin(*funcs: t.Callable[[T], t.Any]) -> t.Callable[[t.Iterable[T]], bool]
 
 
 @t.overload
-def curry(func: t.Callable[[T1], T], arity: t.Union[int, None] = None) -> CurryOne[T1, T]: ...
+def curry(func: t.Callable[[T1], T], arity: t.Union[int, None] = None) -> CurryOne[T1, T]:
+    ...
 
 
 @t.overload
-def curry(
-    func: t.Callable[[T1, T2], T], arity: t.Union[int, None] = None
-) -> CurryTwo[T1, T2, T]: ...
+def curry(func: t.Callable[[T1, T2], T], arity: t.Union[int, None] = None) -> CurryTwo[T1, T2, T]:
+    ...
 
 
 @t.overload
 def curry(
     func: t.Callable[[T1, T2, T3], T], arity: t.Union[int, None] = None
-) -> CurryThree[T1, T2, T3, T]: ...
+) -> CurryThree[T1, T2, T3, T]:
+    ...
 
 
 @t.overload
 def curry(
     func: t.Callable[[T1, T2, T3, T4], T], arity: t.Union[int, None] = None
-) -> CurryFour[T1, T2, T3, T4, T]: ...
+) -> CurryFour[T1, T2, T3, T4, T]:
+    ...
 
 
 @t.overload
 def curry(
     func: t.Callable[[T1, T2, T3, T4, T5], T], arity: t.Union[int, None] = None
-) -> CurryFive[T1, T2, T3, T4, T5, T]: ...
+) -> CurryFive[T1, T2, T3, T4, T5, T]:
+    ...
 
 
 def curry(func, arity=None):
@@ -815,31 +845,34 @@ def curry(func, arity=None):
 @t.overload
 def curry_right(
     func: t.Callable[[T1], T], arity: t.Union[int, None] = None
-) -> CurryRightOne[T1, T]: ...
+) -> CurryRightOne[T1, T]:
+    ...
 
 
 @t.overload
 def curry_right(
     func: t.Callable[[T1, T2], T], arity: t.Union[int, None] = None
-) -> CurryRightTwo[T2, T1, T]: ...
+) -> CurryRightTwo[T2, T1, T]:
+    ...
 
 
 @t.overload
 def curry_right(
     func: t.Callable[[T1, T2, T3], T], arity: t.Union[int, None] = None
-) -> CurryRightThree[T3, T2, T1, T]: ...
+) -> CurryRightThree[T3, T2, T1, T]:
+    ...
 
 
 @t.overload
 def curry_right(
     func: t.Callable[[T1, T2, T3, T4], T], arity: t.Union[int, None] = None
-) -> CurryRightFour[T4, T3, T2, T1, T]: ...
+) -> CurryRightFour[T4, T3, T2, T1, T]:
+    ...
 
 
 @t.overload
-def curry_right(
-    func: t.Callable[[T1, T2, T3, T4, T5], T]
-) -> CurryRightFive[T5, T4, T3, T2, T1, T]: ...
+def curry_right(func: t.Callable[[T1, T2, T3, T4, T5], T]) -> CurryRightFive[T5, T4, T3, T2, T1, T]:
+    ...
 
 
 def curry_right(func, arity=None):
@@ -941,23 +974,28 @@ def disjoin(*funcs: t.Callable[[T], t.Any]) -> Disjoin[T]:
 
 
 @t.overload
-def flip(func: t.Callable[[T1, T2, T3, T4, T5], T]) -> t.Callable[[T5, T4, T3, T2, T1], T]: ...
+def flip(func: t.Callable[[T1, T2, T3, T4, T5], T]) -> t.Callable[[T5, T4, T3, T2, T1], T]:
+    ...
 
 
 @t.overload
-def flip(func: t.Callable[[T1, T2, T3, T4], T]) -> t.Callable[[T4, T3, T2, T1], T]: ...
+def flip(func: t.Callable[[T1, T2, T3, T4], T]) -> t.Callable[[T4, T3, T2, T1], T]:
+    ...
 
 
 @t.overload
-def flip(func: t.Callable[[T1, T2, T3], T]) -> t.Callable[[T3, T2, T1], T]: ...
+def flip(func: t.Callable[[T1, T2, T3], T]) -> t.Callable[[T3, T2, T1], T]:
+    ...
 
 
 @t.overload
-def flip(func: t.Callable[[T1, T2], T]) -> t.Callable[[T2, T1], T]: ...
+def flip(func: t.Callable[[T1, T2], T]) -> t.Callable[[T2, T1], T]:
+    ...
 
 
 @t.overload
-def flip(func: t.Callable[[T1], T]) -> t.Callable[[T1], T]: ...
+def flip(func: t.Callable[[T1], T]) -> t.Callable[[T1], T]:
+    ...
 
 
 def flip(func: t.Callable) -> t.Callable:
@@ -991,7 +1029,8 @@ def flow(
     func3: t.Callable[[T3], T4],
     func4: t.Callable[[T4], T5],
     func5: t.Callable[[T5], T],
-) -> Flow[P, T]: ...
+) -> Flow[P, T]:
+    ...
 
 
 @t.overload
@@ -1000,7 +1039,8 @@ def flow(
     func2: t.Callable[[T2], T3],
     func3: t.Callable[[T3], T4],
     func4: t.Callable[[T4], T],
-) -> Flow[P, T]: ...
+) -> Flow[P, T]:
+    ...
 
 
 @t.overload
@@ -1008,15 +1048,18 @@ def flow(
     func1: t.Callable[P, T2],
     func2: t.Callable[[T2], T3],
     func3: t.Callable[[T3], T],
-) -> Flow[P, T]: ...
+) -> Flow[P, T]:
+    ...
 
 
 @t.overload
-def flow(func1: t.Callable[P, T2], func2: t.Callable[[T2], T]) -> Flow[P, T]: ...
+def flow(func1: t.Callable[P, T2], func2: t.Callable[[T2], T]) -> Flow[P, T]:
+    ...
 
 
 @t.overload
-def flow(func1: t.Callable[P, T]) -> Flow[P, T]: ...
+def flow(func1: t.Callable[P, T]) -> Flow[P, T]:
+    ...
 
 
 def flow(*funcs):
@@ -1035,7 +1078,7 @@ def flow(*funcs):
 
         >>> mult_5 = lambda x: x * 5
         >>> div_10 = lambda x: x / 10.0
-        >>> pow_2 = lambda x: x ** 2
+        >>> pow_2 = lambda x: x**2
         >>> ops = flow(sum, mult_5, div_10, pow_2)
         >>> ops([1, 2, 3, 4])
         25.0
@@ -1058,7 +1101,8 @@ def flow_right(
     func3: t.Callable[[T2], T3],
     func2: t.Callable[[T1], T2],
     func1: t.Callable[P, T1],
-) -> Flow[P, T]: ...
+) -> Flow[P, T]:
+    ...
 
 
 @t.overload
@@ -1067,7 +1111,8 @@ def flow_right(
     func3: t.Callable[[T2], T3],
     func2: t.Callable[[T1], T2],
     func1: t.Callable[P, T1],
-) -> Flow[P, T]: ...
+) -> Flow[P, T]:
+    ...
 
 
 @t.overload
@@ -1075,15 +1120,18 @@ def flow_right(
     func3: t.Callable[[T2], T],
     func2: t.Callable[[T1], T2],
     func1: t.Callable[P, T1],
-) -> Flow[P, T]: ...
+) -> Flow[P, T]:
+    ...
 
 
 @t.overload
-def flow_right(func2: t.Callable[[T1], T], func1: t.Callable[P, T1]) -> Flow[P, T]: ...
+def flow_right(func2: t.Callable[[T1], T], func1: t.Callable[P, T1]) -> Flow[P, T]:
+    ...
 
 
 @t.overload
-def flow_right(func1: t.Callable[P, T]) -> Flow[P, T]: ...
+def flow_right(func1: t.Callable[P, T]) -> Flow[P, T]:
+    ...
 
 
 def flow_right(*funcs):
@@ -1102,7 +1150,7 @@ def flow_right(*funcs):
 
         >>> mult_5 = lambda x: x * 5
         >>> div_10 = lambda x: x / 10.0
-        >>> pow_2 = lambda x: x ** 2
+        >>> pow_2 = lambda x: x**2
         >>> ops = flow_right(mult_5, div_10, pow_2, sum)
         >>> ops([1, 2, 3, 4])
         50.0
@@ -1188,7 +1236,7 @@ def negate(func: t.Callable[P, t.Any]) -> Negate[P]:
         >>> not_is_number = negate(lambda x: isinstance(x, (int, float)))
         >>> not_is_number(1)
         False
-        >>> not_is_number('1')
+        >>> not_is_number("1")
         True
 
     .. versionadded:: 1.1.0
@@ -1228,7 +1276,8 @@ def over_args(
     transform_three: t.Callable[[T3], T3],
     transform_four: t.Callable[[T4], T4],
     transform_five: t.Callable[[T5], T5],
-) -> t.Callable[[T1, T2, T3, T4, T5], T]: ...
+) -> t.Callable[[T1, T2, T3, T4, T5], T]:
+    ...
 
 
 @t.overload
@@ -1238,7 +1287,8 @@ def over_args(
     transform_two: t.Callable[[T2], T2],
     transform_three: t.Callable[[T3], T3],
     transform_four: t.Callable[[T4], T4],
-) -> t.Callable[[T1, T2, T3, T4], T]: ...
+) -> t.Callable[[T1, T2, T3, T4], T]:
+    ...
 
 
 @t.overload
@@ -1247,7 +1297,8 @@ def over_args(
     transform_one: t.Callable[[T1], T1],
     transform_two: t.Callable[[T2], T2],
     transform_three: t.Callable[[T3], T3],
-) -> t.Callable[[T1, T2, T3], T]: ...
+) -> t.Callable[[T1, T2, T3], T]:
+    ...
 
 
 @t.overload
@@ -1255,14 +1306,16 @@ def over_args(
     func: t.Callable[[T1, T2], T],
     transform_one: t.Callable[[T1], T1],
     transform_two: t.Callable[[T2], T2],
-) -> t.Callable[[T1, T2], T]: ...
+) -> t.Callable[[T1, T2], T]:
+    ...
 
 
 @t.overload
 def over_args(
     func: t.Callable[[T1], T],
     transform_one: t.Callable[[T1], T1],
-) -> t.Callable[[T1], T]: ...
+) -> t.Callable[[T1], T]:
+    ...
 
 
 def over_args(func: t.Callable, *transforms: t.Callable) -> t.Callable:  # type: ignore
@@ -1279,7 +1332,7 @@ def over_args(func: t.Callable, *transforms: t.Callable) -> t.Callable:  # type:
 
     Example:
 
-        >>> squared = lambda x: x ** 2
+        >>> squared = lambda x: x**2
         >>> double = lambda x: x * 2
         >>> modder = over_args(lambda x, y: [x, y], squared, double)
         >>> modder(5, 10)
@@ -1364,7 +1417,7 @@ def rearg(func: t.Callable[P, T], *indexes: int) -> Rearg[P, T]:
         >>> jumble = rearg(lambda *args: args, 1, 2, 3)
         >>> jumble(1, 2, 3)
         (2, 3, 1)
-        >>> jumble('a', 'b', 'c', 'd', 'e')
+        >>> jumble("a", "b", "c", "d", "e")
         ('b', 'c', 'd', 'a', 'e')
 
     .. versionadded:: 3.0.0
@@ -1385,8 +1438,8 @@ def spread(func: t.Callable[..., T]) -> Spread[T]:
 
     Example:
 
-        >>> greet = spread(lambda *people: 'Hello ' + ', '.join(people) + '!')
-        >>> greet(['Mike', 'Don', 'Leo'])
+        >>> greet = spread(lambda *people: "Hello " + ", ".join(people) + "!")
+        >>> greet(["Mike", "Don", "Leo"])
         'Hello Mike, Don, Leo!'
 
     .. versionadded:: 3.1.0
@@ -1450,7 +1503,7 @@ def wrap(value: T1, func: t.Callable[Concatenate[T1, P], T]) -> Partial[T]:
 
     Example:
 
-        >>> wrapper = wrap('hello', lambda *args: args)
+        >>> wrapper = wrap("hello", lambda *args: args)
         >>> wrapper(1, 2)
         ('hello', 1, 2)
 
diff --git a/src/pydash/helpers.py b/src/pydash/helpers.py
index 7c47b41..a96068f 100644
--- a/src/pydash/helpers.py
+++ b/src/pydash/helpers.py
@@ -13,7 +13,8 @@
 
 #: Singleton object that differentiates between an explicit ``None`` value and an unset value.
 #: As a class so it has its own type
-class Unset: ...
+class Unset:
+    ...
 
 
 UNSET = Unset()
@@ -259,10 +260,7 @@ def parse_iteratee(iteratee_keyword, *args, **kwargs):
     last_arg = args[-1]
 
     if iteratee is None and (
-        callable(last_arg)
-        or isinstance(last_arg, str)
-        or isinstance(last_arg, dict)
-        or last_arg is None
+        callable(last_arg) or isinstance(last_arg, (dict, str)) or last_arg is None
     ):
         iteratee = last_arg
         args = args[:-1]
diff --git a/src/pydash/numerical.py b/src/pydash/numerical.py
index 7152dc4..0bf4ea4 100644
--- a/src/pydash/numerical.py
+++ b/src/pydash/numerical.py
@@ -57,11 +57,13 @@
 
 
 @t.overload
-def add(a: "SupportsAdd[T, T2]", b: T) -> T2: ...
+def add(a: "SupportsAdd[T, T2]", b: T) -> T2:
+    ...
 
 
 @t.overload
-def add(a: T, b: "SupportsAdd[T, T2]") -> T2: ...
+def add(a: T, b: "SupportsAdd[T, T2]") -> T2:
+    ...
 
 
 def add(a, b):
@@ -92,11 +94,13 @@ def add(a, b):
 
 
 @t.overload
-def sum_(collection: t.Mapping[t.Any, "SupportsAdd[int, T]"]) -> T: ...
+def sum_(collection: t.Mapping[t.Any, "SupportsAdd[int, T]"]) -> T:
+    ...
 
 
 @t.overload
-def sum_(collection: t.Iterable["SupportsAdd[int, T]"]) -> T: ...
+def sum_(collection: t.Iterable["SupportsAdd[int, T]"]) -> T:
+    ...
 
 
 def sum_(collection):
@@ -130,43 +134,49 @@ def sum_(collection):
 def sum_by(
     collection: t.Mapping[T, T2],
     iteratee: t.Callable[[T2, T, t.Dict[T, T2]], "SupportsAdd[int, T3]"],
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
 def sum_by(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], "SupportsAdd[int, T3]"]
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
 def sum_by(
     collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], "SupportsAdd[int, T3]"]
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
 def sum_by(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], "SupportsAdd[int, T2]"]
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
-def sum_by(
-    collection: t.Iterable[T], iteratee: t.Callable[[T, int], "SupportsAdd[int, T2]"]
-) -> T2: ...
+def sum_by(collection: t.Iterable[T], iteratee: t.Callable[[T, int], "SupportsAdd[int, T2]"]) -> T2:
+    ...
 
 
 @t.overload
-def sum_by(collection: t.Iterable[T], iteratee: t.Callable[[T], "SupportsAdd[int, T2]"]) -> T2: ...
+def sum_by(collection: t.Iterable[T], iteratee: t.Callable[[T], "SupportsAdd[int, T2]"]) -> T2:
+    ...
 
 
 @t.overload
-def sum_by(collection: t.Mapping[t.Any, "SupportsAdd[int, T]"], iteratee: None = None) -> T: ...
+def sum_by(collection: t.Mapping[t.Any, "SupportsAdd[int, T]"], iteratee: None = None) -> T:
+    ...
 
 
 @t.overload
-def sum_by(collection: t.Iterable["SupportsAdd[int, T]"], iteratee: None = None) -> T: ...
+def sum_by(collection: t.Iterable["SupportsAdd[int, T]"], iteratee: None = None) -> T:
+    ...
 
 
 def sum_by(collection, iteratee=None):
@@ -183,7 +193,7 @@ def sum_by(collection, iteratee=None):
 
     Example:
 
-        >>> sum_by([1, 2, 3, 4], lambda x: x ** 2)
+        >>> sum_by([1, 2, 3, 4], lambda x: x**2)
         30
 
     .. versionadded:: 4.0.0
@@ -192,11 +202,13 @@ def sum_by(collection, iteratee=None):
 
 
 @t.overload
-def mean(collection: t.Mapping[t.Any, "SupportsAdd[int, t.Any]"]) -> float: ...
+def mean(collection: t.Mapping[t.Any, "SupportsAdd[int, t.Any]"]) -> float:
+    ...
 
 
 @t.overload
-def mean(collection: t.Iterable["SupportsAdd[int, t.Any]"]) -> float: ...
+def mean(collection: t.Iterable["SupportsAdd[int, t.Any]"]) -> float:
+    ...
 
 
 def mean(collection):
@@ -228,47 +240,55 @@ def mean(collection):
 def mean_by(
     collection: t.Mapping[T, T2],
     iteratee: t.Callable[[T2, T, t.Dict[T, T2]], "SupportsAdd[int, t.Any]"],
-) -> float: ...
+) -> float:
+    ...
 
 
 @t.overload
 def mean_by(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], "SupportsAdd[int, t.Any]"]
-) -> float: ...
+) -> float:
+    ...
 
 
 @t.overload
 def mean_by(
     collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], "SupportsAdd[int, t.Any]"]
-) -> float: ...
+) -> float:
+    ...
 
 
 @t.overload
 def mean_by(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], "SupportsAdd[int, t.Any]"]
-) -> float: ...
+) -> float:
+    ...
 
 
 @t.overload
 def mean_by(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int], "SupportsAdd[int, t.Any]"]
-) -> float: ...
+) -> float:
+    ...
 
 
 @t.overload
 def mean_by(
     collection: t.Iterable[T], iteratee: t.Callable[[T], "SupportsAdd[int, t.Any]"]
-) -> float: ...
+) -> float:
+    ...
 
 
 @t.overload
 def mean_by(
     collection: t.Mapping[t.Any, "SupportsAdd[int, t.Any]"], iteratee: None = None
-) -> float: ...
+) -> float:
+    ...
 
 
 @t.overload
-def mean_by(collection: t.Iterable["SupportsAdd[int, t.Any]"], iteratee: None = None) -> float: ...
+def mean_by(collection: t.Iterable["SupportsAdd[int, t.Any]"], iteratee: None = None) -> float:
+    ...
 
 
 def mean_by(collection, iteratee=None):
@@ -285,7 +305,7 @@ def mean_by(collection, iteratee=None):
 
     Example:
 
-        >>> mean_by([1, 2, 3, 4], lambda x: x ** 2)
+        >>> mean_by([1, 2, 3, 4], lambda x: x**2)
         7.5
 
     .. versionadded:: 4.0.0
@@ -415,25 +435,29 @@ def floor(x: NumberT, precision: int = 0) -> float:
 @t.overload
 def max_(
     collection: t.Mapping[t.Any, "SupportsRichComparisonT"], default: Unset = UNSET
-) -> "SupportsRichComparisonT": ...
+) -> "SupportsRichComparisonT":
+    ...
 
 
 @t.overload
 def max_(
     collection: t.Mapping[t.Any, "SupportsRichComparisonT"], default: T
-) -> t.Union["SupportsRichComparisonT", T]: ...
+) -> t.Union["SupportsRichComparisonT", T]:
+    ...
 
 
 @t.overload
 def max_(
     collection: t.Iterable["SupportsRichComparisonT"], default: Unset = UNSET
-) -> "SupportsRichComparisonT": ...
+) -> "SupportsRichComparisonT":
+    ...
 
 
 @t.overload
 def max_(
     collection: t.Iterable["SupportsRichComparisonT"], default: T
-) -> t.Union["SupportsRichComparisonT", T]: ...
+) -> t.Union["SupportsRichComparisonT", T]:
+    ...
 
 
 def max_(collection, default=UNSET):
@@ -467,7 +491,8 @@ def max_by(
     collection: t.Mapping[t.Any, "SupportsRichComparisonT"],
     iteratee: None = None,
     default: Unset = UNSET,
-) -> "SupportsRichComparisonT": ...
+) -> "SupportsRichComparisonT":
+    ...
 
 
 @t.overload
@@ -475,7 +500,8 @@ def max_by(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
     default: Unset = UNSET,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -483,20 +509,23 @@ def max_by(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
     *,
-    default: T
-) -> t.Union[T2, T]: ...
+    default: T,
+) -> t.Union[T2, T]:
+    ...
 
 
 @t.overload
 def max_by(
     collection: t.Mapping[t.Any, "SupportsRichComparisonT"], iteratee: None = None, *, default: T
-) -> t.Union["SupportsRichComparisonT", T]: ...
+) -> t.Union["SupportsRichComparisonT", T]:
+    ...
 
 
 @t.overload
 def max_by(
     collection: t.Iterable["SupportsRichComparisonT"], iteratee: None = None, default: Unset = UNSET
-) -> "SupportsRichComparisonT": ...
+) -> "SupportsRichComparisonT":
+    ...
 
 
 @t.overload
@@ -504,27 +533,32 @@ def max_by(
     collection: t.Iterable[T2],
     iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
     default: Unset = UNSET,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
 def max_by(
     collection: t.Iterable[T2], iteratee: t.Callable[[T2], "SupportsRichComparisonT"], *, default: T
-) -> t.Union[T2, T]: ...
+) -> t.Union[T2, T]:
+    ...
 
 
 @t.overload
 def max_by(
     collection: t.Iterable["SupportsRichComparisonT"], iteratee: None = None, *, default: T
-) -> t.Union["SupportsRichComparisonT", T]: ...
+) -> t.Union["SupportsRichComparisonT", T]:
+    ...
 
 
 @t.overload
-def max_by(collection: t.Iterable[T], iteratee: IterateeObjT, default: Unset = UNSET) -> T: ...
+def max_by(collection: t.Iterable[T], iteratee: IterateeObjT, default: Unset = UNSET) -> T:
+    ...
 
 
 @t.overload
-def max_by(collection: t.Iterable[T], iteratee: IterateeObjT, default: T2) -> t.Union[T, T2]: ...
+def max_by(collection: t.Iterable[T], iteratee: IterateeObjT, default: T2) -> t.Union[T, T2]:
+    ...
 
 
 def max_by(collection, iteratee=None, default=UNSET):
@@ -543,7 +577,7 @@ def max_by(collection, iteratee=None, default=UNSET):
 
         >>> max_by([1.0, 1.5, 1.8], math.floor)
         1.0
-        >>> max_by([{'a': 1}, {'a': 2}, {'a': 3}], 'a')
+        >>> max_by([{"a": 1}, {"a": 2}, {"a": 3}], "a")
         {'a': 3}
         >>> max_by([], default=-1)
         -1
@@ -559,41 +593,46 @@ def max_by(collection, iteratee=None, default=UNSET):
 @t.overload
 def median(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], NumberT]
-) -> t.Union[float, int]: ...
+) -> t.Union[float, int]:
+    ...
 
 
 @t.overload
 def median(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], NumberT]
-) -> t.Union[float, int]: ...
+) -> t.Union[float, int]:
+    ...
 
 
 @t.overload
 def median(
     collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], NumberT]
-) -> t.Union[float, int]: ...
+) -> t.Union[float, int]:
+    ...
 
 
 @t.overload
 def median(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], NumberT]
-) -> t.Union[float, int]: ...
+) -> t.Union[float, int]:
+    ...
 
 
 @t.overload
 def median(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int], NumberT]
-) -> t.Union[float, int]: ...
+) -> t.Union[float, int]:
+    ...
 
 
 @t.overload
-def median(
-    collection: t.Iterable[T], iteratee: t.Callable[[T], NumberT]
-) -> t.Union[float, int]: ...
+def median(collection: t.Iterable[T], iteratee: t.Callable[[T], NumberT]) -> t.Union[float, int]:
+    ...
 
 
 @t.overload
-def median(collection: t.Iterable[NumberT], iteratee: None = None) -> t.Union[float, int]: ...
+def median(collection: t.Iterable[NumberT], iteratee: None = None) -> t.Union[float, int]:
+    ...
 
 
 def median(collection, iteratee=None):
@@ -634,25 +673,29 @@ def median(collection, iteratee=None):
 @t.overload
 def min_(
     collection: t.Mapping[t.Any, "SupportsRichComparisonT"], default: Unset = UNSET
-) -> "SupportsRichComparisonT": ...
+) -> "SupportsRichComparisonT":
+    ...
 
 
 @t.overload
 def min_(
     collection: t.Mapping[t.Any, "SupportsRichComparisonT"], default: T
-) -> t.Union["SupportsRichComparisonT", T]: ...
+) -> t.Union["SupportsRichComparisonT", T]:
+    ...
 
 
 @t.overload
 def min_(
     collection: t.Iterable["SupportsRichComparisonT"], default: Unset = UNSET
-) -> "SupportsRichComparisonT": ...
+) -> "SupportsRichComparisonT":
+    ...
 
 
 @t.overload
 def min_(
     collection: t.Iterable["SupportsRichComparisonT"], default: T
-) -> t.Union["SupportsRichComparisonT", T]: ...
+) -> t.Union["SupportsRichComparisonT", T]:
+    ...
 
 
 def min_(collection, default=UNSET):
@@ -686,7 +729,8 @@ def min_by(
     collection: t.Mapping[t.Any, "SupportsRichComparisonT"],
     iteratee: None = None,
     default: Unset = UNSET,
-) -> "SupportsRichComparisonT": ...
+) -> "SupportsRichComparisonT":
+    ...
 
 
 @t.overload
@@ -694,7 +738,8 @@ def min_by(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
     default: Unset = UNSET,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
@@ -702,20 +747,23 @@ def min_by(
     collection: t.Mapping[t.Any, T2],
     iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
     *,
-    default: T
-) -> t.Union[T2, T]: ...
+    default: T,
+) -> t.Union[T2, T]:
+    ...
 
 
 @t.overload
 def min_by(
     collection: t.Mapping[t.Any, "SupportsRichComparisonT"], iteratee: None = None, *, default: T
-) -> t.Union["SupportsRichComparisonT", T]: ...
+) -> t.Union["SupportsRichComparisonT", T]:
+    ...
 
 
 @t.overload
 def min_by(
     collection: t.Iterable["SupportsRichComparisonT"], iteratee: None = None, default: Unset = UNSET
-) -> "SupportsRichComparisonT": ...
+) -> "SupportsRichComparisonT":
+    ...
 
 
 @t.overload
@@ -723,27 +771,32 @@ def min_by(
     collection: t.Iterable[T2],
     iteratee: t.Callable[[T2], "SupportsRichComparisonT"],
     default: Unset = UNSET,
-) -> T2: ...
+) -> T2:
+    ...
 
 
 @t.overload
 def min_by(
     collection: t.Iterable[T2], iteratee: t.Callable[[T2], "SupportsRichComparisonT"], *, default: T
-) -> t.Union[T2, T]: ...
+) -> t.Union[T2, T]:
+    ...
 
 
 @t.overload
 def min_by(
     collection: t.Iterable["SupportsRichComparisonT"], iteratee: None = None, *, default: T
-) -> t.Union["SupportsRichComparisonT", T]: ...
+) -> t.Union["SupportsRichComparisonT", T]:
+    ...
 
 
 @t.overload
-def min_by(collection: t.Iterable[T], iteratee: IterateeObjT, default: Unset = UNSET) -> T: ...
+def min_by(collection: t.Iterable[T], iteratee: IterateeObjT, default: Unset = UNSET) -> T:
+    ...
 
 
 @t.overload
-def min_by(collection: t.Iterable[T], iteratee: IterateeObjT, default: T2) -> t.Union[T, T2]: ...
+def min_by(collection: t.Iterable[T], iteratee: IterateeObjT, default: T2) -> t.Union[T, T2]:
+    ...
 
 
 def min_by(collection, iteratee=None, default=UNSET):
@@ -762,7 +815,7 @@ def min_by(collection, iteratee=None, default=UNSET):
 
         >>> min_by([1.8, 1.5, 1.0], math.floor)
         1.8
-        >>> min_by([{'a': 1}, {'a': 2}, {'a': 3}], 'a')
+        >>> min_by([{"a": 1}, {"a": 2}, {"a": 3}], "a")
         {'a': 1}
         >>> min_by([], default=100)
         100
@@ -812,23 +865,28 @@ def moving_mean(array: t.Sequence["SupportsAdd[int, t.Any]"], size: t.SupportsIn
 
 
 @t.overload
-def multiply(multiplier: SupportsMul[int, T2], multiplicand: None) -> T2: ...
+def multiply(multiplier: SupportsMul[int, T2], multiplicand: None) -> T2:
+    ...
 
 
 @t.overload
-def multiply(multiplier: None, multiplicand: SupportsMul[int, T2]) -> T2: ...
+def multiply(multiplier: None, multiplicand: SupportsMul[int, T2]) -> T2:
+    ...
 
 
 @t.overload
-def multiply(multiplier: None, multiplicand: None) -> int: ...
+def multiply(multiplier: None, multiplicand: None) -> int:
+    ...
 
 
 @t.overload
-def multiply(multiplier: SupportsMul[T, T2], multiplicand: T) -> T2: ...
+def multiply(multiplier: SupportsMul[T, T2], multiplicand: T) -> T2:
+    ...
 
 
 @t.overload
-def multiply(multiplier: T, multiplicand: SupportsMul[T, T2]) -> T2: ...
+def multiply(multiplier: T, multiplicand: SupportsMul[T, T2]) -> T2:
+    ...
 
 
 def multiply(multiplier, multiplicand):
@@ -859,19 +917,23 @@ def multiply(multiplier, multiplicand):
 
 
 @t.overload
-def power(x: int, n: int) -> t.Union[int, float]: ...
+def power(x: int, n: int) -> t.Union[int, float]:
+    ...
 
 
 @t.overload
-def power(x: float, n: t.Union[int, float]) -> float: ...
+def power(x: float, n: t.Union[int, float]) -> float:
+    ...
 
 
 @t.overload
-def power(x: t.List[int], n: int) -> t.List[t.Union[int, float]]: ...
+def power(x: t.List[int], n: int) -> t.List[t.Union[int, float]]:
+    ...
 
 
 @t.overload
-def power(x: t.List[float], n: t.List[t.Union[int, float]]) -> t.List[float]: ...
+def power(x: t.List[float], n: t.List[t.Union[int, float]]) -> t.List[float]:
+    ...
 
 
 def power(x, n):
@@ -908,11 +970,13 @@ def power(x, n):
 
 
 @t.overload
-def round_(x: t.List[SupportsRound[NumberT]], precision: int = 0) -> t.List[float]: ...
+def round_(x: t.List[SupportsRound[NumberT]], precision: int = 0) -> t.List[float]:
+    ...
 
 
 @t.overload
-def round_(x: SupportsRound[NumberT], precision: int = 0) -> float: ...
+def round_(x: SupportsRound[NumberT], precision: int = 0) -> float:
+    ...
 
 
 def round_(x, precision=0):
@@ -942,15 +1006,18 @@ def round_(x, precision=0):
 
 
 @t.overload
-def scale(array: t.Iterable["Decimal"], maximum: "Decimal") -> t.List["Decimal"]: ...
+def scale(array: t.Iterable["Decimal"], maximum: "Decimal") -> t.List["Decimal"]:
+    ...
 
 
 @t.overload
-def scale(array: t.Iterable[NumberNoDecimalT], maximum: NumberNoDecimalT) -> t.List[float]: ...
+def scale(array: t.Iterable[NumberNoDecimalT], maximum: NumberNoDecimalT) -> t.List[float]:
+    ...
 
 
 @t.overload
-def scale(array: t.Iterable[NumberT], maximum: int = 1) -> t.List[float]: ...
+def scale(array: t.Iterable[NumberT], maximum: int = 1) -> t.List[float]:
+    ...
 
 
 def scale(array, maximum: NumberT = 1):
@@ -986,14 +1053,16 @@ def scale(array, maximum: NumberT = 1):
 def slope(
     point1: t.Union[t.Tuple["Decimal", "Decimal"], t.List["Decimal"]],
     point2: t.Union[t.Tuple["Decimal", "Decimal"], t.List["Decimal"]],
-) -> "Decimal": ...
+) -> "Decimal":
+    ...
 
 
 @t.overload
 def slope(
     point1: t.Union[t.Tuple[NumberNoDecimalT, NumberNoDecimalT], t.List[NumberNoDecimalT]],
     point2: t.Union[t.Tuple[NumberNoDecimalT, NumberNoDecimalT], t.List[NumberNoDecimalT]],
-) -> float: ...
+) -> float:
+    ...
 
 
 def slope(point1, point2):
@@ -1049,11 +1118,13 @@ def std_deviation(array: t.List[NumberT]) -> float:
 
 
 @t.overload
-def subtract(minuend: "SupportsSub[T, T2]", subtrahend: T) -> T2: ...
+def subtract(minuend: "SupportsSub[T, T2]", subtrahend: T) -> T2:
+    ...
 
 
 @t.overload
-def subtract(minuend: T, subtrahend: "SupportsSub[T, T2]") -> T2: ...
+def subtract(minuend: T, subtrahend: "SupportsSub[T, T2]") -> T2:
+    ...
 
 
 def subtract(minuend, subtrahend):
@@ -1108,11 +1179,13 @@ def transpose(array: t.Iterable[t.Iterable[T]]) -> t.List[t.List[T]]:
 
 
 @t.overload
-def variance(array: t.Mapping[t.Any, "SupportsAdd[int, t.Any]"]) -> float: ...
+def variance(array: t.Mapping[t.Any, "SupportsAdd[int, t.Any]"]) -> float:
+    ...
 
 
 @t.overload
-def variance(array: t.Iterable["SupportsAdd[int, t.Any]"]) -> float: ...
+def variance(array: t.Iterable["SupportsAdd[int, t.Any]"]) -> float:
+    ...
 
 
 def variance(array):
@@ -1143,37 +1216,40 @@ def var(x):
 @t.overload
 def zscore(
     collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], NumberT]
-) -> t.List[float]: ...
+) -> t.List[float]:
+    ...
 
 
 @t.overload
-def zscore(
-    collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], NumberT]
-) -> t.List[float]: ...
+def zscore(collection: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], NumberT]) -> t.List[float]:
+    ...
 
 
 @t.overload
-def zscore(
-    collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], NumberT]
-) -> t.List[float]: ...
+def zscore(collection: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], NumberT]) -> t.List[float]:
+    ...
 
 
 @t.overload
 def zscore(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], NumberT]
-) -> t.List[float]: ...
+) -> t.List[float]:
+    ...
 
 
 @t.overload
-def zscore(collection: t.Iterable[T], iteratee: t.Callable[[T, int], NumberT]) -> t.List[float]: ...
+def zscore(collection: t.Iterable[T], iteratee: t.Callable[[T, int], NumberT]) -> t.List[float]:
+    ...
 
 
 @t.overload
-def zscore(collection: t.Iterable[T], iteratee: t.Callable[[T], NumberT]) -> t.List[float]: ...
+def zscore(collection: t.Iterable[T], iteratee: t.Callable[[T], NumberT]) -> t.List[float]:
+    ...
 
 
 @t.overload
-def zscore(collection: t.Iterable[NumberT], iteratee: None = None) -> t.List[float]: ...
+def zscore(collection: t.Iterable[NumberT], iteratee: None = None) -> t.List[float]:
+    ...
 
 
 def zscore(collection, iteratee=None):
diff --git a/src/pydash/objects.py b/src/pydash/objects.py
index 778f367..d5a7c66 100644
--- a/src/pydash/objects.py
+++ b/src/pydash/objects.py
@@ -77,13 +77,15 @@
 @t.overload
 def assign(
     obj: t.Mapping[T, T2], *sources: t.Mapping[T3, T4]
-) -> t.Dict[t.Union[T, T3], t.Union[T2, T4]]: ...
+) -> t.Dict[t.Union[T, T3], t.Union[T2, T4]]:
+    ...
 
 
 @t.overload
 def assign(
     obj: t.Union[t.Tuple[T, ...], t.List[T]], *sources: t.Mapping[int, T2]
-) -> t.List[t.Union[T, T2]]: ...
+) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 def assign(obj, *sources) -> t.Union[t.List, t.Dict]:
@@ -103,8 +105,8 @@ def assign(obj, *sources) -> t.Union[t.List, t.Dict]:
     Example:
 
         >>> obj = {}
-        >>> obj2 = assign(obj, {'a': 1}, {'b': 2}, {'c': 3})
-        >>> obj == {'a': 1, 'b': 2, 'c': 3}
+        >>> obj2 = assign(obj, {"a": 1}, {"b": 2}, {"c": 3})
+        >>> obj == {"a": 1, "b": 2, "c": 3}
         True
         >>> obj is obj2
         True
@@ -133,7 +135,8 @@ def assign_with(
     obj: t.Mapping[T, T2],
     *sources: t.Mapping[T3, t.Any],
     customizer: t.Callable[[t.Union[T2, None]], T5],
-) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]: ...
+) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]:
+    ...
 
 
 @t.overload
@@ -141,7 +144,8 @@ def assign_with(
     obj: t.Mapping[T, T2],
     *sources: t.Mapping[T3, T4],
     customizer: t.Callable[[t.Union[T2, None], T4], T5],
-) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]: ...
+) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]:
+    ...
 
 
 @t.overload
@@ -149,7 +153,8 @@ def assign_with(
     obj: t.Mapping[T, T2],
     *sources: t.Mapping[T3, T4],
     customizer: t.Callable[[t.Union[T2, None], T4, T3], T5],
-) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]: ...
+) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]:
+    ...
 
 
 @t.overload
@@ -157,7 +162,8 @@ def assign_with(
     obj: t.Mapping[T, T2],
     *sources: t.Mapping[T3, T4],
     customizer: t.Callable[[t.Union[T2, None], T4, T3, t.Dict[T, T2]], T5],
-) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]: ...
+) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]:
+    ...
 
 
 @t.overload
@@ -165,13 +171,15 @@ def assign_with(
     obj: t.Mapping[T, T2],
     *sources: t.Mapping[T3, T4],
     customizer: t.Callable[[t.Union[T2, None], T4, T3, t.Dict[T, T2], t.Dict[T3, T4]], T5],
-) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]: ...
+) -> t.Dict[t.Union[T, T3], t.Union[T2, T5]]:
+    ...
 
 
 @t.overload
 def assign_with(
     obj: t.Mapping[T, T2], *sources: t.Mapping[T3, T4], customizer: None = None
-) -> t.Dict[t.Union[T, T3], t.Union[T2, T4]]: ...
+) -> t.Dict[t.Union[T, T3], t.Union[T2, T4]]:
+    ...
 
 
 def assign_with(obj, *sources, customizer=None):
@@ -197,8 +205,8 @@ def assign_with(obj, *sources, customizer=None):
     Example:
 
         >>> customizer = lambda o, s: s if o is None else o
-        >>> results = assign_with({'a': 1}, {'b': 2}, {'a': 3}, customizer)
-        >>> results == {'a': 1, 'b': 2}
+        >>> results = assign_with({"a": 1}, {"b": 2}, {"a": 3}, customizer)
+        >>> results == {"a": 1, "b": 2}
         True
 
     .. versionadded:: 4.0.0
@@ -229,12 +237,14 @@ def assign_with(obj, *sources, customizer=None):
 
 @t.overload
 def callables(
-    obj: t.Mapping["SupportsRichComparisonT", t.Any]
-) -> t.List["SupportsRichComparisonT"]: ...
+    obj: t.Mapping["SupportsRichComparisonT", t.Any],
+) -> t.List["SupportsRichComparisonT"]:
+    ...
 
 
 @t.overload
-def callables(obj: t.Iterable[T]) -> t.List[T]: ...
+def callables(obj: t.Iterable[T]) -> t.List[T]:
+    ...
 
 
 def callables(obj) -> t.List:
@@ -249,7 +259,7 @@ def callables(obj) -> t.List:
 
     Example:
 
-        >>> callables({'a': 1, 'b': lambda: 2, 'c': lambda: 3})
+        >>> callables({"a": 1, "b": lambda: 2, "c": lambda: 3})
         ['b', 'c']
 
     .. versionadded:: 1.0.0
@@ -272,13 +282,13 @@ def clone(value: T) -> T:
 
     Example:
 
-        >>> x = {'a': 1, 'b': 2, 'c': {'d': 3}}
+        >>> x = {"a": 1, "b": 2, "c": {"d": 3}}
         >>> y = clone(x)
         >>> y == y
         True
         >>> x is y
         False
-        >>> x['c'] is y['c']
+        >>> x["c"] is y["c"]
         True
 
     Returns:
@@ -295,43 +305,49 @@ def clone(value: T) -> T:
 @t.overload
 def clone_with(
     value: t.Mapping[T, T2], customizer: t.Callable[[T2, T, t.Mapping[T, T2]], T3]
-) -> t.Dict[T, t.Union[T2, T3]]: ...
+) -> t.Dict[T, t.Union[T2, T3]]:
+    ...
 
 
 @t.overload
 def clone_with(
     value: t.Mapping[T, T2], customizer: t.Callable[[T2, T], T3]
-) -> t.Dict[T, t.Union[T2, T3]]: ...
+) -> t.Dict[T, t.Union[T2, T3]]:
+    ...
 
 
 @t.overload
 def clone_with(
     value: t.Mapping[T, T2], customizer: t.Callable[[T2], T3]
-) -> t.Dict[T, t.Union[T2, T3]]: ...
+) -> t.Dict[T, t.Union[T2, T3]]:
+    ...
 
 
 @t.overload
 def clone_with(
     value: t.List[T], customizer: t.Callable[[T, int, t.List[T]], T2]
-) -> t.List[t.Union[T, T2]]: ...
+) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 @t.overload
-def clone_with(
-    value: t.List[T], customizer: t.Callable[[T, int], T2]
-) -> t.List[t.Union[T, T2]]: ...
+def clone_with(value: t.List[T], customizer: t.Callable[[T, int], T2]) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 @t.overload
-def clone_with(value: t.List[T], customizer: t.Callable[[T], T2]) -> t.List[t.Union[T, T2]]: ...
+def clone_with(value: t.List[T], customizer: t.Callable[[T], T2]) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 @t.overload
-def clone_with(value: T, customizer: None = None) -> T: ...
+def clone_with(value: T, customizer: None = None) -> T:
+    ...
 
 
 @t.overload
-def clone_with(value: t.Any, customizer: t.Callable) -> t.Any: ...
+def clone_with(value: t.Any, customizer: t.Callable) -> t.Any:
+    ...
 
 
 def clone_with(value, customizer=None):
@@ -349,10 +365,10 @@ def clone_with(value, customizer=None):
 
     Example:
 
-        >>> x = {'a': 1, 'b': 2, 'c': {'d': 3}}
+        >>> x = {"a": 1, "b": 2, "c": {"d": 3}}
         >>> cbk = lambda v, k: v + 2 if isinstance(v, int) and k else None
         >>> y = clone_with(x, cbk)
-        >>> y == {'a': 3, 'b': 4, 'c': {'d': 3}}
+        >>> y == {"a": 3, "b": 4, "c": {"d": 3}}
         True
     """
     return base_clone(value, customizer=customizer)
@@ -371,13 +387,13 @@ def clone_deep(value: T) -> T:
 
     Example:
 
-        >>> x = {'a': 1, 'b': 2, 'c': {'d': 3}}
+        >>> x = {"a": 1, "b": 2, "c": {"d": 3}}
         >>> y = clone_deep(x)
         >>> y == y
         True
         >>> x is y
         False
-        >>> x['c'] is y['c']
+        >>> x["c"] is y["c"]
         False
 
     .. versionadded:: 1.0.0
@@ -391,45 +407,51 @@ def clone_deep(value: T) -> T:
 @t.overload
 def clone_deep_with(
     value: t.Mapping[T, T2], customizer: t.Callable[[T2, T, t.Mapping[T, T2]], T3]
-) -> t.Dict[T, t.Union[T2, T3]]: ...
+) -> t.Dict[T, t.Union[T2, T3]]:
+    ...
 
 
 @t.overload
 def clone_deep_with(
     value: t.Mapping[T, T2], customizer: t.Callable[[T2, T], T3]
-) -> t.Dict[T, t.Union[T2, T3]]: ...
+) -> t.Dict[T, t.Union[T2, T3]]:
+    ...
 
 
 @t.overload
 def clone_deep_with(
     value: t.Mapping[T, T2], customizer: t.Callable[[T2], T3]
-) -> t.Dict[T, t.Union[T2, T3]]: ...
+) -> t.Dict[T, t.Union[T2, T3]]:
+    ...
 
 
 @t.overload
 def clone_deep_with(
     value: t.List[T], customizer: t.Callable[[T, int, t.List[T]], T2]
-) -> t.List[t.Union[T, T2]]: ...
+) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 @t.overload
 def clone_deep_with(
     value: t.List[T], customizer: t.Callable[[T, int], T2]
-) -> t.List[t.Union[T, T2]]: ...
+) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 @t.overload
-def clone_deep_with(
-    value: t.List[T], customizer: t.Callable[[T], T2]
-) -> t.List[t.Union[T, T2]]: ...
+def clone_deep_with(value: t.List[T], customizer: t.Callable[[T], T2]) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 @t.overload
-def clone_deep_with(value: T, customizer: None = None) -> T: ...
+def clone_deep_with(value: T, customizer: None = None) -> T:
+    ...
 
 
 @t.overload
-def clone_deep_with(value: t.Any, customizer: t.Callable) -> t.Any: ...
+def clone_deep_with(value: t.Any, customizer: t.Callable) -> t.Any:
+    ...
 
 
 def clone_deep_with(value, customizer=None):
@@ -465,11 +487,11 @@ def defaults(
 
     Example:
 
-        >>> obj = {'a': 1}
-        >>> obj2 = defaults(obj, {'b': 2}, {'c': 3}, {'a': 4})
+        >>> obj = {"a": 1}
+        >>> obj2 = defaults(obj, {"b": 2}, {"c": 3}, {"a": 4})
         >>> obj is obj2
         True
-        >>> obj == {'a': 1, 'b': 2, 'c': 3}
+        >>> obj == {"a": 1, "b": 2, "c": 3}
         True
 
     .. versionadded:: 1.0.0
@@ -499,11 +521,11 @@ def defaults_deep(
 
     Example:
 
-        >>> obj = {'a': {'b': 1}}
-        >>> obj2 = defaults_deep(obj, {'a': {'b': 2, 'c': 3}})
+        >>> obj = {"a": {"b": 1}}
+        >>> obj2 = defaults_deep(obj, {"a": {"b": 2, "c": 3}})
         >>> obj is obj2
         True
-        >>> obj == {'a': {'b': 1, 'c': 3}}
+        >>> obj == {"a": {"b": 1, "c": 3}}
         True
 
     .. versionadded:: 3.3.0
@@ -519,39 +541,47 @@ def setter(obj, key, value):
 @t.overload
 def find_key(
     obj: t.Mapping[T, T2], predicate: t.Callable[[T2, T, t.Dict[T, T2]], t.Any]
-) -> t.Union[T, None]: ...
+) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
-def find_key(obj: t.Mapping[T, T2], predicate: t.Callable[[T2, T], t.Any]) -> t.Union[T, None]: ...
+def find_key(obj: t.Mapping[T, T2], predicate: t.Callable[[T2, T], t.Any]) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
-def find_key(obj: t.Mapping[T, T2], predicate: t.Callable[[T2], t.Any]) -> t.Union[T, None]: ...
+def find_key(obj: t.Mapping[T, T2], predicate: t.Callable[[T2], t.Any]) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
-def find_key(obj: t.Mapping[T, t.Any], predicate: None = None) -> t.Union[T, None]: ...
+def find_key(obj: t.Mapping[T, t.Any], predicate: None = None) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
 def find_key(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], t.Any]
-) -> t.Union[int, None]: ...
+) -> t.Union[int, None]:
+    ...
 
 
 @t.overload
 def find_key(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int], t.Any]
-) -> t.Union[int, None]: ...
+) -> t.Union[int, None]:
+    ...
 
 
 @t.overload
-def find_key(collection: t.Iterable[T], iteratee: t.Callable[[T], t.Any]) -> t.Union[int, None]: ...
+def find_key(collection: t.Iterable[T], iteratee: t.Callable[[T], t.Any]) -> t.Union[int, None]:
+    ...
 
 
 @t.overload
-def find_key(collection: t.Iterable[t.Any], iteratee: None = None) -> t.Union[int, None]: ...
+def find_key(collection: t.Iterable[t.Any], iteratee: None = None) -> t.Union[int, None]:
+    ...
 
 
 def find_key(obj, predicate=None):
@@ -568,7 +598,7 @@ def find_key(obj, predicate=None):
 
     Example:
 
-        >>> find_key({'a': 1, 'b': 2, 'c': 3}, lambda x: x == 1)
+        >>> find_key({"a": 1, "b": 2, "c": 3}, lambda x: x == 1)
         'a'
         >>> find_key([1, 2, 3, 4], lambda x: x == 1)
         0
@@ -583,45 +613,49 @@ def find_key(obj, predicate=None):
 @t.overload
 def find_last_key(
     obj: t.Mapping[T, T2], predicate: t.Callable[[T2, T, t.Dict[T, T2]], t.Any]
-) -> t.Union[T, None]: ...
+) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
-def find_last_key(
-    obj: t.Mapping[T, T2], predicate: t.Callable[[T2, T], t.Any]
-) -> t.Union[T, None]: ...
+def find_last_key(obj: t.Mapping[T, T2], predicate: t.Callable[[T2, T], t.Any]) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
-def find_last_key(
-    obj: t.Mapping[T, T2], predicate: t.Callable[[T2], t.Any]
-) -> t.Union[T, None]: ...
+def find_last_key(obj: t.Mapping[T, T2], predicate: t.Callable[[T2], t.Any]) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
-def find_last_key(obj: t.Mapping[T, t.Any], predicate: None = None) -> t.Union[T, None]: ...
+def find_last_key(obj: t.Mapping[T, t.Any], predicate: None = None) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
 def find_last_key(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], t.Any]
-) -> t.Union[int, None]: ...
+) -> t.Union[int, None]:
+    ...
 
 
 @t.overload
 def find_last_key(
     collection: t.Iterable[T], iteratee: t.Callable[[T, int], t.Any]
-) -> t.Union[int, None]: ...
+) -> t.Union[int, None]:
+    ...
 
 
 @t.overload
 def find_last_key(
     collection: t.Iterable[T], iteratee: t.Callable[[T], t.Any]
-) -> t.Union[int, None]: ...
+) -> t.Union[int, None]:
+    ...
 
 
 @t.overload
-def find_last_key(collection: t.Iterable[t.Any], iteratee: None = None) -> t.Union[int, None]: ...
+def find_last_key(collection: t.Iterable[t.Any], iteratee: None = None) -> t.Union[int, None]:
+    ...
 
 
 def find_last_key(obj, predicate=None):
@@ -638,7 +672,7 @@ def find_last_key(obj, predicate=None):
 
     Example:
 
-        >>> find_last_key({'a': 1, 'b': 2, 'c': 3}, lambda x: x == 1)
+        >>> find_last_key({"a": 1, "b": 2, "c": 3}, lambda x: x == 1)
         'a'
         >>> find_last_key([1, 2, 3, 1], lambda x: x == 1)
         3
@@ -656,35 +690,43 @@ def find_last_key(obj, predicate=None):
 @t.overload
 def for_in(
     obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], t.Any]
-) -> t.Dict[T, T2]: ...
+) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def for_in(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], t.Any]) -> t.Dict[T, T2]: ...
+def for_in(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], t.Any]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def for_in(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], t.Any]) -> t.Dict[T, T2]: ...
+def for_in(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], t.Any]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def for_in(obj: t.Mapping[T, T2], iteratee: None = None) -> t.Dict[T, T2]: ...
+def for_in(obj: t.Mapping[T, T2], iteratee: None = None) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def for_in(obj: t.Sequence[T], iteratee: t.Callable[[T, int, t.List[T]], t.Any]) -> t.List[T]: ...
+def for_in(obj: t.Sequence[T], iteratee: t.Callable[[T, int, t.List[T]], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def for_in(obj: t.Sequence[T], iteratee: t.Callable[[T, int], t.Any]) -> t.List[T]: ...
+def for_in(obj: t.Sequence[T], iteratee: t.Callable[[T, int], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def for_in(obj: t.Sequence[T], iteratee: t.Callable[[T], t.Any]) -> t.List[T]: ...
+def for_in(obj: t.Sequence[T], iteratee: t.Callable[[T], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def for_in(obj: t.Sequence[T], iteratee: None = None) -> t.List[T]: ...
+def for_in(obj: t.Sequence[T], iteratee: None = None) -> t.List[T]:
+    ...
 
 
 def for_in(obj, iteratee=None):
@@ -702,11 +744,12 @@ def for_in(obj, iteratee=None):
     Example:
 
         >>> obj = {}
-        >>> def cb(v, k): obj[k] = v
-        >>> results = for_in({'a': 1, 'b': 2, 'c': 3}, cb)
-        >>> results == {'a': 1, 'b': 2, 'c': 3}
+        >>> def cb(v, k):
+        ...     obj[k] = v
+        >>> results = for_in({"a": 1, "b": 2, "c": 3}, cb)
+        >>> results == {"a": 1, "b": 2, "c": 3}
         True
-        >>> obj == {'a': 1, 'b': 2, 'c': 3}
+        >>> obj == {"a": 1, "b": 2, "c": 3}
         True
 
     .. versionadded:: 1.0.0
@@ -722,37 +765,43 @@ def for_in(obj, iteratee=None):
 @t.overload
 def for_in_right(
     obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], t.Any]
-) -> t.Dict[T, T2]: ...
+) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def for_in_right(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], t.Any]) -> t.Dict[T, T2]: ...
+def for_in_right(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], t.Any]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def for_in_right(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], t.Any]) -> t.Dict[T, T2]: ...
+def for_in_right(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], t.Any]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def for_in_right(obj: t.Mapping[T, T2], iteratee: None = None) -> t.Dict[T, T2]: ...
+def for_in_right(obj: t.Mapping[T, T2], iteratee: None = None) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def for_in_right(
-    obj: t.Sequence[T], iteratee: t.Callable[[T, int, t.List[T]], t.Any]
-) -> t.List[T]: ...
+def for_in_right(obj: t.Sequence[T], iteratee: t.Callable[[T, int, t.List[T]], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def for_in_right(obj: t.Sequence[T], iteratee: t.Callable[[T, int], t.Any]) -> t.List[T]: ...
+def for_in_right(obj: t.Sequence[T], iteratee: t.Callable[[T, int], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def for_in_right(obj: t.Sequence[T], iteratee: t.Callable[[T], t.Any]) -> t.List[T]: ...
+def for_in_right(obj: t.Sequence[T], iteratee: t.Callable[[T], t.Any]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def for_in_right(obj: t.Sequence[T], iteratee: None = None) -> t.List[T]: ...
+def for_in_right(obj: t.Sequence[T], iteratee: None = None) -> t.List[T]:
+    ...
 
 
 def for_in_right(obj, iteratee=None):
@@ -768,11 +817,12 @@ def for_in_right(obj, iteratee=None):
 
     Example:
 
-        >>> data = {'product': 1}
-        >>> def cb(v): data['product'] *= v
+        >>> data = {"product": 1}
+        >>> def cb(v):
+        ...     data["product"] *= v
         >>> for_in_right([1, 2, 3, 4], cb)
         [1, 2, 3, 4]
-        >>> data['product'] == 24
+        >>> data["product"] == 24
         True
 
     .. versionadded:: 1.0.0
@@ -786,15 +836,18 @@ def for_in_right(obj, iteratee=None):
 
 
 @t.overload
-def get(obj: t.List[T], path: int, default: T2) -> t.Union[T, T2]: ...
+def get(obj: t.List[T], path: int, default: T2) -> t.Union[T, T2]:
+    ...
 
 
 @t.overload
-def get(obj: t.List[T], path: int, default: None = None) -> t.Union[T, None]: ...
+def get(obj: t.List[T], path: int, default: None = None) -> t.Union[T, None]:
+    ...
 
 
 @t.overload
-def get(obj: t.Any, path: PathT, default: t.Any = None) -> t.Any: ...
+def get(obj: t.Any, path: PathT, default: t.Any = None) -> t.Any:
+    ...
 
 
 def get(obj: t.Any, path: PathT, default: t.Any = None) -> t.Any:
@@ -812,17 +865,17 @@ def get(obj: t.Any, path: PathT, default: t.Any = None) -> t.Any:
 
     Example:
 
-        >>> get({}, 'a.b.c') is None
+        >>> get({}, "a.b.c") is None
         True
-        >>> get({'a': {'b': {'c': [1, 2, 3, 4]}}}, 'a.b.c[1]')
+        >>> get({"a": {"b": {"c": [1, 2, 3, 4]}}}, "a.b.c[1]")
         2
-        >>> get({'a': {'b': {'c': [1, 2, 3, 4]}}}, 'a.b.c.1')
+        >>> get({"a": {"b": {"c": [1, 2, 3, 4]}}}, "a.b.c.1")
         2
-        >>> get({'a': {'b': [0, {'c': [1, 2]}]}}, 'a.b.1.c.1')
+        >>> get({"a": {"b": [0, {"c": [1, 2]}]}}, "a.b.1.c.1")
         2
-        >>> get({'a': {'b': [0, {'c': [1, 2]}]}}, ['a', 'b', 1, 'c', 1])
+        >>> get({"a": {"b": [0, {"c": [1, 2]}]}}, ["a", "b", 1, "c", 1])
         2
-        >>> get({'a': {'b': [0, {'c': [1, 2]}]}}, 'a.b.1.c.2') is None
+        >>> get({"a": {"b": [0, {"c": [1, 2]}]}}, "a.b.1.c.2") is None
         True
 
     .. versionadded:: 2.0.0
@@ -883,13 +936,13 @@ def has(obj: t.Any, path: PathT) -> bool:
 
         >>> has([1, 2, 3], 1)
         True
-        >>> has({'a': 1, 'b': 2}, 'b')
+        >>> has({"a": 1, "b": 2}, "b")
         True
-        >>> has({'a': 1, 'b': 2}, 'c')
+        >>> has({"a": 1, "b": 2}, "c")
         False
-        >>> has({'a': {'b': [0, {'c': [1, 2]}]}}, 'a.b.1.c.1')
+        >>> has({"a": {"b": [0, {"c": [1, 2]}]}}, "a.b.1.c.1")
         True
-        >>> has({'a': {'b': [0, {'c': [1, 2]}]}}, 'a.b.1.c.2')
+        >>> has({"a": {"b": [0, {"c": [1, 2]}]}}, "a.b.1.c.2")
         False
 
     .. versionadded:: 1.0.0
@@ -915,11 +968,13 @@ def has(obj: t.Any, path: PathT) -> bool:
 
 
 @t.overload
-def invert(obj: t.Mapping[T, T2]) -> t.Dict[T2, T]: ...
+def invert(obj: t.Mapping[T, T2]) -> t.Dict[T2, T]:
+    ...
 
 
 @t.overload
-def invert(obj: t.Iterable[T]) -> t.Dict[T, int]: ...
+def invert(obj: t.Iterable[T]) -> t.Dict[T, int]:
+    ...
 
 
 def invert(obj) -> t.Dict:
@@ -934,8 +989,8 @@ def invert(obj) -> t.Dict:
 
     Example:
 
-        >>> results = invert({'a': 1, 'b': 2, 'c': 3})
-        >>> results == {1: 'a', 2: 'b', 3: 'c'}
+        >>> results = invert({"a": 1, "b": 2, "c": 3})
+        >>> results == {1: "a", 2: "b", 3: "c"}
         True
 
     Note:
@@ -953,19 +1008,23 @@ def invert(obj) -> t.Dict:
 
 
 @t.overload
-def invert_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], T3]) -> t.Dict[T3, t.List[T]]: ...
+def invert_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], T3]) -> t.Dict[T3, t.List[T]]:
+    ...
 
 
 @t.overload
-def invert_by(obj: t.Mapping[T, T2], iteratee: None = None) -> t.Dict[T2, t.List[T]]: ...
+def invert_by(obj: t.Mapping[T, T2], iteratee: None = None) -> t.Dict[T2, t.List[T]]:
+    ...
 
 
 @t.overload
-def invert_by(obj: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, t.List[int]]: ...
+def invert_by(obj: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, t.List[int]]:
+    ...
 
 
 @t.overload
-def invert_by(obj: t.Iterable[T], iteratee: None = None) -> t.Dict[T, t.List[int]]: ...
+def invert_by(obj: t.Iterable[T], iteratee: None = None) -> t.Dict[T, t.List[int]]:
+    ...
 
 
 def invert_by(obj, iteratee=None):
@@ -984,16 +1043,16 @@ def invert_by(obj, iteratee=None):
 
     Example:
 
-        >>> obj = {'a': 1, 'b': 2, 'c': 1}
+        >>> obj = {"a": 1, "b": 2, "c": 1}
         >>> results = invert_by(obj)  # {1: ['a', 'c'], 2: ['b']}
-        >>> set(results[1]) == set(['a', 'c'])
+        >>> set(results[1]) == set(["a", "c"])
         True
-        >>> set(results[2]) == set(['b'])
+        >>> set(results[2]) == set(["b"])
         True
-        >>> results2 = invert_by(obj, lambda value: 'group' + str(value))
-        >>> results2['group1'] == results[1]
+        >>> results2 = invert_by(obj, lambda value: "group" + str(value))
+        >>> results2["group1"] == results[1]
         True
-        >>> results2['group2'] == results[2]
+        >>> results2["group2"] == results[2]
         True
 
     Note:
@@ -1025,8 +1084,8 @@ def invoke(obj: t.Any, path: PathT, *args: t.Any, **kwargs: t.Any) -> t.Any:
 
     Example:
 
-        >>> obj = {'a': [{'b': {'c': [1, 2, 3, 4]}}]}
-        >>> invoke(obj, 'a[0].b.c.pop', 1)
+        >>> obj = {"a": [{"b": {"c": [1, 2, 3, 4]}}]}
+        >>> invoke(obj, "a[0].b.c.pop", 1)
         2
         >>> obj
         {'a': [{'b': {'c': [1, 3, 4]}}]}
@@ -1049,11 +1108,13 @@ def invoke(obj: t.Any, path: PathT, *args: t.Any, **kwargs: t.Any) -> t.Any:
 
 
 @t.overload
-def keys(obj: t.Iterable[T]) -> t.List[T]: ...
+def keys(obj: t.Iterable[T]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def keys(obj: t.Any) -> t.List: ...
+def keys(obj: t.Any) -> t.List:
+    ...
 
 
 def keys(obj):
@@ -1070,7 +1131,7 @@ def keys(obj):
 
         >>> keys([1, 2, 3])
         [0, 1, 2]
-        >>> set(keys({'a': 1, 'b': 2, 'c': 3})) == set(['a', 'b', 'c'])
+        >>> set(keys({"a": 1, "b": 2, "c": 3})) == set(["a", "b", "c"])
         True
 
     .. versionadded:: 1.0.0
@@ -1087,33 +1148,38 @@ def keys(obj):
 @t.overload
 def map_keys(
     obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], T3]
-) -> t.Dict[T3, T2]: ...
+) -> t.Dict[T3, T2]:
+    ...
 
 
 @t.overload
-def map_keys(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]) -> t.Dict[T3, T2]: ...
+def map_keys(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]) -> t.Dict[T3, T2]:
+    ...
 
 
 @t.overload
-def map_keys(obj: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], T3]) -> t.Dict[T3, T2]: ...
+def map_keys(obj: t.Mapping[t.Any, T2], iteratee: t.Callable[[T2], T3]) -> t.Dict[T3, T2]:
+    ...
 
 
 @t.overload
-def map_keys(
-    obj: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]
-) -> t.Dict[T2, T]: ...
+def map_keys(obj: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]) -> t.Dict[T2, T]:
+    ...
 
 
 @t.overload
-def map_keys(obj: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.Dict[T2, T]: ...
+def map_keys(obj: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.Dict[T2, T]:
+    ...
 
 
 @t.overload
-def map_keys(obj: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, T]: ...
+def map_keys(obj: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T2, T]:
+    ...
 
 
 @t.overload
-def map_keys(obj: t.Iterable, iteratee: t.Union[IterateeObjT, None] = None) -> t.Dict: ...
+def map_keys(obj: t.Iterable, iteratee: t.Union[IterateeObjT, None] = None) -> t.Dict:
+    ...
 
 
 def map_keys(obj, iteratee=None):
@@ -1132,8 +1198,8 @@ def map_keys(obj, iteratee=None):
     Example:
 
         >>> callback = lambda value, key: key * 2
-        >>> results = map_keys({'a': 1, 'b': 2, 'c': 3}, callback)
-        >>> results == {'aa': 1, 'bb': 2, 'cc': 3}
+        >>> results = map_keys({"a": 1, "b": 2, "c": 3}, callback)
+        >>> results == {"aa": 1, "bb": 2, "cc": 3}
         True
 
     .. versionadded:: 3.3.0
@@ -1144,33 +1210,38 @@ def map_keys(obj, iteratee=None):
 @t.overload
 def map_values(
     obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T, t.Dict[T, T2]], T3]
-) -> t.Dict[T, T3]: ...
+) -> t.Dict[T, T3]:
+    ...
 
 
 @t.overload
-def map_values(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]) -> t.Dict[T, T3]: ...
+def map_values(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], T3]) -> t.Dict[T, T3]:
+    ...
 
 
 @t.overload
-def map_values(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], T3]) -> t.Dict[T, T3]: ...
+def map_values(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], T3]) -> t.Dict[T, T3]:
+    ...
 
 
 @t.overload
-def map_values(
-    obj: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]
-) -> t.Dict[T, T2]: ...
+def map_values(obj: t.Iterable[T], iteratee: t.Callable[[T, int, t.List[T]], T2]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def map_values(obj: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.Dict[T, T2]: ...
+def map_values(obj: t.Iterable[T], iteratee: t.Callable[[T, int], T2]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def map_values(obj: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T, T2]: ...
+def map_values(obj: t.Iterable[T], iteratee: t.Callable[[T], T2]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def map_values(obj: t.Iterable, iteratee: t.Union[IterateeObjT, None] = None) -> t.Dict: ...
+def map_values(obj: t.Iterable, iteratee: t.Union[IterateeObjT, None] = None) -> t.Dict:
+    ...
 
 
 def map_values(obj, iteratee=None):
@@ -1188,11 +1259,11 @@ def map_values(obj, iteratee=None):
 
     Example:
 
-        >>> results = map_values({'a': 1, 'b': 2, 'c': 3}, lambda x: x * 2)
-        >>> results == {'a': 2, 'b': 4, 'c': 6}
+        >>> results = map_values({"a": 1, "b": 2, "c": 3}, lambda x: x * 2)
+        >>> results == {"a": 2, "b": 4, "c": 6}
         True
-        >>> results = map_values({'a': 1, 'b': {'d': 4}, 'c': 3}, {'d': 4})
-        >>> results == {'a': False, 'b': True, 'c': False}
+        >>> results = map_values({"a": 1, "b": {"d": 4}, "c": 3}, {"d": 4})
+        >>> results == {"a": False, "b": True, "c": False}
         True
 
     .. versionadded:: 1.0.0
@@ -1221,12 +1292,12 @@ def map_values_deep(
 
     Example:
 
-        >>> x = {'a': 1, 'b': {'c': 2}}
+        >>> x = {"a": 1, "b": {"c": 2}}
         >>> y = map_values_deep(x, lambda val: val * 2)
-        >>> y == {'a': 2, 'b': {'c': 4}}
+        >>> y == {"a": 2, "b": {"c": 4}}
         True
         >>> z = map_values_deep(x, lambda val, props: props)
-        >>> z == {'a': ['a'], 'b': {'c': ['b', 'c']}}
+        >>> z == {"a": ["a"], "b": {"c": ["b", "c"]}}
         True
 
     .. versionadded: 2.2.0
@@ -1252,11 +1323,13 @@ def deep_iteratee(value, key):
 @t.overload
 def merge(
     obj: t.Mapping[T, T2], *sources: t.Mapping[T3, T4]
-) -> t.Dict[t.Union[T, T3], t.Union[T2, T4]]: ...
+) -> t.Dict[t.Union[T, T3], t.Union[T2, T4]]:
+    ...
 
 
 @t.overload
-def merge(obj: t.Sequence[T], *sources: t.Sequence[T2]) -> t.List[t.Union[T, T2]]: ...
+def merge(obj: t.Sequence[T], *sources: t.Sequence[T2]) -> t.List[t.Union[T, T2]]:
+    ...
 
 
 def merge(obj, *sources):
@@ -1276,9 +1349,9 @@ def merge(obj, *sources):
 
     Example:
 
-        >>> obj = {'a': 2}
-        >>> obj2 = merge(obj, {'a': 1}, {'b': 2, 'c': 3}, {'d': 4})
-        >>> obj2 == {'a': 1, 'b': 2, 'c': 3, 'd': 4}
+        >>> obj = {"a": 2}
+        >>> obj2 = merge(obj, {"a": 1}, {"b": 2, "c": 3}, {"d": 4})
+        >>> obj2 == {"a": 1, "b": 2, "c": 3, "d": 4}
         True
         >>> obj is obj2
         True
@@ -1325,10 +1398,10 @@ def merge_with(obj: t.Any, *sources: t.Any, **kwargs: t.Any) -> t.Any:
     Example:
 
         >>> cbk = lambda obj_val, src_val: obj_val + src_val
-        >>> obj1 = {'a': [1], 'b': [2]}
-        >>> obj2 = {'a': [3], 'b': [4]}
+        >>> obj1 = {"a": [1], "b": [2]}
+        >>> obj2 = {"a": [3], "b": [4]}
         >>> res = merge_with(obj1, obj2, cbk)
-        >>> obj1 == {'a': [1, 3], 'b': [2, 4]}
+        >>> obj1 == {"a": [1, 3], "b": [2, 4]}
         True
 
     .. versionadded:: 4.0.0
@@ -1385,15 +1458,18 @@ def _merge_with(obj, *sources, **kwargs):
 
 
 @t.overload
-def omit(obj: t.Mapping[T, T2], *properties: PathT) -> t.Dict[T, T2]: ...
+def omit(obj: t.Mapping[T, T2], *properties: PathT) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def omit(obj: t.Iterable[T], *properties: PathT) -> t.Dict[int, T]: ...
+def omit(obj: t.Iterable[T], *properties: PathT) -> t.Dict[int, T]:
+    ...
 
 
 @t.overload
-def omit(obj: t.Any, *properties: PathT) -> t.Dict: ...
+def omit(obj: t.Any, *properties: PathT) -> t.Dict:
+    ...
 
 
 def omit(obj, *properties):
@@ -1410,13 +1486,13 @@ def omit(obj, *properties):
 
     Example:
 
-        >>> omit({'a': 1, 'b': 2, 'c': 3}, 'b', 'c') == {'a': 1}
+        >>> omit({"a": 1, "b": 2, "c": 3}, "b", "c") == {"a": 1}
         True
-        >>> omit({'a': 1, 'b': 2, 'c': 3 }, ['a', 'c']) == {'b': 2}
+        >>> omit({"a": 1, "b": 2, "c": 3}, ["a", "c"]) == {"b": 2}
         True
         >>> omit([1, 2, 3, 4], 0, 3) == {1: 2, 2: 3}
         True
-        >>> omit({'a': {'b': {'c': 'd'}}}, 'a.b.c') == {'a': {'b': {}}}
+        >>> omit({"a": {"b": {"c": "d"}}}, "a.b.c") == {"a": {"b": {}}}
         True
 
     .. versionadded:: 1.0.0
@@ -1431,31 +1507,38 @@ def omit(obj, *properties):
 
 
 @t.overload
-def omit_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], t.Any]) -> t.Dict[T, T2]: ...
+def omit_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], t.Any]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def omit_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], t.Any]) -> t.Dict[T, T2]: ...
+def omit_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], t.Any]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def omit_by(obj: t.Dict[T, T2], iteratee: None = None) -> t.Dict[T, T2]: ...
+def omit_by(obj: t.Dict[T, T2], iteratee: None = None) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def omit_by(obj: t.Iterable[T], iteratee: t.Callable[[T, int], t.Any]) -> t.Dict[int, T]: ...
+def omit_by(obj: t.Iterable[T], iteratee: t.Callable[[T, int], t.Any]) -> t.Dict[int, T]:
+    ...
 
 
 @t.overload
-def omit_by(obj: t.Iterable[T], iteratee: t.Callable[[T], t.Any]) -> t.Dict[int, T]: ...
+def omit_by(obj: t.Iterable[T], iteratee: t.Callable[[T], t.Any]) -> t.Dict[int, T]:
+    ...
 
 
 @t.overload
-def omit_by(obj: t.List[T], iteratee: None = None) -> t.Dict[int, T]: ...
+def omit_by(obj: t.List[T], iteratee: None = None) -> t.Dict[int, T]:
+    ...
 
 
 @t.overload
-def omit_by(obj: t.Any, iteratee: t.Union[t.Callable, None] = None) -> t.Dict: ...
+def omit_by(obj: t.Any, iteratee: t.Union[t.Callable, None] = None) -> t.Dict:
+    ...
 
 
 def omit_by(obj, iteratee=None):
@@ -1473,7 +1556,7 @@ def omit_by(obj, iteratee=None):
 
     Example:
 
-        >>> omit_by({'a': 1, 'b': '2', 'c': 3}, lambda v: isinstance(v, int))
+        >>> omit_by({"a": 1, "b": "2", "c": 3}, lambda v: isinstance(v, int))
         {'b': '2'}
 
     .. versionadded:: 4.0.0
@@ -1521,11 +1604,11 @@ def parse_int(value: t.Any, radix: t.Union[int, None] = None) -> t.Union[int, No
 
     Example:
 
-        >>> parse_int('5')
+        >>> parse_int("5")
         5
-        >>> parse_int('12', 8)
+        >>> parse_int("12", 8)
         10
-        >>> parse_int('x') is None
+        >>> parse_int("x") is None
         True
 
     .. versionadded:: 1.0.0
@@ -1554,15 +1637,18 @@ def parse_int(value: t.Any, radix: t.Union[int, None] = None) -> t.Union[int, No
 
 
 @t.overload
-def pick(obj: t.Mapping[T, T2], *properties: PathT) -> t.Dict[T, T2]: ...
+def pick(obj: t.Mapping[T, T2], *properties: PathT) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def pick(obj: t.Union[t.Tuple[T, ...], t.List[T]], *properties: PathT) -> t.Dict[int, T]: ...
+def pick(obj: t.Union[t.Tuple[T, ...], t.List[T]], *properties: PathT) -> t.Dict[int, T]:
+    ...
 
 
 @t.overload
-def pick(obj: t.Any, *properties: PathT) -> t.Dict: ...
+def pick(obj: t.Any, *properties: PathT) -> t.Dict:
+    ...
 
 
 def pick(obj, *properties):
@@ -1578,7 +1664,7 @@ def pick(obj, *properties):
 
     Example:
 
-        >>> pick({'a': 1, 'b': 2, 'c': 3}, 'a', 'b') == {'a': 1, 'b': 2}
+        >>> pick({"a": 1, "b": 2, "c": 3}, "a", "b") == {"a": 1, "b": 2}
         True
 
     .. versionadded:: 1.0.0
@@ -1590,35 +1676,42 @@ def pick(obj, *properties):
 
 
 @t.overload
-def pick_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], t.Any]) -> t.Dict[T, T2]: ...
+def pick_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2], t.Any]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def pick_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], t.Any]) -> t.Dict[T, T2]: ...
+def pick_by(obj: t.Mapping[T, T2], iteratee: t.Callable[[T2, T], t.Any]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def pick_by(obj: t.Dict[T, T2], iteratee: None = None) -> t.Dict[T, T2]: ...
+def pick_by(obj: t.Dict[T, T2], iteratee: None = None) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
 def pick_by(
     obj: t.Union[t.Tuple[T, ...], t.List[T]], iteratee: t.Callable[[T, int], t.Any]
-) -> t.Dict[int, T]: ...
+) -> t.Dict[int, T]:
+    ...
 
 
 @t.overload
 def pick_by(
     obj: t.Union[t.Tuple[T, ...], t.List[T]], iteratee: t.Callable[[T], t.Any]
-) -> t.Dict[int, T]: ...
+) -> t.Dict[int, T]:
+    ...
 
 
 @t.overload
-def pick_by(obj: t.Union[t.Tuple[T, ...], t.List[T]], iteratee: None = None) -> t.Dict[int, T]: ...
+def pick_by(obj: t.Union[t.Tuple[T, ...], t.List[T]], iteratee: None = None) -> t.Dict[int, T]:
+    ...
 
 
 @t.overload
-def pick_by(obj: t.Any, iteratee: t.Union[t.Callable, None] = None) -> t.Dict: ...
+def pick_by(obj: t.Any, iteratee: t.Union[t.Callable, None] = None) -> t.Dict:
+    ...
 
 
 def pick_by(obj, iteratee=None):
@@ -1635,8 +1728,8 @@ def pick_by(obj, iteratee=None):
 
     Example:
 
-        >>> obj = {'a': 1, 'b': '2', 'c': 3 }
-        >>> pick_by(obj, lambda v: isinstance(v, int)) == {'a': 1, 'c': 3}
+        >>> obj = {"a": 1, "b": "2", "c": 3}
+        >>> pick_by(obj, lambda v: isinstance(v, int)) == {"a": 1, "c": 3}
         True
 
     .. versionadded:: 4.0.0
@@ -1683,8 +1776,8 @@ def rename_keys(obj: t.Dict[T, T2], key_map: t.Dict[t.Any, T3]) -> t.Dict[t.Unio
 
     Example:
 
-        >>> obj = rename_keys({'a': 1, 'b': 2, 'c': 3}, {'a': 'A', 'b': 'B'})
-        >>> obj == {'A': 1, 'B': 2, 'c': 3}
+        >>> obj = rename_keys({"a": 1, "b": 2, "c": 3}, {"a": "A", "b": "B"})
+        >>> obj == {"A": 1, "B": 2, "c": 3}
         True
 
     .. versionadded:: 2.0.0
@@ -1710,13 +1803,13 @@ def set_(obj: T, path: PathT, value: t.Any) -> T:
 
     Example:
 
-        >>> set_({}, 'a.b.c', 1)
+        >>> set_({}, "a.b.c", 1)
         {'a': {'b': {'c': 1}}}
-        >>> set_({}, 'a.0.c', 1)
+        >>> set_({}, "a.0.c", 1)
         {'a': {'0': {'c': 1}}}
-        >>> set_([1, 2], '[2][0]', 1)
+        >>> set_([1, 2], "[2][0]", 1)
         [1, 2, [1]]
-        >>> set_({}, 'a.b[0].c', 1)
+        >>> set_({}, "a.b[0].c", 1)
         {'a': {'b': [{'c': 1}]}}
 
     .. versionadded:: 2.2.0
@@ -1754,7 +1847,7 @@ def set_with(obj: T, path: PathT, value: t.Any, customizer: t.Union[t.Callable,
 
     Example:
 
-        >>> set_with({}, '[0][1]', 'a', lambda: {})
+        >>> set_with({}, "[0][1]", "a", lambda: {})
         {0: {1: 'a'}}
 
     .. versionadded:: 4.0.0
@@ -1790,15 +1883,15 @@ def to_boolean(
 
     Example:
 
-        >>> to_boolean('true')
+        >>> to_boolean("true")
         True
-        >>> to_boolean('1')
+        >>> to_boolean("1")
         True
-        >>> to_boolean('false')
+        >>> to_boolean("false")
         False
-        >>> to_boolean('0')
+        >>> to_boolean("0")
         False
-        >>> assert to_boolean('a') is None
+        >>> assert to_boolean("a") is None
 
     .. versionadded:: 3.0.0
     """
@@ -1824,15 +1917,18 @@ def boolean_match(text, vals):
 
 
 @t.overload
-def to_dict(obj: t.Mapping[T, T2]) -> t.Dict[T, T2]: ...
+def to_dict(obj: t.Mapping[T, T2]) -> t.Dict[T, T2]:
+    ...
 
 
 @t.overload
-def to_dict(obj: t.Iterable[T]) -> t.Dict[int, T]: ...
+def to_dict(obj: t.Iterable[T]) -> t.Dict[int, T]:
+    ...
 
 
 @t.overload
-def to_dict(obj: t.Any) -> t.Dict: ...
+def to_dict(obj: t.Any) -> t.Dict:
+    ...
 
 
 def to_dict(obj):
@@ -1847,7 +1943,7 @@ def to_dict(obj):
 
     Example:
 
-        >>> obj = {'a': 1, 'b': 2}
+        >>> obj = {"a": 1, "b": 2}
         >>> obj2 = to_dict(obj)
         >>> obj2 == obj
         True
@@ -1883,11 +1979,11 @@ def to_integer(obj: t.Any) -> int:
 
         >>> to_integer(3.2)
         3
-        >>> to_integer('3.2')
+        >>> to_integer("3.2")
         3
-        >>> to_integer('3.9')
+        >>> to_integer("3.9")
         3
-        >>> to_integer('invalid')
+        >>> to_integer("invalid")
         0
 
     .. versionadded:: 4.0.0
@@ -1903,15 +1999,18 @@ def to_integer(obj: t.Any) -> int:
 
 
 @t.overload
-def to_list(obj: t.Dict[t.Any, T], split_strings: bool = True) -> t.List[T]: ...
+def to_list(obj: t.Dict[t.Any, T], split_strings: bool = True) -> t.List[T]:
+    ...
 
 
 @t.overload
-def to_list(obj: t.Iterable[T], split_strings: bool = True) -> t.List[T]: ...
+def to_list(obj: t.Iterable[T], split_strings: bool = True) -> t.List[T]:
+    ...
 
 
 @t.overload
-def to_list(obj: T, split_strings: bool = True) -> t.List[T]: ...
+def to_list(obj: T, split_strings: bool = True) -> t.List[T]:
+    ...
 
 
 def to_list(obj, split_strings=True):
@@ -1928,7 +2027,7 @@ def to_list(obj, split_strings=True):
 
     Example:
 
-        >>> results = to_list({'a': 1, 'b': 2, 'c': 3})
+        >>> results = to_list({"a": 1, "b": 2, "c": 3})
         >>> assert set(results) == set([1, 2, 3])
 
         >>> to_list((1, 2, 3, 4))
@@ -1943,10 +2042,10 @@ def to_list(obj, split_strings=True):
         >>> to_list(a for a in [1, 2, 3])
         [1, 2, 3]
 
-        >>> to_list('cat')
+        >>> to_list("cat")
         ['c', 'a', 't']
 
-        >>> to_list('cat', split_strings=False)
+        >>> to_list("cat", split_strings=False)
         ['cat']
 
     .. versionadded:: 1.0.0
@@ -1988,9 +2087,9 @@ def to_number(obj: t.Any, precision: int = 0) -> t.Union[float, None]:
 
     Example:
 
-        >>> to_number('1234.5678')
+        >>> to_number("1234.5678")
         1235.0
-        >>> to_number('1234.5678', 4)
+        >>> to_number("1234.5678", 4)
         1234.5678
         >>> to_number(1, 2)
         1.0
@@ -2015,15 +2114,18 @@ def to_number(obj: t.Any, precision: int = 0) -> t.Union[float, None]:
 
 
 @t.overload
-def to_pairs(obj: t.Mapping[T, T2]) -> t.List[t.List[t.Union[T, T2]]]: ...
+def to_pairs(obj: t.Mapping[T, T2]) -> t.List[t.List[t.Union[T, T2]]]:
+    ...
 
 
 @t.overload
-def to_pairs(obj: t.Iterable[T]) -> t.List[t.List[t.Union[int, T]]]: ...
+def to_pairs(obj: t.Iterable[T]) -> t.List[t.List[t.Union[int, T]]]:
+    ...
 
 
 @t.overload
-def to_pairs(obj: t.Any) -> t.List: ...
+def to_pairs(obj: t.Any) -> t.List:
+    ...
 
 
 def to_pairs(obj):
@@ -2041,7 +2143,7 @@ def to_pairs(obj):
 
         >>> to_pairs([1, 2, 3, 4])
         [[0, 1], [1, 2], [2, 3], [3, 4]]
-        >>> to_pairs({'a': 1})
+        >>> to_pairs({"a": 1})
         [['a', 1]]
 
     .. versionadded:: 1.0.0
@@ -2064,13 +2166,13 @@ def to_string(obj: t.Any) -> str:
 
     Example:
 
-        >>> to_string(1) == '1'
+        >>> to_string(1) == "1"
         True
-        >>> to_string(None) == ''
+        >>> to_string(None) == ""
         True
-        >>> to_string([1, 2, 3]) == '[1, 2, 3]'
+        >>> to_string([1, 2, 3]) == "[1, 2, 3]"
         True
-        >>> to_string('a') == 'a'
+        >>> to_string("a") == "a"
         True
 
     .. versionadded:: 2.0.0
@@ -2090,49 +2192,56 @@ def to_string(obj: t.Any) -> str:
 @t.overload
 def transform(
     obj: t.Mapping[T, T2], iteratee: t.Callable[[T3, T2, T, t.Dict[T, T2]], t.Any], accumulator: T3
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
 def transform(
     obj: t.Mapping[T, T2], iteratee: t.Callable[[T3, T2, T], t.Any], accumulator: T3
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
 def transform(
     obj: t.Mapping[t.Any, T2], iteratee: t.Callable[[T3, T2], t.Any], accumulator: T3
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
 def transform(
     obj: t.Mapping[t.Any, t.Any], iteratee: t.Callable[[T3], t.Any], accumulator: T3
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
 def transform(
     obj: t.Iterable[T], iteratee: t.Callable[[T3, T, int, t.List[T]], t.Any], accumulator: T3
-) -> T3: ...
+) -> T3:
+    ...
 
 
 @t.overload
-def transform(
-    obj: t.Iterable[T], iteratee: t.Callable[[T3, T, int], t.Any], accumulator: T3
-) -> T3: ...
+def transform(obj: t.Iterable[T], iteratee: t.Callable[[T3, T, int], t.Any], accumulator: T3) -> T3:
+    ...
 
 
 @t.overload
-def transform(obj: t.Iterable[T], iteratee: t.Callable[[T3, T], t.Any], accumulator: T3) -> T3: ...
+def transform(obj: t.Iterable[T], iteratee: t.Callable[[T3, T], t.Any], accumulator: T3) -> T3:
+    ...
 
 
 @t.overload
-def transform(obj: t.Iterable[t.Any], iteratee: t.Callable[[T3], t.Any], accumulator: T3) -> T3: ...
+def transform(obj: t.Iterable[t.Any], iteratee: t.Callable[[T3], t.Any], accumulator: T3) -> T3:
+    ...
 
 
 @t.overload
-def transform(obj: t.Any, iteratee: t.Any = None, accumulator: t.Any = None) -> t.Any: ...
+def transform(obj: t.Any, iteratee: t.Any = None, accumulator: t.Any = None) -> t.Any:
+    ...
 
 
 def transform(obj, iteratee=None, accumulator=None):
@@ -2182,7 +2291,8 @@ def update(
     obj: t.Dict[t.Any, T2],
     path: PathT,
     updater: t.Callable[[T2], t.Any],
-) -> t.Dict: ...
+) -> t.Dict:
+    ...
 
 
 @t.overload
@@ -2190,7 +2300,8 @@ def update(
     obj: t.List[T],
     path: PathT,
     updater: t.Callable[[T], t.Any],
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
@@ -2198,7 +2309,8 @@ def update(
     obj: T,
     path: PathT,
     updater: t.Callable,
-) -> T: ...
+) -> T:
+    ...
 
 
 def update(obj, path, updater):
@@ -2220,7 +2332,7 @@ def update(obj, path, updater):
 
     Example:
 
-        >>> update({}, ['a', 'b'], lambda value: value)
+        >>> update({}, ["a", "b"], lambda value: value)
         {'a': {'b': None}}
         >>> update([], [0, 0], lambda value: 1)
         [[1]]
@@ -2236,7 +2348,8 @@ def update_with(
     path: PathT,
     updater: t.Callable[[T2], t.Any],
     customizer: t.Union[t.Callable, None],
-) -> t.Dict: ...
+) -> t.Dict:
+    ...
 
 
 @t.overload
@@ -2245,7 +2358,8 @@ def update_with(
     path: PathT,
     updater: t.Callable[[T], t.Any],
     customizer: t.Union[t.Callable, None] = None,
-) -> t.List: ...
+) -> t.List:
+    ...
 
 
 @t.overload
@@ -2254,10 +2368,11 @@ def update_with(
     path: PathT,
     updater: t.Callable,
     customizer: t.Union[t.Callable, None] = None,
-) -> T: ...
+) -> T:
+    ...
 
 
-def update_with(obj, path, updater, customizer=None):  # noqa: C901
+def update_with(obj, path, updater, customizer=None):  # noqa: PLR0912
     """
     This method is like :func:`update` except that it accepts customizer which is invoked to produce
     the objects of path. If customizer returns ``None``, path creation is handled by the method
@@ -2277,7 +2392,7 @@ def update_with(obj, path, updater, customizer=None):  # noqa: C901
 
     Example:
 
-        >>> update_with({}, '[0][1]', lambda: 'a', lambda: {})
+        >>> update_with({}, "[0][1]", lambda: "a", lambda: {})
         {0: {1: 'a'}}
 
     .. versionadded:: 4.0.0
@@ -2327,7 +2442,7 @@ def update_with(obj, path, updater, customizer=None):  # noqa: C901
                 _failed = True
 
             if _failed:
-                raise TypeError(f"Unable to update object at index {key!r}. {exc}")
+                raise TypeError(f"Unable to update object at index {key!r}. {exc}") from exc
 
     value = base_get(target, last_key, default=None)
     base_set(target, last_key, callit(updater, value))
@@ -2354,12 +2469,12 @@ def unset(obj: t.Union[t.List, t.Dict], path: PathT) -> bool:  # noqa: C901
 
     Example:
 
-        >>> obj = {'a': [{'b': {'c': 7}}]}
-        >>> unset(obj, 'a[0].b.c')
+        >>> obj = {"a": [{"b": {"c": 7}}]}
+        >>> unset(obj, "a[0].b.c")
         True
         >>> obj
         {'a': [{'b': {}}]}
-        >>> unset(obj, 'a[0].b.c')
+        >>> unset(obj, "a[0].b.c")
         False
     """
     tokens = to_path_tokens(path)
@@ -2405,15 +2520,18 @@ def unset(obj: t.Union[t.List, t.Dict], path: PathT) -> bool:  # noqa: C901
 
 
 @t.overload
-def values(obj: t.Mapping[t.Any, T2]) -> t.List[T2]: ...
+def values(obj: t.Mapping[t.Any, T2]) -> t.List[T2]:
+    ...
 
 
 @t.overload
-def values(obj: t.Iterable[T]) -> t.List[T]: ...
+def values(obj: t.Iterable[T]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def values(obj: t.Any) -> t.List: ...
+def values(obj: t.Any) -> t.List:
+    ...
 
 
 def values(obj):
@@ -2428,7 +2546,7 @@ def values(obj):
 
     Example:
 
-        >>> results = values({'a': 1, 'b': 2, 'c': 3})
+        >>> results = values({"a": 1, "b": 2, "c": 3})
         >>> set(results) == set([1, 2, 3])
         True
         >>> values([2, 4, 6, 8])
diff --git a/src/pydash/predicates.py b/src/pydash/predicates.py
index 501bab2..4b7b65d 100644
--- a/src/pydash/predicates.py
+++ b/src/pydash/predicates.py
@@ -111,9 +111,9 @@ def eq(value: t.Any, other: t.Any) -> bool:
 
         >>> eq(None, None)
         True
-        >>> eq(None, '')
+        >>> eq(None, "")
         False
-        >>> eq('a', 'a')
+        >>> eq("a", "a")
         True
         >>> eq(1, str(1))
         False
@@ -137,9 +137,9 @@ def eq_cmp(other: T) -> t.Callable[[T], bool]:
 
         >>> eq_cmp(None)(None)
         True
-        >>> eq_cmp(None)('')
+        >>> eq_cmp(None)("")
         False
-        >>> eq_cmp('a')('a')
+        >>> eq_cmp("a")("a")
         True
         >>> eq_cmp(1)(str(1))
         False
@@ -460,9 +460,9 @@ def is_blank(text: t.Any) -> TypeGuard[str]:
 
     Example:
 
-        >>> is_blank('')
+        >>> is_blank("")
         True
-        >>> is_blank(' \r\n ')
+        >>> is_blank(" \r\n ")
         True
         >>> is_blank(False)
         False
@@ -523,7 +523,7 @@ def is_builtin(value: t.Any) -> bool:
         True
         >>> is_builtin(list)
         True
-        >>> is_builtin('foo')
+        >>> is_builtin("foo")
         False
 
     .. versionadded:: 3.0.0
@@ -554,7 +554,7 @@ def is_date(value: t.Any) -> bool:
         True
         >>> is_date(datetime.datetime.today())
         True
-        >>> is_date('2014-01-01')
+        >>> is_date("2014-01-01")
         False
 
     Note:
@@ -566,7 +566,7 @@ def is_date(value: t.Any) -> bool:
 
 
 def is_decreasing(
-    value: t.Union["SupportsRichComparison", t.List["SupportsRichComparison"]]
+    value: t.Union["SupportsRichComparison", t.List["SupportsRichComparison"]],
 ) -> bool:
     """
     Check if `value` is monotonically decreasing.
@@ -637,7 +637,7 @@ def is_empty(value: t.Any) -> bool:
         True
         >>> is_empty(True)
         True
-        >>> is_empty('foo')
+        >>> is_empty("foo")
         False
         >>> is_empty(None)
         True
@@ -667,7 +667,7 @@ def is_equal(value: t.Any, other: t.Any) -> bool:
 
         >>> is_equal([1, 2, 3], [1, 2, 3])
         True
-        >>> is_equal('a', 'A')
+        >>> is_equal("a", "A")
         False
 
     .. versionadded:: 1.0.0
@@ -693,7 +693,7 @@ def is_equal_cmp(other: T) -> t.Callable[[T], bool]:
 
         >>> is_equal_cmp([1, 2, 3])([1, 2, 3])
         True
-        >>> is_equal_cmp('a')('A')
+        >>> is_equal_cmp("a")("A")
         False
 
     .. versionadded:: 7.1.0
@@ -702,15 +702,18 @@ def is_equal_cmp(other: T) -> t.Callable[[T], bool]:
 
 
 @t.overload
-def is_equal_with(value: T, other: T2, customizer: t.Callable[[T, T2], T3]) -> T3: ...
+def is_equal_with(value: T, other: T2, customizer: t.Callable[[T, T2], T3]) -> T3:
+    ...
 
 
 @t.overload
-def is_equal_with(value: t.Any, other: t.Any, customizer: t.Callable) -> bool: ...
+def is_equal_with(value: t.Any, other: t.Any, customizer: t.Callable) -> bool:
+    ...
 
 
 @t.overload
-def is_equal_with(value: t.Any, other: t.Any, customizer: None) -> bool: ...
+def is_equal_with(value: t.Any, other: t.Any, customizer: None) -> bool:
+    ...
 
 
 def is_equal_with(value, other, customizer):
@@ -732,9 +735,9 @@ def is_equal_with(value, other, customizer):
 
         >>> is_equal_with([1, 2, 3], [1, 2, 3], None)
         True
-        >>> is_equal_with('a', 'A', None)
+        >>> is_equal_with("a", "A", None)
         False
-        >>> is_equal_with('a', 'A', lambda a, b: a.lower() == b.lower())
+        >>> is_equal_with("a", "A", lambda a, b: a.lower() == b.lower())
         True
 
     .. versionadded:: 4.0.0
@@ -783,9 +786,9 @@ def is_equal_with_cmp(other: T, customizer: t.Callable[[T, T], T3]) -> t.Callabl
 
         >>> is_equal_with_cmp([1, 2, 3], None)([1, 2, 3])
         True
-        >>> is_equal_with_cmp('a', None)('A')
+        >>> is_equal_with_cmp("a", None)("A")
         False
-        >>> is_equal_with_cmp('a', lambda a, b: a.lower() == b.lower())('A')
+        >>> is_equal_with_cmp("a", lambda a, b: a.lower() == b.lower())("A")
         True
 
     .. versionadded:: 7.1.0
@@ -888,7 +891,7 @@ def is_function(value: t.Any) -> bool:
 
 
 def is_increasing(
-    value: t.Union["SupportsRichComparison", t.List["SupportsRichComparison"]]
+    value: t.Union["SupportsRichComparison", t.List["SupportsRichComparison"]],
 ) -> bool:
     """
     Check if `value` is monotonically increasing.
@@ -927,7 +930,7 @@ def is_indexed(value: t.Any) -> bool:
 
     Example:
 
-        >>> is_indexed('')
+        >>> is_indexed("")
         True
         >>> is_indexed([])
         True
@@ -1070,7 +1073,7 @@ def is_json(value: t.Any) -> bool:
 
         >>> is_json({})
         False
-        >>> is_json('{}')
+        >>> is_json("{}")
         True
         >>> is_json({"hello": 1, "world": 2})
         False
@@ -1156,11 +1159,11 @@ def is_match_cmp(source: t.Any) -> t.Callable[[t.Any], bool]:
 
     Example:
 
-        >>> is_match_cmp({'b': 2})({'a': 1, 'b': 2})
+        >>> is_match_cmp({"b": 2})({"a": 1, "b": 2})
         True
-        >>> is_match_cmp({'b': 3})({'a': 1, 'b': 2})
+        >>> is_match_cmp({"b": 3})({"a": 1, "b": 2})
         False
-        >>> is_match_cmp({'a': [{'b': [{'d': 4}]}]})({'a': [{'b': [{'c': 3, 'd': 4}]}]})
+        >>> is_match_cmp({"a": [{"b": [{"d": 4}]}]})({"a": [{"b": [{"c": 3, "d": 4}]}]})
         True
 
     .. versionadded:: 7.1.0
@@ -1192,10 +1195,10 @@ def is_match_with(
 
     Example:
 
-        >>> is_greeting = lambda val: val in ('hello', 'hi')
+        >>> is_greeting = lambda val: val in ("hello", "hi")
         >>> customizer = lambda ov, sv: is_greeting(ov) and is_greeting(sv)
-        >>> obj = {'greeting': 'hello'}
-        >>> src = {'greeting': 'hi'}
+        >>> obj = {"greeting": "hello"}
+        >>> src = {"greeting": "hi"}
         >>> is_match_with(obj, src, customizer)
         True
 
@@ -1251,10 +1254,10 @@ def is_match_with_cmp(source: t.Any, customizer: t.Any = None) -> t.Callable[[t.
 
     Example:
 
-        >>> is_greeting = lambda val: val in ('hello', 'hi')
+        >>> is_greeting = lambda val: val in ("hello", "hi")
         >>> customizer = lambda ov, sv: is_greeting(ov) and is_greeting(sv)
-        >>> obj = {'greeting': 'hello'}
-        >>> src = {'greeting': 'hi'}
+        >>> obj = {"greeting": "hello"}
+        >>> src = {"greeting": "hi"}
         >>> is_match_with_cmp(src, customizer)(obj)
         True
 
@@ -1289,7 +1292,9 @@ def is_monotone(value: t.Union[T, t.List[T]], op: t.Callable[[T, T], t.Any]) ->
         l_value = value  # type: ignore
 
     search = (
-        False for x, y in zip(l_value, islice(l_value, 1, None)) if not op(x, y)  # type: ignore
+        False
+        for x, y in zip(l_value, islice(l_value, 1, None))
+        if not op(x, y)  # type: ignore
     )
 
     return next(search, True)
@@ -1331,7 +1336,7 @@ def is_nan(value: t.Any) -> bool:
 
     Example:
 
-        >>> is_nan('a')
+        >>> is_nan("a")
         True
         >>> is_nan(1)
         False
@@ -1409,7 +1414,7 @@ def is_number(value: t.Any) -> bool:
         True
         >>> is_number(1.0)
         True
-        >>> is_number('a')
+        >>> is_number("a")
         False
 
     .. versionadded:: 1.0.0
@@ -1465,7 +1470,7 @@ def is_odd(value: t.Any) -> bool:
         True
         >>> is_odd(2)
         False
-        >>> is_odd('a')
+        >>> is_odd("a")
         False
 
     .. versionadded:: 2.0.0
@@ -1509,9 +1514,9 @@ def is_reg_exp(value: t.Any) -> TypeGuard[re.Pattern]:
 
     Example:
 
-        >>> is_reg_exp(re.compile(''))
+        >>> is_reg_exp(re.compile(""))
         True
-        >>> is_reg_exp('')
+        >>> is_reg_exp("")
         False
 
     .. versionadded:: 1.1.0
@@ -1545,7 +1550,7 @@ def is_set(value: t.Any) -> bool:
 
 
 def is_strictly_decreasing(
-    value: t.Union["SupportsRichComparison", t.List["SupportsRichComparison"]]
+    value: t.Union["SupportsRichComparison", t.List["SupportsRichComparison"]],
 ) -> bool:
     """
     Check if `value` is strictly decreasing.
@@ -1569,7 +1574,7 @@ def is_strictly_decreasing(
 
 
 def is_strictly_increasing(
-    value: t.Union["SupportsRichComparison", t.List["SupportsRichComparison"]]
+    value: t.Union["SupportsRichComparison", t.List["SupportsRichComparison"]],
 ) -> bool:
     """
     Check if `value` is strictly increasing.
@@ -1604,7 +1609,7 @@ def is_string(value: t.Any) -> TypeGuard[str]:
 
     Example:
 
-        >>> is_string('')
+        >>> is_string("")
         True
         >>> is_string(1)
         False
diff --git a/src/pydash/strings.py b/src/pydash/strings.py
index 8fabbf5..acd1359 100644
--- a/src/pydash/strings.py
+++ b/src/pydash/strings.py
@@ -298,7 +298,7 @@ def camel_case(text: t.Any) -> str:
 
     Example:
 
-        >>> camel_case('FOO BAR_bAz')
+        >>> camel_case("FOO BAR_bAz")
         'fooBarBAz'
 
     .. versionadded:: 1.1.0
@@ -323,9 +323,9 @@ def capitalize(text: t.Any, strict: bool = True) -> str:
 
     Example:
 
-        >>> capitalize('once upon a TIME')
+        >>> capitalize("once upon a TIME")
         'Once upon a time'
-        >>> capitalize('once upon a TIME', False)
+        >>> capitalize("once upon a TIME", False)
         'Once upon a TIME'
 
     .. versionadded:: 1.1.0
@@ -349,7 +349,7 @@ def chars(text: t.Any) -> t.List[str]:
 
     Example:
 
-        >>> chars('onetwo')
+        >>> chars("onetwo")
         ['o', 'n', 'e', 't', 'w', 'o']
 
     .. versionadded:: 3.0.0
@@ -370,7 +370,7 @@ def chop(text: t.Any, step: int) -> t.List[str]:
 
     Example:
 
-        >>> chop('abcdefg', 3)
+        >>> chop("abcdefg", 3)
         ['abc', 'def', 'g']
 
     .. versionadded:: 3.0.0
@@ -401,7 +401,7 @@ def chop_right(text: t.Any, step: int) -> t.List[str]:
 
     Example:
 
-        >>> chop_right('abcdefg', 3)
+        >>> chop_right("abcdefg", 3)
         ['a', 'bcd', 'efg']
 
     .. versionadded:: 3.0.0
@@ -432,7 +432,7 @@ def clean(text: t.Any) -> str:
 
     Example:
 
-        >>> clean('a  b   c    d')
+        >>> clean("a  b   c    d")
         'a b c d'
 
     .. versionadded:: 3.0.0
@@ -454,7 +454,7 @@ def count_substr(text: t.Any, subtext: t.Any) -> int:
 
     Example:
 
-        >>> count_substr('aabbccddaabbccdd', 'bc')
+        >>> count_substr("aabbccddaabbccdd", "bc")
         2
 
     .. versionadded:: 3.0.0
@@ -480,9 +480,9 @@ def deburr(text: t.Any) -> str:
 
     Example:
 
-        >>> deburr('déjà vu')
+        >>> deburr("déjà vu")
         '...
-        >>> 'deja vu'
+        >>> "deja vu"
         'deja vu'
 
     .. versionadded:: 2.0.0
@@ -505,7 +505,7 @@ def decapitalize(text: t.Any) -> str:
 
     Example:
 
-        >>> decapitalize('FOO BAR')
+        >>> decapitalize("FOO BAR")
         'fOO BAR'
 
     .. versionadded:: 3.0.0
@@ -528,9 +528,9 @@ def ends_with(text: t.Any, target: t.Any, position: t.Union[int, None] = None) -
 
     Example:
 
-        >>> ends_with('abc def', 'def')
+        >>> ends_with("abc def", "def")
         True
-        >>> ends_with('abc def', 4)
+        >>> ends_with("abc def", 4)
         False
 
     .. versionadded:: 1.1.0
@@ -558,9 +558,9 @@ def ensure_ends_with(text: t.Any, suffix: t.Any) -> str:
 
     Example:
 
-        >>> ensure_ends_with('foo bar', '!')
+        >>> ensure_ends_with("foo bar", "!")
         'foo bar!'
-        >>> ensure_ends_with('foo bar!', '!')
+        >>> ensure_ends_with("foo bar!", "!")
         'foo bar!'
 
     .. versionadded:: 2.4.0
@@ -587,9 +587,9 @@ def ensure_starts_with(text: t.Any, prefix: t.Any) -> str:
 
     Example:
 
-        >>> ensure_starts_with('foo bar', 'Oh my! ')
+        >>> ensure_starts_with("foo bar", "Oh my! ")
         'Oh my! foo bar'
-        >>> ensure_starts_with('Oh my! foo bar', 'Oh my! ')
+        >>> ensure_starts_with("Oh my! foo bar", "Oh my! ")
         'Oh my! foo bar'
 
     .. versionadded:: 2.4.0
@@ -640,7 +640,7 @@ def escape_reg_exp(text: t.Any) -> str:
 
     Example:
 
-        >>> escape_reg_exp('[()]')
+        >>> escape_reg_exp("[()]")
         '\\\\[\\\\(\\\\)\\\\]'
 
     .. versionadded:: 1.1.0
@@ -665,9 +665,9 @@ def has_substr(text: t.Any, subtext: t.Any) -> bool:
 
     Example:
 
-        >>> has_substr('abcdef', 'bc')
+        >>> has_substr("abcdef", "bc")
         True
-        >>> has_substr('abcdef', 'bb')
+        >>> has_substr("abcdef", "bb")
         False
 
     .. versionadded:: 3.0.0
@@ -690,9 +690,9 @@ def human_case(text: t.Any) -> str:
 
     Example:
 
-        >>> human_case('abc-def_hij lmn')
+        >>> human_case("abc-def_hij lmn")
         'Abc def hij lmn'
-        >>> human_case('user_id')
+        >>> human_case("user_id")
         'User'
 
     .. versionadded:: 3.0.0
@@ -724,7 +724,7 @@ def insert_substr(text: t.Any, index: int, subtext: t.Any) -> str:
 
     Example:
 
-        >>> insert_substr('abcdef', 3, '--')
+        >>> insert_substr("abcdef", 3, "--")
         'abc--def'
 
     .. versionadded:: 3.0.0
@@ -747,11 +747,11 @@ def join(array: t.Iterable[t.Any], separator: t.Any = "") -> str:
 
     Example:
 
-        >>> join(['a', 'b', 'c']) == 'abc'
+        >>> join(["a", "b", "c"]) == "abc"
         True
-        >>> join([1, 2, 3, 4], '&') == '1&2&3&4'
+        >>> join([1, 2, 3, 4], "&") == "1&2&3&4"
         True
-        >>> join('abcdef', '-') == 'a-b-c-d-e-f'
+        >>> join("abcdef", "-") == "a-b-c-d-e-f"
         True
 
     .. versionadded:: 2.0.0
@@ -774,7 +774,7 @@ def kebab_case(text: t.Any) -> str:
 
     Example:
 
-        >>> kebab_case('a b c_d-e!f')
+        >>> kebab_case("a b c_d-e!f")
         'a-b-c-d-e-f'
 
     .. versionadded:: 1.1.0
@@ -797,7 +797,7 @@ def lines(text: t.Any) -> t.List[str]:
 
     Example:
 
-        >>> lines('a\nb\r\nc')
+        >>> lines("a\nb\r\nc")
         ['a', 'b', 'c']
 
     .. versionadded:: 3.0.0
@@ -818,9 +818,9 @@ def lower_case(text: t.Any) -> str:
 
     Example:
 
-        >>> lower_case('fooBar')
+        >>> lower_case("fooBar")
         'foo bar'
-        >>> lower_case('--foo-Bar--')
+        >>> lower_case("--foo-Bar--")
         'foo bar'
         >>> lower_case('/?*Foo10/;"B*Ar')
         'foo 10 b ar'
@@ -845,13 +845,13 @@ def lower_first(text: str) -> str:
 
     Example:
 
-        >>> lower_first('FRED')
+        >>> lower_first("FRED")
         'fRED'
-        >>> lower_first('Foo Bar')
+        >>> lower_first("Foo Bar")
         'foo Bar'
-        >>> lower_first('1foobar')
+        >>> lower_first("1foobar")
         '1foobar'
-        >>> lower_first(';foobar')
+        >>> lower_first(";foobar")
         ';foobar'
 
     .. versionadded:: 4.0.0
@@ -878,7 +878,7 @@ def number_format(
 
         >>> number_format(1234.5678)
         '1,235'
-        >>> number_format(1234.5678, 2, ',', '.')
+        >>> number_format(1234.5678, 2, ",", ".")
         '1.234,57'
 
     .. versionadded:: 3.0.0
@@ -919,11 +919,11 @@ def pad(text: t.Any, length: int, chars: t.Any = " ") -> str:
 
     Example:
 
-        >>> pad('abc', 5)
+        >>> pad("abc", 5)
         ' abc '
-        >>> pad('abc', 6, 'x')
+        >>> pad("abc", 6, "x")
         'xabcxx'
-        >>> pad('abc', 5, '...')
+        >>> pad("abc", 5, "...")
         '.abc.'
 
     .. versionadded:: 1.1.0
@@ -962,9 +962,9 @@ def pad_end(text: t.Any, length: int, chars: t.Any = " ") -> str:
 
     Example:
 
-        >>> pad_end('abc', 5)
+        >>> pad_end("abc", 5)
         'abc  '
-        >>> pad_end('abc', 5, '.')
+        >>> pad_end("abc", 5, ".")
         'abc..'
 
     .. versionadded:: 1.1.0
@@ -994,9 +994,9 @@ def pad_start(text: t.Any, length: int, chars: t.Any = " ") -> str:
 
     Example:
 
-        >>> pad_start('abc', 5)
+        >>> pad_start("abc", 5)
         '  abc'
-        >>> pad_start('abc', 5, '.')
+        >>> pad_start("abc", 5, ".")
         '..abc'
 
     .. versionadded:: 1.1.0
@@ -1023,9 +1023,9 @@ def pascal_case(text: t.Any, strict: bool = True) -> str:
 
     Example:
 
-        >>> pascal_case('FOO BAR_bAz')
+        >>> pascal_case("FOO BAR_bAz")
         'FooBarBaz'
-        >>> pascal_case('FOO BAR_bAz', False)
+        >>> pascal_case("FOO BAR_bAz", False)
         'FooBarBAz'
 
     .. versionadded:: 3.0.0
@@ -1053,11 +1053,11 @@ def predecessor(char: t.Any) -> str:
 
     Example:
 
-        >>> predecessor('c')
+        >>> predecessor("c")
         'b'
-        >>> predecessor('C')
+        >>> predecessor("C")
         'B'
-        >>> predecessor('3')
+        >>> predecessor("3")
         '2'
 
     .. versionadded:: 3.0.0
@@ -1083,13 +1083,13 @@ def prune(text: t.Any, length: int = 0, omission: str = "...") -> str:
 
     Example:
 
-        >>> prune('Fe fi fo fum', 5)
+        >>> prune("Fe fi fo fum", 5)
         'Fe fi...'
-        >>> prune('Fe fi fo fum', 6)
+        >>> prune("Fe fi fo fum", 6)
         'Fe fi...'
-        >>> prune('Fe fi fo fum', 7)
+        >>> prune("Fe fi fo fum", 7)
         'Fe fi...'
-        >>> prune('Fe fi fo fum', 8, ',,,')
+        >>> prune("Fe fi fo fum", 8, ",,,")
         'Fe fi fo,,,'
 
     .. versionadded:: 3.0.0
@@ -1140,9 +1140,9 @@ def quote(text: t.Any, quote_char: t.Any = '"') -> str:
 
     Example:
 
-        >>> quote('To be or not to be')
+        >>> quote("To be or not to be")
         '"To be or not to be"'
-        >>> quote('To be or not to be', "'")
+        >>> quote("To be or not to be", "'")
         "'To be or not to be'"
 
     .. versionadded:: 2.4.0
@@ -1163,13 +1163,13 @@ def reg_exp_js_match(text: t.Any, reg_exp: str) -> t.List[str]:
 
     Example:
 
-        >>> reg_exp_js_match('aaBBcc', '/bb/')
+        >>> reg_exp_js_match("aaBBcc", "/bb/")
         []
-        >>> reg_exp_js_match('aaBBcc', '/bb/i')
+        >>> reg_exp_js_match("aaBBcc", "/bb/i")
         ['BB']
-        >>> reg_exp_js_match('aaBBccbb', '/bb/i')
+        >>> reg_exp_js_match("aaBBccbb", "/bb/i")
         ['BB']
-        >>> reg_exp_js_match('aaBBccbb', '/bb/gi')
+        >>> reg_exp_js_match("aaBBccbb", "/bb/gi")
         ['BB', 'bb']
 
     .. versionadded:: 2.0.0
@@ -1200,13 +1200,13 @@ def reg_exp_js_replace(
 
     Example:
 
-        >>> reg_exp_js_replace('aaBBcc', '/bb/', 'X')
+        >>> reg_exp_js_replace("aaBBcc", "/bb/", "X")
         'aaBBcc'
-        >>> reg_exp_js_replace('aaBBcc', '/bb/i', 'X')
+        >>> reg_exp_js_replace("aaBBcc", "/bb/i", "X")
         'aaXcc'
-        >>> reg_exp_js_replace('aaBBccbb', '/bb/i', 'X')
+        >>> reg_exp_js_replace("aaBBccbb", "/bb/i", "X")
         'aaXccbb'
-        >>> reg_exp_js_replace('aaBBccbb', '/bb/gi', 'X')
+        >>> reg_exp_js_replace("aaBBccbb", "/bb/gi", "X")
         'aaXccX'
 
     .. versionadded:: 2.0.0
@@ -1247,13 +1247,13 @@ def reg_exp_replace(
 
     Example:
 
-        >>> reg_exp_replace('aabbcc', 'b', 'X')
+        >>> reg_exp_replace("aabbcc", "b", "X")
         'aaXXcc'
-        >>> reg_exp_replace('aabbcc', 'B', 'X', ignore_case=True)
+        >>> reg_exp_replace("aabbcc", "B", "X", ignore_case=True)
         'aaXXcc'
-        >>> reg_exp_replace('aabbcc', 'b', 'X', count=1)
+        >>> reg_exp_replace("aabbcc", "b", "X", count=1)
         'aaXbcc'
-        >>> reg_exp_replace('aabbcc', '[ab]', 'X')
+        >>> reg_exp_replace("aabbcc", "[ab]", "X")
         'XXXXcc'
 
     .. versionadded:: 3.0.0
@@ -1280,7 +1280,7 @@ def repeat(text: t.Any, n: t.SupportsInt = 0) -> str:
 
     Example:
 
-        >>> repeat('.', 5)
+        >>> repeat(".", 5)
         '.....'
 
     .. versionadded:: 1.1.0
@@ -1320,15 +1320,15 @@ def replace(
 
     Example:
 
-        >>> replace('aabbcc', 'b', 'X')
+        >>> replace("aabbcc", "b", "X")
         'aaXXcc'
-        >>> replace('aabbcc', 'B', 'X', ignore_case=True)
+        >>> replace("aabbcc", "B", "X", ignore_case=True)
         'aaXXcc'
-        >>> replace('aabbcc', 'b', 'X', count=1)
+        >>> replace("aabbcc", "b", "X", count=1)
         'aaXbcc'
-        >>> replace('aabbcc', '[ab]', 'X')
+        >>> replace("aabbcc", "[ab]", "X")
         'aabbcc'
-        >>> replace('aabbcc', '[ab]', 'X', escape=False)
+        >>> replace("aabbcc", "[ab]", "X", escape=False)
         'XXXXcc'
 
     .. versionadded:: 3.0.0
@@ -1393,9 +1393,9 @@ def replace_end(
 
     Example:
 
-        >>> replace_end('aabbcc', 'b', 'X')
+        >>> replace_end("aabbcc", "b", "X")
         'aabbcc'
-        >>> replace_end('aabbcc', 'c', 'X')
+        >>> replace_end("aabbcc", "c", "X")
         'aabbcX'
 
     .. versionadded:: 4.1.0
@@ -1428,9 +1428,9 @@ def replace_start(
 
     Example:
 
-        >>> replace_start('aabbcc', 'b', 'X')
+        >>> replace_start("aabbcc", "b", "X")
         'aabbcc'
-        >>> replace_start('aabbcc', 'a', 'X')
+        >>> replace_start("aabbcc", "a", "X")
         'Xabbcc'
 
     .. versionadded:: 4.1.0
@@ -1451,7 +1451,7 @@ def separator_case(text: t.Any, separator: str) -> str:
 
     Example:
 
-        >>> separator_case('a!!b___c.d', '-')
+        >>> separator_case("a!!b___c.d", "-")
         'a-b-c-d'
 
     .. versionadded:: 3.0.0
@@ -1483,11 +1483,11 @@ def series_phrase(
 
     Example:
 
-        >>> series_phrase(['apples', 'bananas', 'peaches'])
+        >>> series_phrase(["apples", "bananas", "peaches"])
         'apples, bananas and peaches'
-        >>> series_phrase(['apples', 'bananas', 'peaches'], serial=True)
+        >>> series_phrase(["apples", "bananas", "peaches"], serial=True)
         'apples, bananas, and peaches'
-        >>> series_phrase(['apples', 'bananas', 'peaches'], '; ', ', or ')
+        >>> series_phrase(["apples", "bananas", "peaches"], "; ", ", or ")
         'apples; bananas, or peaches'
 
 
@@ -1525,7 +1525,7 @@ def series_phrase_serial(
 
     Example:
 
-        >>> series_phrase_serial(['apples', 'bananas', 'peaches'])
+        >>> series_phrase_serial(["apples", "bananas", "peaches"])
         'apples, bananas, and peaches'
 
     .. versionadded:: 3.0.0
@@ -1550,9 +1550,9 @@ def slugify(text: t.Any, separator: str = "-") -> str:
 
     Example:
 
-        >>> slugify('This is a slug.') == 'this-is-a-slug'
+        >>> slugify("This is a slug.") == "this-is-a-slug"
         True
-        >>> slugify('This is a slug.', '+') == 'this+is+a+slug'
+        >>> slugify("This is a slug.", "+") == "this+is+a+slug"
         True
 
     .. versionadded:: 3.0.0
@@ -1585,7 +1585,7 @@ def snake_case(text: t.Any) -> str:
 
     Example:
 
-        >>> snake_case('This is Snake Case!')
+        >>> snake_case("This is Snake Case!")
         'this_is_snake_case'
 
     .. versionadded:: 1.1.0
@@ -1613,9 +1613,9 @@ def split(text: t.Any, separator: t.Union[str, Unset, None] = UNSET) -> t.List[s
 
     Example:
 
-        >>> split('one potato, two potatoes, three potatoes, four!')
+        >>> split("one potato, two potatoes, three potatoes, four!")
         ['one', 'potato,', 'two', 'potatoes,', 'three', 'potatoes,', 'four!']
-        >>> split('one potato, two potatoes, three potatoes, four!', ',')
+        >>> split("one potato, two potatoes, three potatoes, four!", ",")
         ['one potato', ' two potatoes', ' three potatoes', ' four!']
 
     .. versionadded:: 2.0.0
@@ -1675,11 +1675,11 @@ def starts_with(text: t.Any, target: t.Any, position: int = 0) -> bool:
 
     Example:
 
-        >>> starts_with('abcdef', 'a')
+        >>> starts_with("abcdef", "a")
         True
-        >>> starts_with('abcdef', 'b')
+        >>> starts_with("abcdef", "b")
         False
-        >>> starts_with('abcdef', 'a', 1)
+        >>> starts_with("abcdef", "a", 1)
         False
 
     .. versionadded:: 1.1.0
@@ -1723,7 +1723,7 @@ def substr_left(text: t.Any, subtext: str) -> str:
 
     Example:
 
-        >>> substr_left('abcdefcdg', 'cd')
+        >>> substr_left("abcdefcdg", "cd")
         'ab'
 
     .. versionadded:: 3.0.0
@@ -1746,7 +1746,7 @@ def substr_left_end(text: t.Any, subtext: str) -> str:
 
     Example:
 
-        >>> substr_left_end('abcdefcdg', 'cd')
+        >>> substr_left_end("abcdefcdg", "cd")
         'abcdef'
 
     .. versionadded:: 3.0.0
@@ -1769,7 +1769,7 @@ def substr_right(text: t.Any, subtext: str) -> str:
 
     Example:
 
-        >>> substr_right('abcdefcdg', 'cd')
+        >>> substr_right("abcdefcdg", "cd")
         'efcdg'
 
     .. versionadded:: 3.0.0
@@ -1792,7 +1792,7 @@ def substr_right_end(text: t.Any, subtext: str) -> str:
 
     Example:
 
-        >>> substr_right_end('abcdefcdg', 'cd')
+        >>> substr_right_end("abcdefcdg", "cd")
         'g'
 
     .. versionadded:: 3.0.0
@@ -1813,11 +1813,11 @@ def successor(char: t.Any) -> str:
 
     Example:
 
-        >>> successor('b')
+        >>> successor("b")
         'c'
-        >>> successor('B')
+        >>> successor("B")
         'C'
-        >>> successor('2')
+        >>> successor("2")
         '3'
 
     .. versionadded:: 3.0.0
@@ -1839,9 +1839,9 @@ def surround(text: t.Any, wrapper: t.Any) -> str:
 
     Example:
 
-        >>> surround('abc', '"')
+        >>> surround("abc", '"')
         '"abc"'
-        >>> surround('abc', '!')
+        >>> surround("abc", "!")
         '!abc!'
 
     .. versionadded:: 2.4.0
@@ -1863,7 +1863,7 @@ def swap_case(text: t.Any) -> str:
 
     Example:
 
-        >>> swap_case('aBcDeF')
+        >>> swap_case("aBcDeF")
         'AbCdEf'
 
     .. versionadded:: 3.0.0
@@ -1906,11 +1906,11 @@ def to_lower(text: t.Any) -> str:
 
     Example:
 
-        >>> to_lower('--Foo-Bar--')
+        >>> to_lower("--Foo-Bar--")
         '--foo-bar--'
-        >>> to_lower('fooBar')
+        >>> to_lower("fooBar")
         'foobar'
-        >>> to_lower('__FOO_BAR__')
+        >>> to_lower("__FOO_BAR__")
         '__foo_bar__'
 
     .. versionadded:: 4.0.0
@@ -1930,11 +1930,11 @@ def to_upper(text: t.Any) -> str:
 
     Example:
 
-        >>> to_upper('--Foo-Bar--')
+        >>> to_upper("--Foo-Bar--")
         '--FOO-BAR--'
-        >>> to_upper('fooBar')
+        >>> to_upper("fooBar")
         'FOOBAR'
-        >>> to_upper('__FOO_BAR__')
+        >>> to_upper("__FOO_BAR__")
         '__FOO_BAR__'
 
     .. versionadded:: 4.0.0
@@ -1955,7 +1955,7 @@ def trim(text: t.Any, chars: t.Union[str, None] = None) -> str:
 
     Example:
 
-        >>> trim('  abc efg\r\n ')
+        >>> trim("  abc efg\r\n ")
         'abc efg'
 
     .. versionadded:: 1.1.0
@@ -1978,7 +1978,7 @@ def trim_end(text: t.Any, chars: t.Union[str, None] = None) -> str:
 
     Example:
 
-        >>> trim_end('  abc efg\r\n ')
+        >>> trim_end("  abc efg\r\n ")
         '  abc efg'
 
     .. versionadded:: 1.1.0
@@ -2003,7 +2003,7 @@ def trim_start(text: t.Any, chars: t.Union[str, None] = None) -> str:
 
     Example:
 
-        >>> trim_start('  abc efg\r\n ')
+        >>> trim_start("  abc efg\r\n ")
         'abc efg\r\n '
 
     .. versionadded:: 1.1.0
@@ -2036,13 +2036,13 @@ def truncate(
 
     Example:
 
-        >>> truncate('hello world', 5)
+        >>> truncate("hello world", 5)
         'he...'
-        >>> truncate('hello world', 5, '..')
+        >>> truncate("hello world", 5, "..")
         'hel..'
-        >>> truncate('hello world', 10)
+        >>> truncate("hello world", 10)
         'hello w...'
-        >>> truncate('hello world', 10, separator=' ')
+        >>> truncate("hello world", 10, separator=" ")
         'hello...'
 
     .. versionadded:: 1.1.0
@@ -2087,7 +2087,7 @@ def unescape(text: t.Any) -> str:
 
     Example:
 
-        >>> results = unescape('&quot;1 &gt; 2 &amp;&amp; 3 &lt; 4&quot;')
+        >>> results = unescape("&quot;1 &gt; 2 &amp;&amp; 3 &lt; 4&quot;")
         >>> results == '"1 > 2 && 3 < 4"'
         True
 
@@ -2112,9 +2112,9 @@ def upper_case(text: t.Any) -> str:
 
     Example:
 
-        >>> upper_case('--foo-bar--')
+        >>> upper_case("--foo-bar--")
         'FOO BAR'
-        >>> upper_case('fooBar')
+        >>> upper_case("fooBar")
         'FOO BAR'
         >>> upper_case('/?*Foo10/;"B*Ar')
         'FOO 10 B AR'
@@ -2139,13 +2139,13 @@ def upper_first(text: str) -> str:
 
     Example:
 
-        >>> upper_first('fred')
+        >>> upper_first("fred")
         'Fred'
-        >>> upper_first('foo bar')
+        >>> upper_first("foo bar")
         'Foo bar'
-        >>> upper_first('1foobar')
+        >>> upper_first("1foobar")
         '1foobar'
-        >>> upper_first(';foobar')
+        >>> upper_first(";foobar")
         ';foobar'
 
     .. versionadded:: 4.0.0
@@ -2168,11 +2168,11 @@ def unquote(text: t.Any, quote_char: t.Any = '"') -> str:
 
         >>> unquote('"abc"')
         'abc'
-        >>> unquote('"abc"', '#')
+        >>> unquote('"abc"', "#")
         '"abc"'
-        >>> unquote('#abc', '#')
+        >>> unquote("#abc", "#")
         '#abc'
-        >>> unquote('#abc#', '#')
+        >>> unquote("#abc#", "#")
         'abc'
 
     .. versionadded:: 3.0.0
@@ -2202,11 +2202,11 @@ def url(*paths: t.Any, **params: t.Any) -> str:
 
     Example:
 
-        >>> link = url('a', 'b', ['c', 'd'], '/', q='X', y='Z')
-        >>> path, params = link.split('?')
-        >>> path == 'a/b/c/d/'
+        >>> link = url("a", "b", ["c", "d"], "/", q="X", y="Z")
+        >>> path, params = link.split("?")
+        >>> path == "a/b/c/d/"
         True
-        >>> set(params.split('&')) == set(['q=X', 'y=Z'])
+        >>> set(params.split("&")) == set(["q=X", "y=Z"])
         True
 
     .. versionadded:: 2.2.0
@@ -2245,9 +2245,9 @@ def words(text: t.Any, pattern: t.Union[str, None] = None) -> t.List[str]:
 
     Example:
 
-        >>> words('a b, c; d-e')
+        >>> words("a b, c; d-e")
         ['a', 'b', 'c', 'd', 'e']
-        >>> words('fred, barney, & pebbles', '/[^, ]+/g')
+        >>> words("fred, barney, & pebbles", "/[^, ]+/g")
         ['fred', 'barney', '&', 'pebbles']
 
     .. versionadded:: 2.0.0
@@ -2304,19 +2304,19 @@ def delimitedpathjoin(delimiter, *paths):
     """
     Join delimited path using specified delimiter.
 
-    >>> assert delimitedpathjoin('.', '') == ''
-    >>> assert delimitedpathjoin('.', '.') == '.'
-    >>> assert delimitedpathjoin('.', ['', '.a']) == '.a'
-    >>> assert delimitedpathjoin('.', ['a', '.']) == 'a.'
-    >>> assert delimitedpathjoin('.', ['', '.a', '', '', 'b']) == '.a.b'
-    >>> ret = '.a.b.c.d.e.'
-    >>> assert delimitedpathjoin('.', ['.a.', 'b.', '.c', 'd', 'e.']) == ret
-    >>> assert delimitedpathjoin('.', ['a', 'b', 'c']) == 'a.b.c'
-    >>> ret = 'a.b.c.d.e.f'
-    >>> assert delimitedpathjoin('.', ['a.b', '.c.d.', '.e.f']) == ret
-    >>> ret = '.a.b.c.1.'
-    >>> assert delimitedpathjoin('.', '.', 'a', 'b', 'c', 1, '.') == ret
-    >>> assert delimitedpathjoin('.', []) == ''
+    >>> assert delimitedpathjoin(".", "") == ""
+    >>> assert delimitedpathjoin(".", ".") == "."
+    >>> assert delimitedpathjoin(".", ["", ".a"]) == ".a"
+    >>> assert delimitedpathjoin(".", ["a", "."]) == "a."
+    >>> assert delimitedpathjoin(".", ["", ".a", "", "", "b"]) == ".a.b"
+    >>> ret = ".a.b.c.d.e."
+    >>> assert delimitedpathjoin(".", [".a.", "b.", ".c", "d", "e."]) == ret
+    >>> assert delimitedpathjoin(".", ["a", "b", "c"]) == "a.b.c"
+    >>> ret = "a.b.c.d.e.f"
+    >>> assert delimitedpathjoin(".", ["a.b", ".c.d.", ".e.f"]) == ret
+    >>> ret = ".a.b.c.1."
+    >>> assert delimitedpathjoin(".", ".", "a", "b", "c", 1, ".") == ret
+    >>> assert delimitedpathjoin(".", []) == ""
     """
     paths = [pyd.to_string(path) for path in pyd.flatten_deep(paths) if path]
 
@@ -2343,10 +2343,10 @@ def flatten_url_params(
     Flatten URL params into list of tuples. If any param value is a list or tuple, then map each
     value to the param key.
 
-    >>> params = [('a', 1), ('a', [2, 3])]
-    >>> assert flatten_url_params(params) == [('a', 1), ('a', 2), ('a', 3)]
-    >>> params = {'a': [1, 2, 3]}
-    >>> assert flatten_url_params(params) == [('a', 1), ('a', 2), ('a', 3)]
+    >>> params = [("a", 1), ("a", [2, 3])]
+    >>> assert flatten_url_params(params) == [("a", 1), ("a", 2), ("a", 3)]
+    >>> params = {"a": [1, 2, 3]}
+    >>> assert flatten_url_params(params) == [("a", 1), ("a", 2), ("a", 3)]
     """
     if isinstance(params, dict):
         params = list(params.items())
diff --git a/src/pydash/types.py b/src/pydash/types.py
index 8c1535e..c6c882c 100644
--- a/src/pydash/types.py
+++ b/src/pydash/types.py
@@ -15,8 +15,10 @@
 
 
 class SupportsMul(Protocol[_T_contra, _T_co]):
-    def __mul__(self, x: _T_contra) -> _T_co: ...
+    def __mul__(self, x: _T_contra) -> _T_co:
+        ...
 
 
 class SupportsRound(Protocol[_T_co]):
-    def __round__(self) -> _T_co: ...
+    def __round__(self) -> _T_co:
+        ...
diff --git a/src/pydash/utilities.py b/src/pydash/utilities.py
index 55e06bb..b9a5a66 100644
--- a/src/pydash/utilities.py
+++ b/src/pydash/utilities.py
@@ -94,7 +94,7 @@ def attempt(func: t.Callable[P, T], *args: "P.args", **kwargs: "P.kwargs") -> t.
 
     Example:
 
-        >>> results = attempt(lambda x: x/0, 1)
+        >>> results = attempt(lambda x: x / 0, 1)
         >>> assert isinstance(results, ZeroDivisionError)
 
     .. versionadded:: 1.1.0
@@ -112,13 +112,15 @@ def attempt(func: t.Callable[P, T], *args: "P.args", **kwargs: "P.kwargs") -> t.
 def cond(
     pairs: t.List[t.Tuple[t.Callable[P, t.Any], t.Callable[P, T]]],
     *extra_pairs: t.Tuple[t.Callable[P, t.Any], t.Callable[P, T]],
-) -> t.Callable[P, T]: ...
+) -> t.Callable[P, T]:
+    ...
 
 
 @t.overload
 def cond(
     pairs: t.List[t.List[t.Callable[P, t.Any]]], *extra_pairs: t.List[t.Callable[P, t.Any]]
-) -> t.Callable[P, t.Any]: ...
+) -> t.Callable[P, t.Any]:
+    ...
 
 
 def cond(pairs, *extra_pairs):
@@ -177,11 +179,13 @@ def _cond(*args):
 
 
 @t.overload
-def conforms(source: t.Dict[T, t.Callable[[T2], t.Any]]) -> t.Callable[[t.Dict[T, T2]], bool]: ...
+def conforms(source: t.Dict[T, t.Callable[[T2], t.Any]]) -> t.Callable[[t.Dict[T, T2]], bool]:
+    ...
 
 
 @t.overload
-def conforms(source: t.List[t.Callable[[T], t.Any]]) -> t.Callable[[t.List[T]], bool]: ...
+def conforms(source: t.List[t.Callable[[T], t.Any]]) -> t.Callable[[t.List[T]], bool]:
+    ...
 
 
 def conforms(source: t.Union[t.List, t.Dict]) -> t.Callable:
@@ -198,10 +202,10 @@ def conforms(source: t.Union[t.List, t.Dict]) -> t.Callable:
 
     Example:
 
-        >>> func = conforms({'b': lambda n: n > 1})
-        >>> func({'b': 2})
+        >>> func = conforms({"b": lambda n: n > 1})
+        >>> func({"b": 2})
         True
-        >>> func({'b': 0})
+        >>> func({"b": 0})
         False
         >>> func = conforms([lambda n: n > 1, lambda n: n == 0])
         >>> func([2, 0])
@@ -222,11 +226,13 @@ def _conforms(obj):
 
 
 @t.overload
-def conforms_to(obj: t.Dict[T, T2], source: t.Dict[T, t.Callable[[T2], t.Any]]) -> bool: ...
+def conforms_to(obj: t.Dict[T, T2], source: t.Dict[T, t.Callable[[T2], t.Any]]) -> bool:
+    ...
 
 
 @t.overload
-def conforms_to(obj: t.List[T], source: t.List[t.Callable[[T], t.Any]]) -> bool: ...
+def conforms_to(obj: t.List[T], source: t.List[t.Callable[[T], t.Any]]) -> bool:
+    ...
 
 
 def conforms_to(obj, source):
@@ -240,9 +246,9 @@ def conforms_to(obj, source):
 
     Example:
 
-        >>> conforms_to({'b': 2}, {'b': lambda n: n > 1})
+        >>> conforms_to({"b": 2}, {"b": lambda n: n > 1})
         True
-        >>> conforms_to({'b': 0}, {'b': lambda n: n > 1})
+        >>> conforms_to({"b": 0}, {"b": lambda n: n > 1})
         False
         >>> conforms_to([2, 0], [lambda n: n > 1, lambda n: n == 0])
         True
@@ -302,7 +308,8 @@ def default_to(value: t.Union[T, None], default_value: T2) -> t.Union[T, T2]:
 
 
 @t.overload
-def default_to_any(value: None, *default_values: None) -> None: ...
+def default_to_any(value: None, *default_values: None) -> None:
+    ...
 
 
 @t.overload
@@ -310,7 +317,8 @@ def default_to_any(
     value: t.Union[T, None],
     default_value1: None,
     default_value2: T2,
-) -> t.Union[T, T2]: ...
+) -> t.Union[T, T2]:
+    ...
 
 
 @t.overload
@@ -319,7 +327,8 @@ def default_to_any(
     default_value1: None,
     default_value2: None,
     default_value3: T2,
-) -> t.Union[T, T2]: ...
+) -> t.Union[T, T2]:
+    ...
 
 
 @t.overload
@@ -329,7 +338,8 @@ def default_to_any(
     default_value2: None,
     default_value3: None,
     default_value4: T2,
-) -> t.Union[T, T2]: ...
+) -> t.Union[T, T2]:
+    ...
 
 
 @t.overload
@@ -340,11 +350,13 @@ def default_to_any(
     default_value3: None,
     default_value4: None,
     default_value5: T2,
-) -> t.Union[T, T2]: ...
+) -> t.Union[T, T2]:
+    ...
 
 
 @t.overload
-def default_to_any(value: t.Union[T, None], *default_values: T2) -> t.Union[T, T2]: ...
+def default_to_any(value: t.Union[T, None], *default_values: T2) -> t.Union[T, T2]:
+    ...
 
 
 def default_to_any(value, *default_values):
@@ -379,11 +391,13 @@ def default_to_any(value, *default_values):
 
 
 @t.overload
-def identity(arg: T, *args: t.Any) -> T: ...
+def identity(arg: T, *args: t.Any) -> T:
+    ...
 
 
 @t.overload
-def identity(arg: None = None, *args: t.Any) -> None: ...
+def identity(arg: None = None, *args: t.Any) -> None:
+    ...
 
 
 def identity(arg=None, *args):
@@ -411,11 +425,13 @@ def identity(arg=None, *args):
 
 
 @t.overload
-def iteratee(func: t.Callable[P, T]) -> t.Callable[P, T]: ...
+def iteratee(func: t.Callable[P, T]) -> t.Callable[P, T]:
+    ...
 
 
 @t.overload
-def iteratee(func: t.Any) -> t.Callable: ...
+def iteratee(func: t.Any) -> t.Callable:
+    ...
 
 
 def iteratee(func):
@@ -433,26 +449,26 @@ def iteratee(func):
 
     Example:
 
-        >>> get_data = iteratee('data')
-        >>> get_data({'data': [1, 2, 3]})
+        >>> get_data = iteratee("data")
+        >>> get_data({"data": [1, 2, 3]})
         [1, 2, 3]
-        >>> is_active = iteratee({'active': True})
-        >>> is_active({'active': True})
+        >>> is_active = iteratee({"active": True})
+        >>> is_active({"active": True})
         True
-        >>> is_active({'active': 0})
+        >>> is_active({"active": 0})
         False
-        >>> iteratee(['a', 5])({'a': 5})
+        >>> iteratee(["a", 5])({"a": 5})
         True
-        >>> iteratee(['a.b'])({'a.b': 5})
+        >>> iteratee(["a.b"])({"a.b": 5})
         5
-        >>> iteratee('a.b')({'a': {'b': 5}})
+        >>> iteratee("a.b")({"a": {"b": 5}})
         5
-        >>> iteratee(('a', ['c', 'd', 'e']))({'a': 1, 'c': {'d': {'e': 3}}})
+        >>> iteratee(("a", ["c", "d", "e"]))({"a": 1, "c": {"d": {"e": 3}}})
         [1, 3]
         >>> iteratee(lambda a, b: a + b)(1, 2)
         3
         >>> ident = iteratee(None)
-        >>> ident('a')
+        >>> ident("a")
         'a'
         >>> ident(1, 2, 3)
         1
@@ -516,11 +532,11 @@ def matches(source: t.Any) -> t.Callable[[t.Any], bool]:
 
     Example:
 
-        >>> matches({'a': {'b': 2}})({'a': {'b': 2, 'c':3}})
+        >>> matches({"a": {"b": 2}})({"a": {"b": 2, "c": 3}})
         True
-        >>> matches({'a': 1})({'b': 2, 'a': 1})
+        >>> matches({"a": 1})({"b": 2, "a": 1})
         True
-        >>> matches({'a': 1})({'b': 2, 'a': 2})
+        >>> matches({"a": 1})({"b": 2, "a": 2})
         False
 
     .. versionadded:: 1.0.0
@@ -545,11 +561,11 @@ def matches_property(key: t.Any, value: t.Any) -> t.Callable[[t.Any], bool]:
 
     Example:
 
-        >>> matches_property('a', 1)({'a': 1, 'b': 2})
+        >>> matches_property("a", 1)({"a": 1, "b": 2})
         True
         >>> matches_property(0, 1)([1, 2, 3])
         True
-        >>> matches_property('a', 2)({'a': 1, 'b': 2})
+        >>> matches_property("a", 2)({"a": 1, "b": 2})
         False
 
     .. versionadded:: 3.1.0
@@ -561,17 +577,20 @@ def matches_property(key: t.Any, value: t.Any) -> t.Callable[[t.Any], bool]:
 class MemoizedFunc(Protocol[P, T, T2]):
     cache: t.Dict[T2, T]
 
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T: ...  # pragma: no cover
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        ...  # pragma: no cover
 
 
 @t.overload
-def memoize(func: t.Callable[P, T], resolver: None = None) -> MemoizedFunc[P, T, str]: ...
+def memoize(func: t.Callable[P, T], resolver: None = None) -> MemoizedFunc[P, T, str]:
+    ...
 
 
 @t.overload
 def memoize(
     func: t.Callable[P, T], resolver: t.Union[t.Callable[P, T2], None] = None
-) -> MemoizedFunc[P, T, T2]: ...
+) -> MemoizedFunc[P, T, T2]:
+    ...
 
 
 def memoize(func, resolver=None):
@@ -593,11 +612,11 @@ def memoize(func, resolver=None):
         >>> ident = memoize(identity)
         >>> ident(1)
         1
-        >>> ident.cache['(1,){}'] == 1
+        >>> ident.cache["(1,){}"] == 1
         True
         >>> ident(1, 2, 3)
         1
-        >>> ident.cache['(1, 2, 3){}'] == 1
+        >>> ident.cache["(1, 2, 3){}"] == 1
         True
 
     .. versionadded:: 1.0.0
@@ -634,11 +653,11 @@ def method(path: PathT, *args: t.Any, **kwargs: t.Any) -> t.Callable[..., t.Any]
 
     Example:
 
-        >>> obj = {'a': {'b': [None, lambda x: x]}}
-        >>> echo = method('a.b.1')
+        >>> obj = {"a": {"b": [None, lambda x: x]}}
+        >>> echo = method("a.b.1")
         >>> echo(obj, 1) == 1
         True
-        >>> echo(obj, 'one') == 'one'
+        >>> echo(obj, "one") == "one"
         True
 
     .. versionadded:: 3.3.0
@@ -666,11 +685,11 @@ def method_of(obj: t.Any, *args: t.Any, **kwargs: t.Any) -> t.Callable[..., t.An
 
     Example:
 
-        >>> obj = {'a': {'b': [None, lambda x: x]}}
+        >>> obj = {"a": {"b": [None, lambda x: x]}}
         >>> dispatch = method_of(obj)
-        >>> dispatch('a.b.1', 1) == 1
+        >>> dispatch("a.b.1", 1) == 1
         True
-        >>> dispatch('a.b.1', 'one') == 'one'
+        >>> dispatch("a.b.1", "one") == "one"
         True
 
     .. versionadded:: 3.3.0
@@ -834,8 +853,8 @@ def property_(path: PathT) -> t.Callable[[t.Any], t.Any]:
 
     Example:
 
-        >>> get_data = property_('data')
-        >>> get_data({'data': 1})
+        >>> get_data = property_("data")
+        >>> get_data({"data": 1})
         1
         >>> get_data({}) is None
         True
@@ -863,8 +882,8 @@ def properties(*paths: t.Any) -> t.Callable[[t.Any], t.Any]:
 
     Example:
 
-        >>> getter = properties('a', 'b', ['c', 'd', 'e'])
-        >>> getter({'a': 1, 'b': 2, 'c': {'d': {'e': 3}}})
+        >>> getter = properties("a", "b", ["c", "d", "e"])
+        >>> getter({"a": 1, "b": 2, "c": {"d": {"e": 3}}})
         [1, 2, 3]
 
     .. versionadded:: 4.1.0
@@ -885,12 +904,12 @@ def property_of(obj: t.Any) -> t.Callable[[PathT], t.Any]:
 
     Example:
 
-        >>> getter = property_of({'a': 1, 'b': 2, 'c': 3})
-        >>> getter('a')
+        >>> getter = property_of({"a": 1, "b": 2, "c": 3})
+        >>> getter("a")
         1
-        >>> getter('b')
+        >>> getter("b")
         2
-        >>> getter('x') is None
+        >>> getter("x") is None
         True
 
     .. versionadded:: 3.0.0
@@ -902,25 +921,30 @@ def property_of(obj: t.Any) -> t.Callable[[PathT], t.Any]:
 
 
 @t.overload
-def random(start: int = 0, stop: int = 1, *, floating: Literal[False] = False) -> int: ...
+def random(start: int = 0, stop: int = 1, *, floating: Literal[False] = False) -> int:
+    ...
 
 
 @t.overload
-def random(start: float, stop: int = 1, floating: bool = False) -> float: ...
+def random(start: float, stop: int = 1, floating: bool = False) -> float:
+    ...
 
 
 @t.overload
-def random(start: int = 0, *, stop: float, floating: bool = False) -> float: ...
+def random(start: int = 0, *, stop: float, floating: bool = False) -> float:
+    ...
 
 
 @t.overload
-def random(start: float, stop: float, floating: bool = False) -> float: ...
+def random(start: float, stop: float, floating: bool = False) -> float:
+    ...
 
 
 @t.overload
 def random(
     start: t.Union[float, int] = 0, stop: t.Union[float, int] = 1, *, floating: Literal[True]
-) -> float: ...
+) -> float:
+    ...
 
 
 def random(start: t.Union[float, int] = 0, stop: t.Union[float, int] = 1, floating: bool = False):
@@ -964,11 +988,13 @@ def random(start: t.Union[float, int] = 0, stop: t.Union[float, int] = 1, floati
 
 
 @t.overload
-def range_(stop: int) -> t.Generator[int, None, None]: ...
+def range_(stop: int) -> t.Generator[int, None, None]:
+    ...
 
 
 @t.overload
-def range_(start: int, stop: int, step: int = 1) -> t.Generator[int, None, None]: ...
+def range_(start: int, stop: int, step: int = 1) -> t.Generator[int, None, None]:
+    ...
 
 
 def range_(*args):
@@ -1011,11 +1037,13 @@ def range_(*args):
 
 
 @t.overload
-def range_right(stop: int) -> t.Generator[int, None, None]: ...
+def range_right(stop: int) -> t.Generator[int, None, None]:
+    ...
 
 
 @t.overload
-def range_right(start: int, stop: int, step: int = 1) -> t.Generator[int, None, None]: ...
+def range_right(start: int, stop: int, step: int = 1) -> t.Generator[int, None, None]:
+    ...
 
 
 def range_right(*args):
@@ -1047,15 +1075,18 @@ def range_right(*args):
 
 # TODO
 @t.overload
-def result(obj: None, key: t.Any, default: None = None) -> None: ...
+def result(obj: None, key: t.Any, default: None = None) -> None:
+    ...
 
 
 @t.overload
-def result(obj: None, key: t.Any, default: T) -> T: ...
+def result(obj: None, key: t.Any, default: T) -> T:
+    ...
 
 
 @t.overload
-def result(obj: t.Any, key: t.Any, default: t.Any = None) -> t.Any: ...
+def result(obj: t.Any, key: t.Any, default: t.Any = None) -> t.Any:
+    ...
 
 
 def result(obj, key, default=None):
@@ -1074,13 +1105,13 @@ def result(obj, key, default=None):
 
     Example:
 
-        >>> result({'a': 1, 'b': lambda: 2}, 'a')
+        >>> result({"a": 1, "b": lambda: 2}, "a")
         1
-        >>> result({'a': 1, 'b': lambda: 2}, 'b')
+        >>> result({"a": 1, "b": lambda: 2}, "b")
         2
-        >>> result({'a': 1, 'b': lambda: 2}, 'c') is None
+        >>> result({"a": 1, "b": lambda: 2}, "c") is None
         True
-        >>> result({'a': 1, 'b': lambda: 2}, 'c', default=False)
+        >>> result({"a": 1, "b": lambda: 2}, "c", default=False)
         False
 
     .. versionadded:: 1.0.0
@@ -1099,7 +1130,7 @@ def result(obj, key, default=None):
     return ret
 
 
-def retry(  # noqa: C901
+def retry(
     attempts: int = 3,
     delay: t.Union[int, float] = 0.5,
     max_delay: t.Union[int, float] = 150.0,
@@ -1141,10 +1172,12 @@ def retry(  # noqa: C901
 
         >>> @retry(attempts=3, delay=0)
         ... def do_something():
-        ...     print('something')
-        ...     raise Exception('something went wrong')
-        >>> try: do_something()
-        ... except Exception: print('caught something')
+        ...     print("something")
+        ...     raise Exception("something went wrong")
+        >>> try:
+        ...     do_something()
+        ... except Exception:
+        ...     print("caught something")
         something
         something
         something
@@ -1311,11 +1344,13 @@ def stub_true() -> Literal[True]:
 
 
 @t.overload
-def times(n: int, iteratee: t.Callable[..., T]) -> t.List[T]: ...
+def times(n: int, iteratee: t.Callable[..., T]) -> t.List[T]:
+    ...
 
 
 @t.overload
-def times(n: int, iteratee: None = None) -> t.List[int]: ...
+def times(n: int, iteratee: None = None) -> t.List[int]:
+    ...
 
 
 def times(n: int, iteratee=None):
@@ -1366,11 +1401,11 @@ def to_path(value: PathT) -> t.List[t.Hashable]:
 
     Example:
 
-        >>> to_path('a.b.c')
+        >>> to_path("a.b.c")
         ['a', 'b', 'c']
-        >>> to_path('a[0].b.c')
+        >>> to_path("a[0].b.c")
         ['a', 0, 'b', 'c']
-        >>> to_path('a[0][1][2].b.c')
+        >>> to_path("a[0][1][2].b.c")
         ['a', 0, 1, 2, 'b', 'c']
 
     .. versionadded:: 4.0.0
@@ -1396,7 +1431,7 @@ def unique_id(prefix: t.Union[str, None] = None) -> str:
 
         >>> unique_id()
         '1'
-        >>> unique_id('id_')
+        >>> unique_id("id_")
         'id_2'
         >>> unique_id()
         '3'
@@ -1404,7 +1439,7 @@ def unique_id(prefix: t.Union[str, None] = None) -> str:
     .. versionadded:: 1.0.0
     """
     # pylint: disable=global-statement
-    global ID_COUNTER
+    global ID_COUNTER  # noqa: PLW0603
     ID_COUNTER += 1
 
     if prefix is None:
diff --git a/tasks.py b/tasks.py
index 7559f33..6337617 100644
--- a/tasks.py
+++ b/tasks.py
@@ -23,7 +23,6 @@
 MYPY_TESTS_DIR = "tests/pytest_mypy_testing"
 TEST_TARGETS = f"{PACKAGE_SOURCE} tests"
 LINT_TARGETS = f"{TEST_TARGETS} tasks.py"
-LINT_EXCLUDE = MYPY_TESTS_DIR
 EXIT_EXCEPTIONS = (Exit, UnexpectedExit, SystemExit)
 
 
@@ -32,66 +31,46 @@
 
 
 @task()
-def black(ctx: Context, target: t.Optional[str] = None, quiet: bool = False) -> None:
-    """Autoformat code using black."""
-    run(f"black --exclude='{LINT_EXCLUDE}' {target or LINT_TARGETS}", hide=quiet)
+def ruff_format(ctx: Context, target: str, quiet: bool = False) -> None:
+    """Autoformat code and docstrings using ruff."""
+    run(f"ruff format {target}", hide=quiet)
 
 
 @task()
-def isort(ctx: Context, target: t.Optional[str] = None, quiet: bool = False) -> None:
-    """Autoformat Python imports."""
-    run(f"isort {target or LINT_TARGETS}", hide=quiet)
-
-
-@task()
-def docformatter(ctx: Context, target: t.Optional[str] = None) -> None:
-    """Autoformat docstrings using docformatter."""
-    run(
-        f"docformatter -r {target or LINT_TARGETS} "
-        f"--in-place --pre-summary-newline --wrap-descriptions 100 --wrap-summaries 100"
-    )
+def ruff_fix(ctx: Context, target: str, quiet: bool = False) -> None:
+    """Autofix fixable lint issues using ruff."""
+    run(f"ruff check {target} --fix", hide=quiet)
 
 
 @task()
 def fmt(ctx: Context, target: t.Optional[str] = None, quiet: bool = False) -> None:
     """Autoformat code and docstrings."""
     if not quiet:
-        print("Running docformatter")
-    docformatter(ctx, target)
+        print("Running ruff format")
+    ruff_format(ctx, target or ".", quiet=quiet)
 
     if not quiet:
-        print("Running isort")
-    isort(ctx, target, quiet=True)
-
-    if not quiet:
-        print("Running black")
-    black(ctx, target, quiet=True)
-
-
-@task()
-def flake8(ctx: Context) -> None:
-    """Check code for PEP8 violations using flake8."""
-    run(f"flake8 --format=pylint --exclude='{LINT_EXCLUDE}' {LINT_TARGETS}")
+        print("Running ruff lint fixes")
+    ruff_fix(ctx, target or ".", quiet=quiet)
 
 
 @task()
-def pylint(ctx: Context) -> None:
+def ruff_lint(ctx: Context) -> None:
     """Check code for static errors using pylint."""
-    run(f"pylint --ignore='{LINT_EXCLUDE}' {LINT_TARGETS}")
+    run("ruff check .")
 
 
 @task()
 def mypy(ctx: Context) -> None:
     """Check code using mypy type checker."""
-    run(f"mypy --exclude='{LINT_EXCLUDE}' {LINT_TARGETS} --no-error-summary")
+    run(f"mypy {LINT_TARGETS} --no-error-summary")
 
 
 @task()
 def lint(ctx: Context) -> None:
     """Run linters."""
     linters = {
-        "flake8": flake8,
-        "pylint": pylint,
+        "ruff-lint": ruff_lint,
         "mypy": mypy,
     }
     # in python 3.8 and before the ast module doesn't have the `unparse` function


Test patch:
diff --git a/scripts/mypy_doctests_generator.py b/scripts/mypy_doctests_generator.py
index b34a03c..316a061 100644
--- a/scripts/mypy_doctests_generator.py
+++ b/scripts/mypy_doctests_generator.py
@@ -1,4 +1,5 @@
 import re
+import sys
 import typing as t
 from pathlib import Path
 
@@ -70,6 +71,6 @@ def main(path: Path) -> str:
 
     if not args.filename.exists():
         print(f"`{args.filename}` does not exist")
-        exit(1)
+        sys.exit(1)
 
     args.output.write_text(main(args.filename))
diff --git a/tests/pytest_mypy_testing/test_collections.py b/tests/pytest_mypy_testing/test_collections.py
index 5786406..2b703a9 100644
--- a/tests/pytest_mypy_testing/test_collections.py
+++ b/tests/pytest_mypy_testing/test_collections.py
@@ -1,3 +1,5 @@
+import typing as t
+
 import pytest
 
 import pydash as _
@@ -48,7 +50,10 @@ def test_mypy_find_last() -> None:
 
 @pytest.mark.mypy_testing
 def test_mypy_flat_map() -> None:
-    reveal_type(_.flat_map([1, 2], lambda n: [[n, n]]))  # R: builtins.list[builtins.list[builtins.int]]
+    def listify(n: int) -> t.List[t.List[int]]:
+        return [[n, n]]
+
+    reveal_type(_.flat_map([1, 2], listify))  # R: builtins.list[builtins.list[builtins.int]]
 
 
 @pytest.mark.mypy_testing
diff --git a/tests/pytest_mypy_testing/test_objects.py b/tests/pytest_mypy_testing/test_objects.py
index 09482de..b4df527 100644
--- a/tests/pytest_mypy_testing/test_objects.py
+++ b/tests/pytest_mypy_testing/test_objects.py
@@ -247,13 +247,13 @@ def test_mypy_rename_keys() -> None:
 
 @pytest.mark.mypy_testing
 def test_mypy_set_() -> None:
-    reveal_type(_.set_({}, 'a.b.c', 1))  # R: builtins.dict[<nothing>, <nothing>]
+    reveal_type(_.set_({}, 'a.b.c', 1))  # R: builtins.dict[Never, Never]
     reveal_type(_.set_(MyClass(), "x", 10))  # R: tests.pytest_mypy_testing.test_objects.MyClass
 
 
 @pytest.mark.mypy_testing
 def test_mypy_set_with() -> None:
-    reveal_type(_.set_with({}, '[0][1]', 'a', lambda: {}))  # R: builtins.dict[<nothing>, <nothing>]
+    reveal_type(_.set_with({}, '[0][1]', 'a', lambda: {}))  # R: builtins.dict[Never, Never]
     reveal_type(_.set_with(MyClass(), "x", lambda: 10))  # R: tests.pytest_mypy_testing.test_objects.MyClass
 
 
diff --git a/tests/pytest_mypy_testing/test_utilities.py b/tests/pytest_mypy_testing/test_utilities.py
index 74d027c..19559f5 100644
--- a/tests/pytest_mypy_testing/test_utilities.py
+++ b/tests/pytest_mypy_testing/test_utilities.py
@@ -7,7 +7,10 @@
 
 @pytest.mark.mypy_testing
 def test_mypy_attempt() -> None:
-    reveal_type(_.attempt(lambda x: x/0, 1))  # R: Union[Any, builtins.Exception]
+    def divide_by_zero(n: int) -> float:
+        return n/0
+
+    reveal_type(_.attempt(divide_by_zero, 1))  # R: Union[builtins.float, builtins.Exception]
 
 
 @pytest.mark.mypy_testing
@@ -19,7 +22,7 @@ def is_1(n: int) -> bool:
             (is_1, _.constant("matches 1")),
         ]
     )
-    reveal_type(func)  # R: def (n: builtins.int) -> builtins.str
+    reveal_type(func)  # R: def (*Any, **Any) -> builtins.str
 
 
 @pytest.mark.mypy_testing
diff --git a/tests/test_chaining.py b/tests/test_chaining.py
index 47eb05d..2277be4 100644
--- a/tests/test_chaining.py
+++ b/tests/test_chaining.py
@@ -40,7 +40,7 @@ def test_chaining_invalid_method():
     raised = False
 
     try:
-        _.chain([]).foobar
+        _.chain([]).foobar  # noqa: B018
     except _.InvalidMethod:
         raised = True