docsig 0.62.1__tar.gz → 0.64.0__tar.gz

{docsig-0.62.1 → docsig-0.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: docsig
-Version: 0.62.1
+Version: 0.64.0
 Summary: Check signature params for proper documentation
 Home-page: https://pypi.org/project/docsig/
 License: MIT
@@ -180,7 +180,7 @@ ensure your installation has registered `docsig`
 .. code-block:: console
 
     $ flake8 --version
-    7.1.0 (docsig: 0.62.1, mccabe: 0.7.0, pycodestyle: 2.12.0, pyflakes: 3.2.0) CPython 3.8.13 on Darwin
+    7.1.0 (docsig: 0.64.0, 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
 
@@ -269,7 +269,7 @@ Standalone
 
     repos:
       - repo: https://github.com/jshwi/docsig
-        rev: v0.62.1
+        rev: v0.64.0
         hooks:
           - id: docsig
             args:
@@ -288,7 +288,7 @@ or integrated with ``flake8``
         hooks:
           - id: flake8
             additional_dependencies:
-              - docsig==0.62.1
+              - docsig==0.64.0
             args:
               - "--sig-check-class"
               - "--sig-check-dunders"

{docsig-0.62.1 → docsig-0.64.0}/README.rst

@@ -153,7 +153,7 @@ ensure your installation has registered `docsig`
 .. code-block:: console
 
     $ flake8 --version
-    7.1.0 (docsig: 0.62.1, mccabe: 0.7.0, pycodestyle: 2.12.0, pyflakes: 3.2.0) CPython 3.8.13 on Darwin
+    7.1.0 (docsig: 0.64.0, 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
 
@@ -242,7 +242,7 @@ Standalone
 
     repos:
       - repo: https://github.com/jshwi/docsig
-        rev: v0.62.1
+        rev: v0.64.0
         hooks:
           - id: docsig
             args:
@@ -261,7 +261,7 @@ or integrated with ``flake8``
         hooks:
           - id: flake8
             additional_dependencies:
-              - docsig==0.62.1
+              - docsig==0.64.0
             args:
               - "--sig-check-class"
               - "--sig-check-dunders"

{docsig-0.62.1 → docsig-0.64.0}/docsig/_config.py

@@ -110,7 +110,7 @@ def parse_args(args: _t.Sequence[str] | None = None) -> _a.Namespace:
     :return: Parsed arguments.
     """
     parser = _ArgumentParser(
-        description="Check signature params for proper documentation",
+        description="Check signature params for proper documentation"
     )
     parser.add_argument(
         "-V",

{docsig-0.62.1 → docsig-0.64.0}/docsig/_core.py

@@ -5,6 +5,7 @@ docsig._core
 
 from __future__ import annotations as _
 
+import logging as _logging
 import sys as _sys
 from pathlib import Path as _Path
 
@@ -20,7 +21,6 @@ from ._module import Parent as _Parent
 from ._report import Failure as _Failure
 from ._report import Failures as _Failures
 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
 
@@ -44,6 +44,21 @@ _DEFAULT_EXCLUDES = """\
 """
 
 
+def setup_logger(verbose: bool) -> None:
+    """Setup docsig logger.
+
+    Only log if verbose mode is enabled.
+
+    :param verbose: Whether to enable verbose mode.
+    """
+    loglevel = _logging.DEBUG if verbose else _logging.INFO
+    logger = _logging.getLogger(__package__)
+    logger.setLevel(loglevel)
+    if not logger.handlers:
+        stream_handler = _logging.StreamHandler(_sys.stdout)
+        logger.addHandler(stream_handler)
+
+
 def _run_check(  # pylint: disable=too-many-arguments,too-many-locals
     child: _Parent,
     parent: _Parent,
@@ -118,23 +133,44 @@ def _run_check(  # pylint: disable=too-many-arguments,too-many-locals
             )
 
 
-def _parse_ast(  # pylint: disable=too-many-arguments
+def _from_file(
+    root: _Path,
     messages: _Messages,
     ignore_args: bool,
     ignore_kwargs: bool,
     check_class_constructor,
-    verbose: bool,
-    root: _Path | None = None,
-    string: str | None = None,
 ) -> _Parent:
-    parent = _Parent()
     try:
-        if root is not None:
-            string = root.read_text(encoding="utf-8")
+        string = root.read_text(encoding="utf-8")
+        parent = _from_str(
+            messages=messages,
+            string=string,
+            root=root,
+            ignore_args=ignore_args,
+            ignore_kwargs=ignore_kwargs,
+            check_class_constructor=check_class_constructor,
+        )
+    except UnicodeDecodeError as err:
+        logger = _logging.getLogger(__package__)
+        logger.debug(_FILE_INFO, root, str(err).replace("\n", " "))
+        parent = _Parent(error=_Error.UNICODE)
 
-        # empty string won't happen but keeps the
-        # typechecker happy
-        string = string or ""
+    if parent.error is not None and not root.name.endswith(".py"):
+        parent = _Parent()
+
+    return parent
+
+
+def _from_str(  # pylint: disable=too-many-arguments
+    string: str,
+    messages: _Messages,
+    ignore_args: bool,
+    ignore_kwargs: bool,
+    check_class_constructor,
+    root: _Path | None = None,
+) -> _Parent:
+    logger = _logging.getLogger(__package__)
+    try:
         parent = _Parent(
             _ast.parse(string),
             _Directives.from_text(string, messages),
@@ -143,29 +179,17 @@ def _parse_ast(  # pylint: disable=too-many-arguments
             ignore_kwargs,
             check_class_constructor,
         )
-        _vprint(
-            _FILE_INFO.format(
-                path=root or "stdin", msg="Parsing Python code successful"
-            ),
-            verbose,
-        )
-        return parent
-    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
-            parent = _Parent(error=_Error.SYNTAX)
-
-        _vprint(
-            _FILE_INFO.format(path=root or "stdin", msg=msg),
-            verbose,
+        logger.debug(
+            _FILE_INFO, root or "stdin", "Parsing Python code successful"
         )
+    except _ast.AstroidSyntaxError as err:
+        logger.debug(_FILE_INFO, root or "stdin", str(err).replace("\n", " "))
+        parent = _Parent(error=_Error.SYNTAX)
 
     return parent
 
 
-def _get_failures(  # pylint: disable=too-many-locals,too-many-arguments
+def _get_failures(  # pylint: disable=too-many-arguments
     module: _Parent,
     check_class: bool,
     check_class_constructor: bool,
@@ -209,8 +233,10 @@ def _get_failures(  # pylint: disable=too-many-locals,too-many-arguments
 
 def _report(
     failures: _Failures, path: str | None = None, no_ansi: bool = False
-) -> None:
+) -> int:
+    retcodes = [0]
     for failure in failures:
+        retcodes.append(failure.retcode)
         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():
@@ -229,6 +255,8 @@ def _report(
             if item.hint:
                 print(f"    hint: {item.hint}")
 
+    return max(retcodes)
+
 
 def runner(  # pylint: disable=too-many-locals,too-many-arguments
     file: str | _Path,
@@ -246,7 +274,6 @@ def runner(  # pylint: disable=too-many-locals,too-many-arguments
     ignore_typechecker: bool = False,
     check_protected_class_methods: bool = False,
     no_ansi: bool = False,
-    verbose: bool = False,
     target: _Messages | None = None,
 ) -> _Failures:
     """Per path runner.
@@ -269,37 +296,31 @@ def runner(  # pylint: disable=too-many-locals,too-many-arguments
     :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 = _parse_ast(
+    module = _from_file(
+        _Path(file),
         disable or _Messages(),
         ignore_args,
         ignore_kwargs,
         check_class_constructor,
-        verbose,
-        root=_Path(file),
     )
-    if module or module.error is not None:
-        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
+    return _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(),
+    )
 
 
 @_decorators.parse_msgs
@@ -367,6 +388,7 @@ def docsig(  # pylint: disable=too-many-locals,too-many-arguments
     :param excludes: Files or dirs to exclude from checks.
     :return: Exit status for whether test failed or not.
     """
+    setup_logger(verbose)
     if list_checks:
         return int(bool(_print_checks()))  # type: ignore
 
@@ -375,13 +397,12 @@ def docsig(  # pylint: disable=too-many-locals,too-many-arguments
         patterns.append(exclude)
 
     if string is None:
-        retcode = 0
+        retcodes = [0]
         paths = _Paths(
-            *tuple(_Path(i) for i in path),
+            *path,
             patterns=patterns,
             excludes=excludes or [],
             include_ignored=include_ignored,
-            verbose=verbose,
         )
         for file in paths:
             failures = runner(
@@ -400,41 +421,32 @@ def docsig(  # pylint: disable=too-many-locals,too-many-arguments
                 ignore_typechecker,
                 check_protected_class_methods,
                 no_ansi,
-                verbose,
                 target,
             )
-            if failures:
-                _report(failures, str(file), no_ansi)
-                retcode = 1
+            retcodes.append(_report(failures, str(file), no_ansi))
 
-        return retcode
+        return max(retcodes)
 
-    module = _parse_ast(
+    module = _from_str(
+        string,
         disable or _Messages(),
         ignore_args,
         ignore_kwargs,
         check_class_constructor,
-        verbose,
-        string=string,
     )
-    if module or module.error is not None:
-        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(),
-        )
-        if failures:
-            _report(failures, no_ansi=no_ansi)
-            return 1
-
-    return 0
+    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 _report(failures, no_ansi=no_ansi)

{docsig-0.62.1 → docsig-0.64.0}/docsig/_files.py

@@ -5,6 +5,7 @@ docsig._files
 
 from __future__ import annotations as _
 
+import logging as _logging
 import os as _os
 import re as _re
 import typing as _t
@@ -14,9 +15,7 @@ from pathspec import PathSpec as _PathSpec
 from pathspec.patterns import GitWildMatchPattern as _GitWildMatchPattern
 from wcmatch.pathlib import Path as _WcPath
 
-from ._utils import vprint as _vprint
-
-FILE_INFO = "{path}: {msg}"
+FILE_INFO = "%s: %s"
 
 
 class _Gitignore(_PathSpec):
@@ -68,7 +67,7 @@ def _glob(path: _Path, pattern: str) -> bool:
     return _WcPath(str(path)).globmatch(pattern)  # type: ignore
 
 
-class Paths(_t.List[_Path]):  # pylint: disable=too-many-instance-attributes
+class Paths(_t.List[_Path]):
     """Collect a list of valid paths.
 
     :param paths: Path(s) to parse ``Module``(s) from.
@@ -77,36 +76,31 @@ class Paths(_t.List[_Path]):  # pylint: disable=too-many-instance-attributes
     :param excludes: Files or 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
+    def __init__(
         self,
-        *paths: _Path,
+        *paths: _Path | str,
         patterns: list[str],
         excludes: list[str],
         include_ignored: bool = False,
-        verbose: bool = False,
     ) -> None:
         super().__init__()
         self._patterns = patterns
-        self._excludes = excludes
+        self._excludes = excludes or []
         self._include_ignored = include_ignored
-        self._verbose = verbose
         self._gitignore = _Gitignore()
+        self._logger = _logging.getLogger(__package__)
         for path in paths:
-            self._populate(path)
+            self._populate(_Path(path))
 
         for path in list(self):
             if str(path) != "." and (
                 any(_re.match(i, str(path)) for i in self._patterns)
                 or any(_glob(path, i) for i in self._excludes)
             ):
-                _vprint(
-                    FILE_INFO.format(
-                        path=path, msg="in exclude list, skipping"
-                    ),
-                    self._verbose,
+                self._logger.debug(
+                    FILE_INFO, path, "in exclude list, skipping"
                 )
                 self.remove(path)
 
@@ -117,10 +111,7 @@ class Paths(_t.List[_Path]):  # pylint: disable=too-many-instance-attributes
             raise FileNotFoundError(root)
 
         if not self._include_ignored and self._gitignore.match_file(root):
-            _vprint(
-                FILE_INFO.format(path=root, msg="in gitignore, skipping"),
-                self._verbose,
-            )
+            self._logger.debug(FILE_INFO, root, "in gitignore, skipping")
             return
 
         if root.is_file():

{docsig-0.62.1 → docsig-0.64.0}/docsig/_module.py

@@ -24,6 +24,7 @@ class Error(_Enum):
     """Represents an unrecoverable error."""
 
     SYNTAX = 1
+    UNICODE = 2
 
 
 class _Imports(_t.Dict[str, str]):
@@ -60,6 +61,9 @@ class Parent(_t.List["Parent"]):
         super().__init__()
         self._name = "module"
         self._error = error
+        self._ignore_args = ignore_args
+        self._ignore_kwargs = ignore_kwargs
+        self._check_class_constructor = check_class_constructor
         if node is None:
             if not isinstance(self, Function) and error is not None:
                 self.append(Function(path, error=error))
@@ -67,28 +71,13 @@ class Parent(_t.List["Parent"]):
             self._name = node.name
             self._overloads = _Overloads()
             self._imports = imports or _Imports()
-            self._parse_ast(
-                node,
-                directives or _Directives(),
-                path,
-                ignore_args,
-                ignore_kwargs,
-                check_class_constructor,
-            )
-
-    def _parse_imports(self, names: list[tuple[str, str | None]]) -> None:
-        for name in names:
-            original, alias = name
-            self._imports[original] = alias or original
+            self._parse_ast(node, directives or _Directives(), path)
 
-    def _parse_ast(  # pylint: disable=protected-access,too-many-arguments
+    def _parse_ast(
         self,
         node: _ast.Module | _ast.ClassDef | _ast.FunctionDef | _ast.NodeNG,
         directives: _Directives,
         path: _Path | None = None,
-        ignore_args: bool = False,
-        ignore_kwargs: bool = False,
-        check_class_constructor: bool = False,
     ) -> None:
         # need to keep track of `comments` as, even though they are
         # resolved in directives object, they are needed to notify user
@@ -104,7 +93,9 @@ class Parent(_t.List["Parent"]):
                 comments.extend(parent_comments)
                 disabled.extend(parent_disabled)
                 if isinstance(subnode, (_ast.Import, _ast.ImportFrom)):
-                    self._parse_imports(subnode.names)
+                    for name in subnode.names:
+                        original, alias = name
+                        self._imports[original] = alias or original
                 elif isinstance(subnode, _ast.FunctionDef):
                     func = Function(
                         subnode,
@@ -112,9 +103,9 @@ class Parent(_t.List["Parent"]):
                         directives,
                         disabled,
                         path,
-                        ignore_args,
-                        ignore_kwargs,
-                        check_class_constructor,
+                        self._ignore_args,
+                        self._ignore_kwargs,
+                        self._check_class_constructor,
                         self._imports,
                     )
                     if func.isoverloaded:
@@ -137,21 +128,14 @@ class Parent(_t.List["Parent"]):
                             subnode,
                             directives,
                             path,
-                            ignore_args,
-                            ignore_kwargs,
-                            check_class_constructor,
+                            self._ignore_args,
+                            self._ignore_kwargs,
+                            self._check_class_constructor,
                             self._imports,
                         )
                     )
                 else:
-                    self._parse_ast(
-                        subnode,
-                        directives,
-                        path,
-                        ignore_args,
-                        ignore_kwargs,
-                        check_class_constructor,
-                    )
+                    self._parse_ast(subnode, directives, path)
 
     @property
     def isprotected(self) -> bool:
@@ -216,13 +200,14 @@ class Function(Parent):
             self._parent = node.parent.frame()
             self._decorators = node.decorators
             self._lineno = node.lineno
+            if self.ismethod and not self.isstaticmethod:
+                if node.args.posonlyargs:
+                    node.args.posonlyargs.pop(0)
+                elif node.args.args:
+                    node.args.args.pop(0)
+
             self._signature = self._signature.from_ast(
-                node.args,
-                node.returns,
-                self.ismethod,
-                self.isstaticmethod,
-                ignore_args,
-                ignore_kwargs,
+                node, ignore_args, ignore_kwargs
             )
             if self.isinit and not check_class_constructor:
                 # docstring for __init__ is expected on the class
@@ -232,9 +217,7 @@ class Function(Parent):
                 relevant_doc_node = node.doc_node
 
             if relevant_doc_node is not None:
-                self._docstring = self.docstring.from_ast(
-                    relevant_doc_node, ignore_kwargs
-                )
+                self._docstring = self.docstring.from_ast(relevant_doc_node)
 
     def __len__(self) -> int:
         """Length of the longest sequence of args."""

{docsig-0.62.1 → docsig-0.64.0}/docsig/_report.py

@@ -51,6 +51,7 @@ class Failure(_t.List[Failed]):
         ignore_typechecker: bool,
     ) -> None:
         super().__init__()
+        self._retcode = 0
         self._func = func
         if target:
             self._func.messages.extend(i for i in _E.all if i not in target)
@@ -79,6 +80,7 @@ class Failure(_t.List[Failed]):
         self.sort()
 
     def _add(self, value: _Message, hint: bool = False, **kwargs) -> None:
+        self._retcode = 1
         failed = Failed(
             self._name,
             value.ref,
@@ -236,6 +238,9 @@ class Failure(_t.List[Failed]):
         # invalid-syntax
         if self._func.error == _Error.SYNTAX:
             self._add(_E[901])
+            self._retcode = 123
+        if self._func.error == _Error.UNICODE:
+            self._add(_E[902])
 
     @property
     def name(self) -> str:
@@ -247,6 +252,11 @@ class Failure(_t.List[Failed]):
         """Function line number."""
         return self._func.lineno
 
+    @property
+    def retcode(self) -> int:
+        """How to exit the program."""
+        return self._retcode
+
 
 class Failures(_t.List[Failure]):
     """Sequence of failed functions."""

{docsig-0.62.1 → docsig-0.64.0}/docsig/_stub.py

@@ -112,15 +112,18 @@ class _Params(_t.List[Param]):
         self._ignore_kwargs = ignore_kwargs
         self._duplicates: list[Param] = []
 
-    # pylint: disable=too-many-boolean-expressions
     def append(self, value: Param) -> None:
-        if not value.isprotected and (
-            value.kind == DocType.PARAM
-            or (value.kind == DocType.ARG and not self._ignore_args)
-            or (
-                value.kind == DocType.KWARG
-                and not self._ignore_kwargs
-                and not any(i.kind == DocType.KWARG for i in self)
+        if not value.isprotected and any(
+            (
+                value.kind == DocType.PARAM,
+                (value.kind == DocType.ARG and not self._ignore_args),
+                (
+                    value.kind == DocType.KWARG
+                    and not (
+                        self._ignore_kwargs
+                        or any(i.kind == DocType.KWARG for i in self)
+                    )
+                ),
             )
         ):
             super().append(value)
@@ -189,6 +192,7 @@ class _Stub:
 class Signature(_Stub):
     """Represents a function signature.
 
+    :param rettype: The return type.
     :param returns: Returns declared in signature.
     :param ignore_args: Ignore args prefixed with an asterisk.
     :param ignore_kwargs: Ignore kwargs prefixed with two asterisks.
@@ -196,51 +200,40 @@ class Signature(_Stub):
 
     def __init__(
         self,
-        returns: _ast.Module | str | None = None,
+        rettype: RetType = RetType.NONE,
+        returns: bool = False,
         ignore_args: bool = False,
         ignore_kwargs: bool = False,
     ) -> None:
         super().__init__(ignore_args, ignore_kwargs)
-
-        self._rettype = RetType.from_ast(returns)
-        self._returns = self._rettype == RetType.SOME
+        self._rettype = rettype
+        self._returns = returns
 
     @classmethod
-    def from_ast(  # pylint: disable=too-many-arguments
+    def from_ast(
         cls,
-        arguments: _ast.Arguments,
-        returns: _ast.Module | str,
-        ismethod: bool = False,
-        isstaticmethod: bool = False,
+        node: _ast.Module | _ast.ClassDef | _ast.FunctionDef,
         ignore_args: bool = False,
         ignore_kwargs: bool = False,
     ) -> Signature:
         """Parse signature from ast.
 
-        :param arguments: Arguments provided to signature.
-        :param returns: Returns declared in signature.
-        :param ismethod: Whether this signature belongs to a method.
-        :param isstaticmethod: Whether this signature belongs to a
-            static method.
+        :param node: Abstract syntax tree.
         :param ignore_args: Ignore args prefixed with an asterisk.
         :param ignore_kwargs: Ignore kwargs prefixed with two asterisks.
         :return: Instantiated signature object.
         """
-        if ismethod and not isstaticmethod:
-            if arguments.posonlyargs:
-                arguments.posonlyargs.pop(0)
-            elif arguments.args:
-                arguments.args.pop(0)
-
-        signature = cls(returns, ignore_args, ignore_kwargs)
+        rettype = RetType.from_ast(node.returns)
+        returns = rettype == RetType.SOME
+        signature = cls(rettype, returns, ignore_args, ignore_kwargs)
         for i in [
             a if isinstance(a, Param) else Param(name=a.name)
             for a in [
-                *arguments.posonlyargs,
-                *arguments.args,
-                Param(DocType.ARG, name=arguments.vararg),
-                *arguments.kwonlyargs,
-                Param(DocType.KWARG, name=arguments.kwarg),
+                *node.args.posonlyargs,
+                *node.args.args,
+                Param(DocType.ARG, name=node.args.vararg),
+                *node.args.kwonlyargs,
+                Param(DocType.KWARG, name=node.args.kwarg),
             ]
             if a is not None and a.name
         ]:
@@ -270,13 +263,11 @@ class Docstring(_Stub):
     """Represents a function docstring.
 
     :param string: The raw docstring.
-    :param ignore_args: Ignore args prefixed with an asterisk.
-    :param ignore_kwargs: Ignore kwargs prefixed with two asterisks.
+    :param returns: Whether this docstring has a return.
     """
 
     @staticmethod
     def _indent_anomaly(string: str) -> bool:
-        leading_spaces = []
         for line in string.splitlines():
             # only check params
             # description or anything else is out of scope
@@ -285,10 +276,9 @@ class Docstring(_Stub):
                 if match is not None:
                     spaces = len(match.group())
                     if spaces > 0:
-                        leading_spaces.append(spaces)
+                        return spaces % 2 != 0
 
-        # look for spaces in odd intervals
-        return bool(any(i % 2 != 0 for i in leading_spaces))
+        return False
 
     @staticmethod
     def _normalize_docstring(string: str) -> str:
@@ -307,30 +297,23 @@ class Docstring(_Stub):
         )
 
     def __init__(
-        self,
-        string: str | None = None,
-        ignore_args: bool = False,
-        ignore_kwargs: bool = False,
+        self, string: str | None = None, returns: bool = False
     ) -> None:
-        super().__init__(ignore_args, ignore_kwargs)
+        super().__init__()
         self._string = string
-        self._returns = self._string is not None and bool(
-            _re.search(":returns?:", self._string)
-        )
+        self._returns = returns
 
     @classmethod
-    def from_ast(
-        cls, node: _ast.Const, ignore_kwargs: bool = False
-    ) -> Docstring:
+    def from_ast(cls, node: _ast.Const) -> Docstring:
         """Parse function docstring from ast.
 
         :param node: Docstring ast node.
-        :param ignore_kwargs: Ignore kwargs prefixed with two asterisks.
         :return: Instantiated docstring object.
         """
-        string = cls._normalize_docstring(node.value)
-        docstring = cls(string, ignore_kwargs)
         indent_anomaly = cls._indent_anomaly(node.value)
+        string = cls._normalize_docstring(node.value)
+        returns = bool(_re.search(r":returns?:", string))
+        docstring = cls(string, returns)
         for match in _re.findall(r":(.*?):((?:.|\n)*?)(?=\n:|$)", string):
             if match:
                 kinds = match[0].split()

{docsig-0.62.1 → docsig-0.64.0}/docsig/_utils.py

@@ -26,16 +26,6 @@ def almost_equal(str1: str, str2: str, mini: float, maxi: float) -> bool:
     return mini < _SequenceMatcher(a=str1, b=str2).ratio() < maxi
 
 
-def vprint(msg: str, verbose: bool = False) -> None:
-    """Print messages only if verbose is true.
-
-    :param msg: Message to print.
-    :param verbose: Whether verbose mode is enabled.
-    """
-    if verbose:
-        print(msg)
-
-
 def pretty_print_error(
     exception_type: _t.Type[BaseException], msg: str, no_ansi: bool
 ) -> None:

{docsig-0.62.1 → docsig-0.64.0}/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.62.1"
+__version__ = "0.64.0"

{docsig-0.62.1 → docsig-0.64.0}/docsig/messages.py

@@ -254,5 +254,11 @@ E = MessageMap(
             "parsing python code failed",
             "invalid-syntax",
         ),
+        902: Message(
+            "SIG902",
+            "SIG902",
+            "failed to read file",
+            "unicode-decode-error",
+        ),
     }
 )

{docsig-0.62.1 → docsig-0.64.0}/docsig/plugin.py

@@ -6,7 +6,7 @@ from argparse import Namespace
 
 from ._config import get_config as _get_config
 from ._config import merge_configs as _merge_configs
-from ._core import runner
+from ._core import runner, setup_logger
 from ._version import __version__
 from .messages import FLAKE8, E
 
@@ -141,10 +141,11 @@ class Docsig:
                     ref=E[5].ref,
                     description=E[5].description,
                     symbolic=E[5].symbolic,
-                ),
+                )
             )
             yield 0, 0, line, self.__class__
         else:
+            setup_logger(self.a.verbose)
             results = runner(
                 self.filename,
                 check_class=self.a.check_class,
@@ -161,7 +162,6 @@ class Docsig:
                 ignore_args=self.a.ignore_args,
                 ignore_kwargs=self.a.ignore_kwargs,
                 ignore_typechecker=self.a.ignore_typechecker,
-                verbose=self.a.verbose,
             )
             for result in results:
                 for info in result:

{docsig-0.62.1 → docsig-0.64.0}/pyproject.toml

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