docsig 0.58.0__tar.gz → 0.59.1__tar.gz

{docsig-0.58.0 → docsig-0.59.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: docsig
-Version: 0.58.0
+Version: 0.59.1
 Summary: Check signature params for proper documentation
 Home-page: https://pypi.org/project/docsig/
 License: MIT
@@ -169,7 +169,7 @@ ensure your installation has registered `docsig`
 .. code-block:: console
 
     $ flake8 --version
-    7.1.0 (docsig: 0.58.0, mccabe: 0.7.0, pycodestyle: 2.12.0, pyflakes: 3.2.0) CPython 3.8.13 on Darwin
+    7.1.0 (docsig: 0.59.1, mccabe: 0.7.0, pycodestyle: 2.12.0, pyflakes: 3.2.0) CPython 3.8.13 on Darwin
 
 And now use `flake8` to lint your files
 
@@ -258,7 +258,7 @@ Standalone
 
     repos:
       - repo: https://github.com/jshwi/docsig
-        rev: v0.58.0
+        rev: v0.59.1
         hooks:
           - id: docsig
             args:
@@ -277,7 +277,7 @@ or integrated with ``flake8``
         hooks:
           - id: flake8
             additional_dependencies:
-              - docsig==0.58.0
+              - docsig==0.59.1
             args:
               - "--sig-check-class"
               - "--sig-check-dunders"

{docsig-0.58.0 → docsig-0.59.1}/README.rst

@@ -143,7 +143,7 @@ ensure your installation has registered `docsig`
 .. code-block:: console
 
     $ flake8 --version
-    7.1.0 (docsig: 0.58.0, mccabe: 0.7.0, pycodestyle: 2.12.0, pyflakes: 3.2.0) CPython 3.8.13 on Darwin
+    7.1.0 (docsig: 0.59.1, mccabe: 0.7.0, pycodestyle: 2.12.0, pyflakes: 3.2.0) CPython 3.8.13 on Darwin
 
 And now use `flake8` to lint your files
 
@@ -232,7 +232,7 @@ Standalone
 
     repos:
       - repo: https://github.com/jshwi/docsig
-        rev: v0.58.0
+        rev: v0.59.1
         hooks:
           - id: docsig
             args:
@@ -251,7 +251,7 @@ or integrated with ``flake8``
         hooks:
           - id: flake8
             additional_dependencies:
-              - docsig==0.58.0
+              - docsig==0.59.1
             args:
               - "--sig-check-class"
               - "--sig-check-dunders"

{docsig-0.58.0 → docsig-0.59.1}/docsig/_core.py

@@ -8,13 +8,19 @@ from __future__ import annotations as _
 import sys as _sys
 from pathlib import Path as _Path
 
+import astroid as _ast
+
 from . import _decorators
+from ._directives import Directives as _Directives
+from ._files import FILE_INFO as _FILE_INFO
+from ._files import Paths as _Paths
 from ._module import Function as _Function
-from ._module import Modules as _Modules
 from ._module import Parent as _Parent
 from ._report import Failure as _Failure
 from ._report import Failures as _Failures
+from ._utils import pretty_print_error as _pretty_print_error
 from ._utils import print_checks as _print_checks
+from ._utils import vprint as _vprint
 from .messages import TEMPLATE as _TEMPLATE
 from .messages import Messages as _Messages
 
@@ -112,6 +118,56 @@ def _run_check(  # pylint: disable=too-many-arguments,too-many-locals
             )
 
 
+def _parse_ast(  # pylint: disable=too-many-arguments
+    messages: _Messages,
+    ignore_args: bool,
+    ignore_kwargs: bool,
+    check_class_constructor,
+    verbose: bool,
+    no_ansi: bool,
+    root: _Path | None = None,
+    string: str | None = None,
+) -> tuple[_Parent | None, int]:
+    parent = None
+    retcode = 0
+    try:
+        if root is not None:
+            string = root.read_text(encoding="utf-8")
+
+        # empty string won't happen but keeps the
+        # typechecker happy
+        string = string or ""
+        parent = _Parent(
+            _ast.parse(string),
+            _Directives(string, messages),
+            root,
+            ignore_args,
+            ignore_kwargs,
+            check_class_constructor,
+        )
+        _vprint(
+            _FILE_INFO.format(
+                path=root or "stdin", msg="Parsing Python code successful"
+            ),
+            verbose,
+        )
+    except (_ast.AstroidSyntaxError, UnicodeDecodeError) as err:
+        msg = str(err).replace("\n", " ")
+        if root is not None and root.name.endswith(".py"):
+            # pass by silently for files that do not end with .py, may
+            # result in a 123 syntax error exit status in the future
+            print(root, file=_sys.stderr)
+            _pretty_print_error(type(err), msg, no_ansi=no_ansi)
+            retcode = 1
+
+        _vprint(
+            _FILE_INFO.format(path=root or "stdin", msg=msg),
+            verbose,
+        )
+
+    return parent, retcode
+
+
 def _get_failures(  # pylint: disable=too-many-locals,too-many-arguments
     module: _Parent,
     check_class: bool,
@@ -158,7 +214,8 @@ def _report(
     failures: _Failures, path: str | None = None, no_ansi: bool = False
 ) -> None:
     for failure in failures:
-        header = f"{path}{failure.lineno} in {failure.name}"
+        module = f"{path}:" if path is not None else ""
+        header = f"{module}{failure.lineno} in {failure.name}"
         if not no_ansi and _sys.stdout.isatty():
             header = f"\033[35m{header}\033[0m"
 
@@ -176,6 +233,79 @@ def _report(
                 print(f"    hint: {item.hint}")
 
 
+def runner(  # pylint: disable=too-many-locals,too-many-arguments
+    file: str | _Path,
+    disable: _Messages | None = None,
+    check_class: bool = False,
+    check_class_constructor: bool = False,
+    check_dunders: bool = False,
+    check_nested: bool = False,
+    check_overridden: bool = False,
+    check_protected: bool = False,
+    check_property_returns: bool = False,
+    ignore_no_params: bool = False,
+    ignore_args: bool = False,
+    ignore_kwargs: bool = False,
+    ignore_typechecker: bool = False,
+    check_protected_class_methods: bool = False,
+    no_ansi: bool = False,
+    verbose: bool = False,
+    target: _Messages | None = None,
+) -> tuple[_Failures, int]:
+    """Per path runner.
+
+    :param file: Path to check.
+    :param disable: Messages to disable.
+    :param check_class: Check class docstrings.
+    :param check_class_constructor: Check ``__init__`` methods. Note that this
+        is mutually incompatible with check_class.
+    :param check_dunders: Check dunder methods
+    :param check_nested: Check nested functions and classes.
+    :param check_overridden: Check overridden methods
+    :param check_protected: Check protected functions and classes.
+    :param check_property_returns: Run return checks on properties.
+    :param ignore_no_params: Ignore docstrings where parameters are not
+        documented
+    :param ignore_args: Ignore args prefixed with an asterisk.
+    :param ignore_kwargs: Ignore kwargs prefixed with two asterisks.
+    :param ignore_typechecker: Ignore checking return values.
+    :param check_protected_class_methods: Check public methods belonging
+        to protected classes.
+    :param no_ansi: Disable ANSI output.
+    :param verbose: increase output verbosity.
+    :param target: List of errors to target.
+    :return: Exit status for whether test failed or not.
+    """
+    failures = _Failures()
+    module, retcode = _parse_ast(
+        disable or _Messages(),
+        ignore_args,
+        ignore_kwargs,
+        check_class_constructor,
+        verbose,
+        no_ansi,
+        root=_Path(file),
+    )
+    if module:
+        failures = _get_failures(
+            module,
+            check_class,
+            check_class_constructor,
+            check_dunders,
+            check_nested,
+            check_overridden,
+            check_protected,
+            check_property_returns,
+            ignore_no_params,
+            ignore_typechecker,
+            check_protected_class_methods,
+            no_ansi,
+            target or _Messages(),
+        )
+
+    return failures, retcode
+
+
 @_decorators.parse_msgs
 @_decorators.handle_deprecations
 @_decorators.validate_args
@@ -239,7 +369,6 @@ def docsig(  # pylint: disable=too-many-locals,too-many-arguments
         checks.
     :return: Exit status for whether test failed or not.
     """
-    retcode = 0
     if list_checks:
         return int(bool(_print_checks()))  # type: ignore
 
@@ -247,19 +376,51 @@ def docsig(  # pylint: disable=too-many-locals,too-many-arguments
     if exclude is not None:
         excludes.append(exclude)
 
-    modules = _Modules(
-        *tuple(_Path(i) for i in path),
-        messages=disable or _Messages(),
+    if string is None:
+        retcode = 0
+        paths = _Paths(
+            *tuple(_Path(i) for i in path),
+            excludes=excludes,
+            include_ignored=include_ignored,
+            verbose=verbose,
+        )
+        for file in paths:
+            failures, parse_retcode = runner(
+                file,
+                disable,
+                check_class,
+                check_class_constructor,
+                check_dunders,
+                check_nested,
+                check_overridden,
+                check_protected,
+                check_property_returns,
+                ignore_no_params,
+                ignore_args,
+                ignore_kwargs,
+                ignore_typechecker,
+                check_protected_class_methods,
+                no_ansi,
+                verbose,
+                target,
+            )
+            retcode = retcode or parse_retcode
+            if failures:
+                _report(failures, str(file), no_ansi)
+                retcode = 1
+
+        return retcode
+
+    module, retcode = _parse_ast(
+        disable or _Messages(),
+        ignore_args,
+        ignore_kwargs,
+        check_class_constructor,
+        verbose,
+        no_ansi,
         string=string,
-        excludes=excludes,
-        include_ignored=include_ignored,
-        ignore_args=ignore_args,
-        ignore_kwargs=ignore_kwargs,
-        check_class_constructor=check_class_constructor,
-        no_ansi=no_ansi,
-        verbose=verbose,
     )
-    for module in modules:
+    if module is not None:
         failures = _get_failures(
             module,
             check_class,
@@ -276,7 +437,7 @@ def docsig(  # pylint: disable=too-many-locals,too-many-arguments
             target or _Messages(),
         )
         if failures:
-            _report(failures, module.path, no_ansi=no_ansi)
-            retcode = 1
+            _report(failures, no_ansi=no_ansi)
+            return 1
 
-    return max(retcode, modules.retcode)
+    return 0

docsig-0.59.1/docsig/_files.py

@@ -0,0 +1,118 @@
+"""
+docsig._files
+=============
+"""
+
+from __future__ import annotations as _
+
+import os as _os
+import re as _re
+import typing as _t
+from pathlib import Path as _Path
+
+from pathspec import PathSpec as _PathSpec
+from pathspec.patterns import GitWildMatchPattern as _GitWildMatchPattern
+
+from ._utils import vprint as _vprint
+
+FILE_INFO = "{path}: {msg}"
+
+
+class _Gitignore(_PathSpec):
+    def _get_repo_relative_to(self, path: _Path) -> _Path | None:
+        if (path / ".git" / "HEAD").is_file():
+            return path
+
+        if str(path) == _os.path.abspath(_os.sep):
+            return None
+
+        return self._get_repo_relative_to(path.parent)
+
+    def __init__(self) -> None:
+        patterns = []
+        repo = self._get_repo_relative_to(_Path.cwd())
+        # only consider gitignore patterns valid if inside a git repo
+        # there might be stray gitignore files lying about
+        if repo is not None:
+            # add patterns from all gitignore files
+            # adjust patterns to account for their relative paths
+            for file in repo.rglob(".gitignore"):
+                for pattern in file.read_text(encoding="utf-8").splitlines():
+                    if pattern.startswith("#"):
+                        continue
+
+                    # if pattern starts with "/" then os.path.join will
+                    # consider it in the filesystem root, and it will
+                    # only ever return /pattern
+                    if pattern.startswith("/"):
+                        pattern = pattern[1:]
+
+                    # use os.path.dirname, so it joins without a leading
+                    # "./", like it does with pathlib parent
+                    # use os.path.join so trailing slash is preserved
+                    # replace sep with "/" as, even on windows,
+                    # gitignore patterns only ever use "/"
+                    patterns.append(
+                        _os.path.join(
+                            _os.path.dirname(file.relative_to(repo)),
+                            pattern.strip(),
+                        ).replace(_os.sep, "/")
+                    )
+
+        super().__init__(map(_GitWildMatchPattern, patterns))
+
+
+class Paths(_t.List[_Path]):  # pylint: disable=too-many-instance-attributes
+    """Collect a list of valid paths.
+
+    :param paths: Path(s) to parse ``Module``(s) from.
+    :param excludes: List pf regular expression of files and dirs to
+        exclude from checks.
+    :param include_ignored: Check files even if they match a gitignore
+        pattern.
+    :param verbose: increase output verbosity.
+    """
+
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        *paths: _Path,
+        excludes: list[str],
+        include_ignored: bool = False,
+        verbose: bool = False,
+    ) -> None:
+        super().__init__()
+        self._excludes = excludes
+        self._include_ignored = include_ignored
+        self._verbose = verbose
+        self._gitignore = _Gitignore()
+        for path in paths:
+            self._populate(path)
+
+        self.sort()
+
+    def _populate(self, root: _Path) -> None:
+        if not root.exists():
+            raise FileNotFoundError(root)
+
+        if str(root) != "." and any(
+            _re.match(i, root.name) for i in self._excludes
+        ):
+            _vprint(
+                FILE_INFO.format(path=root, msg="in exclude list, skipping"),
+                self._verbose,
+            )
+            return
+
+        if not self._include_ignored and self._gitignore.match_file(root):
+            _vprint(
+                FILE_INFO.format(path=root, msg="in gitignore, skipping"),
+                self._verbose,
+            )
+            return
+
+        if root.is_file():
+            self.append(root)
+
+        if root.is_dir():
+            for path in root.iterdir():
+                self._populate(path)

{docsig-0.58.0 → docsig-0.59.1}/docsig/_module.py

@@ -5,71 +5,19 @@ docsig._module
 
 from __future__ import annotations as _
 
-import os as _os
 import re as _re
-import sys as _sys
 import typing as _t
 from pathlib import Path as _Path
 
 import astroid as _ast
-from pathspec import PathSpec as _PathSpec
-from pathspec.patterns import GitWildMatchPattern as _GitWildMatchPattern
 
 from ._directives import Comment as _Comment
 from ._directives import Directives as _Directives
 from ._stub import Docstring as _Docstring
 from ._stub import RetType as _RetType
 from ._stub import Signature as _Signature
-from ._utils import pretty_print_error as _pretty_print_error
-from ._utils import vprint as _vprint
 from .messages import Messages as _Messages
 
-_FILE_INFO = "{path}: {msg}"
-
-
-class _Gitignore(_PathSpec):
-    def _get_repo_relative_to(self, path: _Path) -> _Path | None:
-        if (path / ".git" / "HEAD").is_file():
-            return path
-
-        if str(path) == _os.path.abspath(_os.sep):
-            return None
-
-        return self._get_repo_relative_to(path.parent)
-
-    def __init__(self) -> None:
-        patterns = []
-        repo = self._get_repo_relative_to(_Path.cwd())
-        # only consider gitignore patterns valid if inside a git repo
-        # there might be stray gitignore files lying about
-        if repo is not None:
-            # add patterns from all gitignore files
-            # adjust patterns to account for their relative paths
-            for file in repo.rglob(".gitignore"):
-                for pattern in file.read_text(encoding="utf-8").splitlines():
-                    if pattern.startswith("#"):
-                        continue
-
-                    # if pattern starts with "/" then os.path.join will
-                    # consider it in the filesystem root, and it will
-                    # only ever return /pattern
-                    if pattern.startswith("/"):
-                        pattern = pattern[1:]
-
-                    # use os.path.dirname, so it joins without a leading
-                    # "./", like it does with pathlib parent
-                    # use os.path.join so trailing slash is preserved
-                    # replace sep with "/" as, even on windows,
-                    # gitignore patterns only ever use "/"
-                    patterns.append(
-                        _os.path.join(
-                            _os.path.dirname(file.relative_to(repo)),
-                            pattern.strip(),
-                        ).replace(_os.sep, "/")
-                    )
-
-        super().__init__(map(_GitWildMatchPattern, patterns))
-
 
 class Parent(_t.List["Parent"]):
     """Represents an object that contains functions or methods.
@@ -98,7 +46,6 @@ class Parent(_t.List["Parent"]):
     ) -> None:
         super().__init__()
         self._name = node.name
-        self._path = f"{path}:" if path is not None else ""
         self._overloads: dict[str, Function] = {}
         self._imports = imports or {}
         self._parse_ast(
@@ -185,11 +132,6 @@ class Parent(_t.List["Parent"]):
                         check_class_constructor,
                     )
 
-    @property
-    def path(self) -> str:
-        """Representation of path to parent."""
-        return self._path
-
     @property
     def isprotected(self) -> bool:
         """Boolean value for whether class is protected."""
@@ -366,150 +308,3 @@ class Function(Parent):
         :param rettype: Return type of overloaded signature.
         """
         self._signature.overload(rettype)
-
-
-class Modules(_t.List[Parent]):  # pylint: disable=too-many-instance-attributes
-    """Sequence of ``Module`` objects parsed from Python modules or str.
-
-    Recursively collect Python files from within all dirs that exist
-    under paths provided.
-
-    If string is provided, ignore paths.
-
-    :param paths: Path(s) to parse ``Module``(s) from.
-    :param messages: List of checks to disable.
-    :param excludes: List pf regular expression of files and dirs to
-        exclude from checks.
-    :param string: String to parse if provided.
-    :param include_ignored: Check files even if they match a gitignore
-        pattern.
-    :param ignore_args: Ignore args prefixed with an asterisk.
-    :param ignore_kwargs: Ignore kwargs prefixed with two asterisks.
-    :param check_class_constructor: Check the class constructor's
-        docstring. Otherwise, expect the constructor's documentation to
-        be on the class level docstring.
-    :param no_ansi: Disable ANSI output.
-    :param verbose: increase output verbosity.
-    """
-
-    # handle errors here before appending a module
-    def _add_module(  # pylint: disable=too-many-arguments
-        self,
-        messages: _Messages,
-        string: str | None = None,
-        root: _Path | None = None,
-        ignore_args: bool = False,
-        ignore_kwargs: bool = False,
-        check_class_constructor: bool = False,
-    ) -> None:
-        try:
-            if root is not None:
-                string = root.read_text(encoding="utf-8")
-
-            # empty string won't happen but keeps the
-            # typechecker happy
-            string = string or ""
-            self.append(
-                Parent(
-                    _ast.parse(string),
-                    _Directives(string, messages),
-                    root,
-                    ignore_args,
-                    ignore_kwargs,
-                    check_class_constructor,
-                )
-            )
-            _vprint(
-                _FILE_INFO.format(
-                    path=root or "stdin", msg="Parsing Python code successful"
-                ),
-                self._verbose,
-            )
-        except (_ast.AstroidSyntaxError, UnicodeDecodeError) as err:
-            msg = str(err).replace("\n", " ")
-            if root is not None and root.name.endswith(".py"):
-                # pass by silently for files that do not end with .py,
-                # may result in a 123 syntax error exit status in the
-                # future
-                print(root, file=_sys.stderr)
-                _pretty_print_error(type(err), msg, no_ansi=self._no_ansi)
-                self._retcode = 1
-
-            _vprint(
-                _FILE_INFO.format(path=root or "stdin", msg=msg),
-                self._verbose,
-            )
-
-    def __init__(  # pylint: disable=too-many-arguments
-        self,
-        *paths: _Path,
-        messages: _Messages,
-        excludes: list[str],
-        string: str | None = None,
-        include_ignored: bool = False,
-        ignore_args: bool = False,
-        ignore_kwargs: bool = False,
-        check_class_constructor: bool = False,
-        no_ansi: bool = False,
-        verbose: bool = False,
-    ) -> None:
-        super().__init__()
-        self._messages = messages
-        self._excludes = excludes
-        self._include_ignored = include_ignored
-        self._ignore_args = ignore_args
-        self._ignore_kwargs = ignore_kwargs
-        self._check_class_constructor = check_class_constructor
-        self._no_ansi = no_ansi
-        self._verbose = verbose
-        self._retcode = 0
-        self._gitignore = _Gitignore()
-        if string is not None:
-            self._add_module(
-                messages,
-                string=string,
-                ignore_args=ignore_args,
-                ignore_kwargs=ignore_kwargs,
-                check_class_constructor=check_class_constructor,
-            )
-        else:
-            for path in paths:
-                self._populate(path)
-
-    def _populate(self, root: _Path) -> None:
-        if not root.exists():
-            raise FileNotFoundError(root)
-
-        if str(root) != "." and any(
-            _re.match(i, root.name) for i in self._excludes
-        ):
-            _vprint(
-                _FILE_INFO.format(path=root, msg="in exclude list, skipping"),
-                self._verbose,
-            )
-            return
-
-        if not self._include_ignored and self._gitignore.match_file(root):
-            _vprint(
-                _FILE_INFO.format(path=root, msg="in gitignore, skipping"),
-                self._verbose,
-            )
-            return
-
-        if root.is_file():
-            self._add_module(
-                self._messages,
-                root=root,
-                ignore_args=self._ignore_args,
-                ignore_kwargs=self._ignore_kwargs,
-                check_class_constructor=self._check_class_constructor,
-            )
-
-        if root.is_dir():
-            for path in root.iterdir():
-                self._populate(path)
-
-    @property
-    def retcode(self) -> int:
-        """Return code to propagate to main."""
-        return self._retcode

{docsig-0.58.0 → docsig-0.59.1}/docsig/_version.py

@@ -8,4 +8,4 @@ Allows for access to the version internally without cyclic imports
 caused by accessing it through __init__.
 """
 
-__version__ = "0.58.0"
+__version__ = "0.59.1"

{docsig-0.58.0 → docsig-0.59.1}/docsig/plugin.py

@@ -1,14 +1,14 @@
 """Flake8 implementation of docsig."""
 
 import ast
-import contextlib
-import io
-import re
 import sys
 import typing as t
 from argparse import Namespace
 
-import docsig
+from ._config import Parser
+from ._core import runner
+from ._version import __version__
+from .messages import FLAKE8
 
 Flake8Error = t.Tuple[int, int, str, t.Type]
 
@@ -22,8 +22,8 @@ class Docsig:
     """
 
     off_by_default = False
-    name = docsig.__name__
-    version = docsig.__version__
+    name = __package__
+    version = __version__
     options_dict: t.Dict[str, bool] = {}
 
     def __init__(self, tree: ast.Module, filename: str) -> None:
@@ -141,25 +141,42 @@ class Docsig:
 
         :return: Flake8 error, if there is one.
         """
-        buffer = io.StringIO()
-        with contextlib.redirect_stdout(buffer):
-            sys.argv = [
-                __package__,
-                self.filename,
-                *[
-                    f"--{k.replace('_', '-')}"
-                    for k, v in self.options_dict.items()
-                    if v
-                ],
-            ]
-            docsig.main()
-
-        results = re.split(r"^(?!\s)", buffer.getvalue(), flags=re.MULTILINE)
+        sys.argv = [
+            __package__,
+            self.filename,
+            *[
+                f"--{k.replace('_', '-')}"
+                for k, v in self.options_dict.items()
+                if v
+            ],
+        ]
+        p = Parser()
+        results = runner(
+            self.filename,
+            check_class=p.args.check_class,
+            check_class_constructor=p.args.check_class_constructor,
+            check_dunders=p.args.check_dunders,
+            check_protected_class_methods=(
+                p.args.check_protected_class_methods
+            ),
+            check_nested=p.args.check_nested,
+            check_overridden=p.args.check_overridden,
+            check_protected=p.args.check_protected,
+            check_property_returns=p.args.check_property_returns,
+            ignore_no_params=p.args.ignore_no_params,
+            ignore_args=p.args.ignore_args,
+            ignore_kwargs=p.args.ignore_kwargs,
+            ignore_typechecker=p.args.ignore_typechecker,
+            no_ansi=p.args.no_ansi,
+        )[0]
         for result in results:
-            if not result:
-                continue
-
-            header, remainder = result.splitlines()[:2]
-            lineno, func_name = header.split(":", 1)[1].split(" in ", 1)
-            line = f"{remainder.lstrip().replace(':', '')} '{func_name}'"
-            yield int(lineno), 0, line, self.__class__
+            for info in result:
+                line = "{msg} '{name}'".format(
+                    msg=FLAKE8.format(
+                        ref=info.ref,
+                        description=info.description,
+                        symbolic=info.symbolic,
+                    ),
+                    name=info.name,
+                )
+                yield info.lineno, 0, line, self.__class__

{docsig-0.58.0 → docsig-0.59.1}/pyproject.toml

@@ -11,7 +11,7 @@ line-length = 79
 allow_dirty = true
 commit = true
 commit_args = "-sS"
-current_version = "0.58.0"
+current_version = "0.59.1"
 message = "bump: version {current_version} → {new_version}"
 sign_tags = true
 tag = true
@@ -132,7 +132,7 @@ maintainers = [
 name = "docsig"
 readme = "README.rst"
 repository = "https://github.com/jshwi/docsig"
-version = "0.58.0"
+version = "0.59.1"
 
 [tool.poetry.dependencies]
 Sphinx = "^7.0.0"