pynudger 0.1.0__py3-none-any.whl

pynudger/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: © 2025 open-nudge <https://github.com/open-nudge>
+# SPDX-FileContributor: szymonmaszke <github@maszke.co>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Pynudger is an official opennudge linter."""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+__version__ = version("pynudger")
+
+del version

pynudger/__main__.py

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: © 2025 open-nudge <https://github.com/open-nudge>
+# SPDX-FileContributor: szymonmaszke <github@maszke.co>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Pynudger entrypoint."""
+
+from __future__ import annotations
+
+if __name__ == "__main__":  # pragma: no cover
+    from pynudger import _cli
+
+    _cli.main()

pynudger/_check.py

@@ -0,0 +1,358 @@
+# SPDX-FileCopyrightText: © 2025 open-nudge <https://github.com/open-nudge>
+# SPDX-FileContributor: szymonmaszke <github@maszke.co>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Base checks used for multiple rules."""
+
+from __future__ import annotations
+
+import abc
+import re
+import typing
+
+import lintkit
+
+# Shared functionality
+
+
+class _Length(lintkit.check.Check, abc.ABC):
+    """Calculate length of the value."""
+
+    @abc.abstractmethod
+    def _variable(self) -> str:
+        """Name of the check.
+
+        Note:
+            It is used to display appropriate message.
+
+        Returns:
+            Appropriate name of the length subclass.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _words(self, value: str) -> list[str]:
+        """Divide string into words as defined by concrete class.
+
+        Returns:
+            List of words
+
+        """
+        raise NotImplementedError
+
+    def check(self, value: lintkit.Value[str]) -> bool:
+        """Verify if the length of the value exceeds the limit.
+
+        Args:
+            value:
+                Value which is unpacked (ast.AST node or path changed
+                    to string)
+
+        Returns:
+            True if the length exceeds the limit, False otherwise.
+
+        """
+        words = self._words(value)
+        to_exclude: list[str] = self.config.get(  # pyright: ignore[reportAttributeAccessIssue]
+            f"{self._variable()}_excludes", []
+        )
+        for word in to_exclude:
+            if word.lower() in words:  # pragma: no cover
+                words.remove(word)  # pyright: ignore[reportUnknownArgumentType]
+
+        return len(words) > self._length()
+
+    def _length(self) -> int:
+        """Get length limit from config or return default.
+
+        Returns:
+            Length limit
+
+        """
+        length = self.config.get(f"{self._variable()}_length")  # pyright: ignore[reportAttributeAccessIssue]
+        if length is None:
+            return 3
+        return length  # pragma: no cover
+
+    def message(self, value: lintkit.Value[str]) -> str:
+        """Display error message in case of rule violation.
+
+        Args:
+            value:
+                Value which violated the rule.
+
+        Returns:
+            Message describing rule violation.
+
+        """
+        return (
+            f"'{value}' has too many words (maximum: {self._length()}). "
+            "Consider using modules and submodules instead."
+        )
+
+
+class _Regex(lintkit.check.Regex, abc.ABC):
+    """Shared regex functionality."""
+
+    def regex_flags(self) -> int:
+        """Make the matching case insensitive.
+
+        Returns:
+            Flag indicating both upper and lowercase match.
+
+        """
+        return re.IGNORECASE
+
+
+class _What(abc.ABC):
+    """What is being avoided."""
+
+    @abc.abstractmethod
+    def _what(self) -> str:
+        """What is being avoided.
+
+        Returns:
+            String describing what is being avoided.
+
+        """
+        raise NotImplementedError
+
+
+class _SetGet(_Regex, _What, abc.ABC):
+    """Shared functionality of setters and getters."""
+
+    def message(self, value: lintkit.Value[str]) -> str:
+        """Display error message in case of rule violation.
+
+        Args:
+            value:
+                Value which violated the rule.
+
+        Returns:
+            Message describing rule violation.
+
+        """
+        goal = re.sub(
+            self.regex(),
+            "",
+            value.__wrapped__,  # pyright: ignore[reportUnknownArgumentType]
+            flags=self.regex_flags(),
+        )
+        if not goal:
+            return f"Avoid using {self._what()}."
+        return (
+            f"Avoid using {self._what()}. Instead of '{value}' "
+            f"define '{goal}' as a property."
+        )
+
+
+class _UtilHelperCommon(_Regex, _What, abc.ABC):
+    """Shared functionality of utils, helpers and commons."""
+
+    def message(self, _: lintkit.Value[str]) -> str:
+        """Display error message in case of rule violation.
+
+        Args:
+            _:
+                Unused
+
+        Returns:
+            Message describing rule violation.
+
+        """
+        return (
+            f"Avoid defining '{self._what()}'. Use semantically "
+            "meaningful names instead."
+        )
+
+
+# Concrete checks
+
+
+class Set(_SetGet):
+    """Match setter and its variations."""
+
+    def regex(self) -> str:
+        """Regex matching setters.
+
+        Note:
+            It might raise false positives.
+
+        Returns:
+            Regex to match
+
+        """
+        return r"^_?set(?:s|ters?)?_?"
+
+    def _what(self) -> str:
+        """What is being avoided.
+
+        Returns:
+            Always "setters" string.
+
+        """
+        return "setters"
+
+
+class Get(_SetGet):
+    """Match getter and its variations."""
+
+    def regex(self) -> str:
+        """Regex matching getters.
+
+        Note:
+            It might raise false positives.
+
+        Returns:
+            Regex to match
+
+        """
+        return r"^_?get(?:s|ters?)?_?"
+
+    def _what(self) -> str:
+        """What is being avoided.
+
+        Returns:
+            Always "getters" string.
+
+        """
+        return "getters"
+
+
+class Util(_UtilHelperCommon):
+    """Match utilities and its variations."""
+
+    def regex(self) -> str:
+        """Regex matching utils.
+
+        Note:
+            It might raise false positives.
+
+        Returns:
+            Regex to match
+
+        """
+        return r"_?util(s|ities)?"
+
+    def _what(self) -> str:
+        """What is being avoided.
+
+        Returns:
+            Always "utils" string.
+
+        """
+        return "utils"
+
+
+class Helper(_UtilHelperCommon):
+    """Match helpers and its variations."""
+
+    def regex(self) -> str:
+        """Regex matching helpers.
+
+        Note:
+            It might raise false positives.
+
+        Returns:
+            Regex to match
+
+        """
+        return r"_?help(ers?)?"
+
+    def _what(self) -> str:
+        """What is being avoided.
+
+        Returns:
+            Always "helpers" string.
+
+        """
+        return "helpers"
+
+
+class Common(_UtilHelperCommon):
+    """Match common and its variations."""
+
+    def regex(self) -> str:
+        """Regex matching common(s).
+
+        Note:
+            It might raise false positives.
+
+        Returns:
+            Regex to match
+
+        """
+        return r"_?common(s)?"
+
+    def _what(self) -> str:
+        """What is being avoided.
+
+        Returns:
+            Always "commons" string.
+
+        """
+        return "commons"
+
+
+class Pascal(_Length):
+    """Calculate length of name based on pascal casing."""
+
+    def _variable(self) -> typing.Literal["pascal"]:
+        """Name of the check.
+
+        Note:
+            It is used to display appropriate message.
+
+        Returns:
+            Always "pascal" string.
+
+        """
+        return "pascal"
+
+    def _words(self, value: str) -> list[str]:
+        """Divide string into words as defined by pascal casing.
+
+        Returns:
+            List of words
+
+        """
+        return re.sub(
+            "([A-Z][a-z]+)",
+            r" \1",
+            re.sub(
+                "([A-Z]+)",
+                r" \1",
+                value.__wrapped__,  # pyright: ignore[reportUnknownArgumentType, reportAttributeAccessIssue]
+            ),
+        ).split()
+
+
+class Snake(_Length):
+    """Calculate length of name based on snake casing."""
+
+    def _variable(self) -> typing.Literal["snake"]:
+        """Name of the check.
+
+        Note:
+            It is used to display appropriate message.
+
+        Returns:
+            Always "snake" string.
+
+        """
+        return "snake"
+
+    def _words(self, value: str) -> list[str]:
+        """Divide string into words as defined by snake casing.
+
+        Returns:
+            List of words
+
+        """
+        if value.startswith("__") and value.endswith("__"):
+            return value[2:-2].split("_")
+        if value.startswith("_"):
+            return value[1:].split("_")
+        return value.split("_")

pynudger/_cli.py

@@ -0,0 +1,57 @@
+# SPDX-FileCopyrightText: © 2025 open-nudge <https://github.com/open-nudge>
+# SPDX-FileContributor: szymonmaszke <github@maszke.co>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Pynudger CLI entrypoint."""
+
+from __future__ import annotations
+
+import pathlib
+import typing
+
+from importlib.metadata import version
+
+import lintkit
+import loadfig
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Iterable
+
+NAME = "pynudger"
+
+lintkit.settings.name = NAME.upper()
+
+# Import all rules to register them (side-effect)
+from pynudger import (  # noqa: E402
+    _rule,  # noqa: F401  # pyright: ignore[reportUnusedImport]
+)
+
+
+def main(
+    args: list[str] | None = None,
+    include_codes: Iterable[int] | None = None,
+    exclude_codes: Iterable[int] | None = None,
+) -> None:
+    """Run the CLI."""
+    config = loadfig.config(NAME.lower())
+
+    lintkit.registry.inject("config", config)
+
+    if include_codes is None:  # pragma: no cover
+        include_codes = config.get("include_codes")
+    if exclude_codes is None:  # pragma: no cover
+        exclude_codes = config.get("exclude_codes")
+
+    lintkit.cli.main(
+        version(NAME),
+        files_default=pathlib.Path.cwd().rglob("*.py"),
+        files_help=(
+            "Files to lint with pynudger (default: all Python files in cwd)"
+        ),
+        include_codes=include_codes,
+        exclude_codes=exclude_codes,
+        end_mode=config.get("end_mode", "all"),
+        args=args,
+        description="pynudger - opennudge Python linter",
+    )

pynudger/_loader.py

@@ -0,0 +1,89 @@
+# SPDX-FileCopyrightText: © 2025 open-nudge <https://github.com/open-nudge>
+# SPDX-FileContributor: szymonmaszke <github@maszke.co>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Pynudger loaders."""
+
+from __future__ import annotations
+
+import abc
+import ast
+import typing
+
+import lintkit
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Iterable
+
+# Shared functionality
+
+
+class _Definition(lintkit.loader.Python, abc.ABC):
+    """Base class for loading class and function definitions."""
+
+    @abc.abstractmethod
+    def ast_class(self) -> type[ast.ClassDef | ast.FunctionDef]:
+        """Return the AST class to look for.
+
+        Returns:
+            AST class to look for
+
+        """
+        raise NotImplementedError
+
+    def values(self) -> Iterable[lintkit.Value[str]]:
+        """Yield all definitions of the specified AST class.
+
+        Yields:
+            All definitions of the specified AST class
+
+        """
+        data: dict[type[ast.AST], list[ast.AST]] = self.getitem("nodes_map")
+        for node in data[self.ast_class()]:
+            yield lintkit.Value.from_python(
+                node.name,  # pyright: ignore[reportUnknownArgumentType, reportAttributeAccessIssue]
+                node,
+            )
+
+
+# Concrete loaders
+
+
+class Class(_Definition):
+    """Loader for function definitions."""
+
+    def ast_class(self) -> type[ast.ClassDef]:
+        """Return the AST class to look for.
+
+        Returns:
+            Always ast.ClassDef
+
+        """
+        return ast.ClassDef
+
+
+class Function(_Definition):
+    """Loader for function definitions."""
+
+    def ast_class(self) -> type[ast.FunctionDef]:
+        """Return the AST class to look for.
+
+        Returns:
+            Always ast.FunctionDef
+
+        """
+        return ast.FunctionDef
+
+
+class Path(lintkit.loader.File):
+    """Loader for file paths."""
+
+    def values(self) -> Iterable[lintkit.Value[str]]:
+        """Yield the file path as a value.
+
+        Yields:
+            The file path as a value
+        """
+        # COE: lintkit framework assures self.file is not None at this point
+        yield lintkit.Value(str(self.file.stem))  # pyright: ignore[reportOptionalMemberAccess]

pynudger/_rule.py

@@ -0,0 +1,169 @@
+# SPDX-FileCopyrightText: © 2025 open-nudge <https://github.com/open-nudge>
+# SPDX-FileContributor: szymonmaszke <github@maszke.co>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Pynudger rules."""
+
+from __future__ import annotations
+
+import lintkit
+
+from pynudger._check import Common, Get, Helper, Pascal, Set, Snake, Util
+from pynudger._loader import Class, Function, Path
+
+
+# Setters rules
+class SetClass(Set, Class, lintkit.rule.Node, code=0):
+    """Rule checking class names for setters."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using setters in class names. Use properties instead."
+
+
+class SetFunction(Set, Function, lintkit.rule.Node, code=1):
+    """Rule checking function names for setters."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using setters in function names. Use properties instead."
+
+
+class SetPath(Set, Path, lintkit.rule.Node, code=2):
+    """Rule checking paths for setters."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using setters in file names. Define file name without it."
+
+
+# Getters rules
+class GetClass(Get, Class, lintkit.rule.Node, code=3):
+    """Rule checking class names for getters."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using getters in class names. Use properties instead."
+
+
+class GetFunction(Get, Function, lintkit.rule.Node, code=4):
+    """Rule checking function names for getters."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using getters in function names. Use properties instead."
+
+
+class GetPath(Get, Path, lintkit.rule.Node, code=5):
+    """Rule checking paths for getters."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using getters in file names. Define file name without it."
+
+
+# Util rules
+class UtilClass(Util, Class, lintkit.rule.Node, code=6):
+    """Rule checking class names for utils."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using utils in class names. Name the class appropriately."
+
+
+class UtilFunction(Util, Function, lintkit.rule.Node, code=7):
+    """Rule checking function names for utils."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using utils in function names. Name the function appropriately."
+
+
+class UtilPath(Util, Path, lintkit.rule.Node, code=8):
+    """Rule checking paths for utils."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid defining utils modules. Move functionality to appropriate modules."
+
+
+# Helper rules
+class HelperClass(Helper, Class, lintkit.rule.Node, code=9):
+    """Rule checking class names for helpers."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return (
+            "Avoid using helpers in class names. Name the class appropriately."
+        )
+
+
+class HelperFunction(Helper, Function, lintkit.rule.Node, code=10):
+    """Rule checking function names for helpers."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using helpers in function names. Name the function appropriately."
+
+
+class HelperPath(Helper, Path, lintkit.rule.Node, code=11):
+    """Rule checking paths for utils."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid defining utils modules. Move functionality to appropriate modules."
+
+
+# Common rules
+class CommonClass(Common, Class, lintkit.rule.Node, code=12):
+    """Rule checking class names for helpers."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return (
+            "Avoid using common in class names. Name the class appropriately."
+        )
+
+
+class CommonFunction(Common, Function, lintkit.rule.Node, code=13):
+    """Rule checking function names for common."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid using common in function names. Name the function appropriately."
+
+
+class CommonPath(Common, Path, lintkit.rule.Node, code=14):
+    """Rule checking paths for commons."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid defining common modules. Move functionality to appropriate modules."
+
+
+# Length rules
+class LengthClass(Pascal, Class, lintkit.rule.Node, code=15):
+    """Rule for checking class's name length (word-wise)."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid long class names. Specify intent by nesting modules/packages."
+
+
+class LengthFunction(Snake, Function, lintkit.rule.Node, code=16):
+    """Rule for checking function's name length (word-wise)."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return "Avoid long function names. Specify intent by nesting modules/packages."
+
+
+class LengthPath(Snake, Path, lintkit.rule.Node, code=17):
+    """Rule for checking path name length (word-wise)."""
+
+    def description(self) -> str:
+        """Return rule description."""
+        return (
+            "Avoid long path names. Specify intent by nesting modules/packages."
+        )

pynudger/py.typed.license

@@ -0,0 +1,4 @@
+SPDX-FileCopyrightText: © 2025 open-nudge <https://github.com/open-nudge>
+SPDX-FileContributor: szymonmaszke <github@maszke.co>
+
+SPDX-License-Identifier: Apache-2.0

pynudger-0.1.0.dist-info/METADATA

@@ -0,0 +1,265 @@
+Metadata-Version: 2.4
+Name: pynudger
+Version: 0.1.0
+Summary: opennudge Python linter (naming conventions and other automated checks)
+Author: open-nudge
+Maintainer: open-nudge
+License-Expression: Apache-2.0
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Project-URL: Changelog, https://github.com/open-nudge/pynudger/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://open-nudge.github.io/pynudger
+Project-URL: Homepage, https://open-nudge.github.io/pynudger
+Project-URL: Issues, https://github.com/open-nudge/pynudger/issues
+Project-URL: Repository, https://github.com/open-nudge/pynudger
+Requires-Python: >=3.11
+Requires-Dist: lintkit[rich]>=0.2.1
+Requires-Dist: loadfig>=0.1.0
+Description-Content-Type: text/markdown
+
+<!--
+SPDX-FileCopyrightText: © 2025 open-nudge <https://github.com/open-nudge>
+SPDX-FileContributor: szymonmaszke <github@maszke.co>
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# pynudger
+
+<!-- mkdocs remove start -->
+
+<!-- vale off -->
+
+<!-- pyml disable-num-lines 30 line-length-->
+
+<p align="center">
+    <em>opennudge Python linter (naming conventions and other automated checks)</em>
+</p>
+
+<div align="center">
+
+<a href="https://pypi.org/project/pynudger">![PyPI - Python Version](https://img.shields.io/pypi/v/pynudger?style=for-the-badge&label=release&labelColor=grey&color=blue)
+</a>
+<a href="https://pypi.org/project/pynudger">![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fopen-nudge%2Fpynudger%2Fmain%2Fpyproject.toml&style=for-the-badge&label=python&labelColor=grey&color=blue)
+</a>
+<a href="https://opensource.org/licenses/Apache-2.0">![License](https://img.shields.io/badge/License-Apache_2.0-blue?style=for-the-badge)
+</a>
+<a>![Coverage Hardcoded](https://img.shields.io/badge/coverage-100%25-green?style=for-the-badge)
+</a>
+<a href="https://scorecard.dev/viewer/?uri=github.com/open-nudge/pynudger">![OSSF-Scorecard Score](https://img.shields.io/ossf-scorecard/github.com/open-nudge/pynudger?style=for-the-badge&label=OSSF)
+</a>
+
+</div>
+
+<p align="center">
+✨ <a href="#features">Features</a>
+🚀 <a href="#quick-start">Quick start</a>
+📚 <a href="https://open-nudge.github.io/pynudger">Documentation</a>
+🤝 <a href="#contribute">Contribute</a>
+👍 <a href="https://github.com/open-nudge/pynudger/blob/main/ADOPTERS.md">Adopters</a>
+📜 <a href="#legal">Legal</a>
+</p>
+<!-- vale on -->
+
+______________________________________________________________________
+
+<!-- mkdocs remove end -->
+
+## Features
+
+__pynudger__ is an opinionated linter for Python projects, focused on
+naming conventions and making your code "more Pythonic".
+
+- __Length rules__: Too long class/function names are flagged.
+- __Setters/getters__: Discourages usage of setters/getters,
+    encourages properties instead.
+- __No helpers/utils/commons__: Incentivizes more descriptive
+    and semantically coherent names for functionalities.
+
+## Table of contents
+
+- [Quick start](#quick-start)
+    - [Installation](#installation)
+    - [Usage](#usage)
+- [Advanced](#advanced)
+    - [Configuration](#configuration)
+    - [Run as a pre-commit hook](#run-as-a-pre-commit-hook)
+    - [Disable in code](#disable-in-code)
+    - [Rules](#rules)
+
+## Quick start
+
+### Installation
+
+> [!TIP]
+> You can use your favorite package manager like
+> [`uv`](https://github.com/astral-sh/uv),
+> [`hatch`](https://github.com/pypa/hatch)
+> or [`pdm`](https://github.com/pdm-project/pdm)
+> instead of `pip`.
+
+```sh
+> pip install pynudger
+```
+
+### Usage
+
+To check against the rules run the following from the command line:
+
+```sh
+> pynudger check
+```
+
+You can pass additional arguments to `pynudger check`, like files
+to check (by default all Python files in the current directory):
+
+```sh
+> pynudger check path/to/file.py another_file.py
+```
+
+## Advanced
+
+### Configuration
+
+You can configure pynudger in `pyproject.toml` (or `.pynudger.toml`
+in the root of your project, just remove the `[tool.pynudger]` section),
+for example:
+
+```toml
+[tool.pynudger]
+# include rules by their code
+include_codes = [1, 2, 5] # default: all rules included
+# exclude rules by their code (takes precedence over include)
+exclude_codes = [4, 5, 6] # default: no rules excluded
+# whether to exit after first error or all errors
+end_mode = "first" # default: "all"
+```
+
+> [!TIP]
+> Rule-specific configuration can be found in the section below.
+
+### Run as a pre-commit hook
+
+`pynudger` can be used as a pre-commit hook, to add as a plugin:
+
+```yaml
+repos:
+-   repo: "https://github.com/open-nudge/pynudger"
+    rev: ...  # select the tag or revision you want, or run `pre-commit autoupdate`
+    hooks:
+    -   id: "pynudger"
+```
+
+### Disable in code
+
+You can disable `pynudger` on a line-by-line basis
+(you have to specify exact code), e.g.:
+
+```python
+def set_my_too_long_function_name():  # noqa: PYNUDGER0, PYNUDGER16
+    pass
+```
+
+or a line span:
+
+```python
+# noqa-start: PYNUDGER0, PYNUDGER16
+def set_my_too_long_function_name():
+    pass
+
+def set_another_long_function():
+    pass
+# noqa-end: PYNUDGER0, PYNUDGER16
+
+def set_will_error_out_this_time():
+    pass
+```
+
+It is also possible to disable all checks in a file
+by placing the following somewhere in the file (preferably at the top):
+
+```python
+# noqa-file: PYNUDGER0, PYNUDGER16
+```
+
+> [!NOTE]
+> If you are running `pynudger` with
+> [`ruff`](https://github.com/astral-sh/ruff) you should add
+> `lint.external = ["PYNUDGER"]` to `[tool.ruff]` section in
+> `pyproject.toml` to avoid removing `# noqa: PYNUDGER` comments.
+
+### Rules
+
+> [!TIP]
+> Run `pynudger rules` to see the list of available rules.
+
+`pynudger` provides the following rules:
+
+<!-- pyml disable-num-lines 25 line-length-->
+
+| Name         | Description                                                               |
+| ------------ | ------------------------------------------------------------------------- |
+| `PYNUDGER0`  | Avoid using setters in class names. Use properties instead.               |
+| `PYNUDGER1`  | Avoid using setters in function names. Use properties instead.            |
+| `PYNUDGER2`  | Avoid using setters in file names. Define file name without it.           |
+| `PYNUDGER3`  | Avoid using getters in class names. Use properties instead.               |
+| `PYNUDGER4`  | Avoid using getters in function names. Use properties instead.            |
+| `PYNUDGER5`  | Avoid using getters in file names. Define file name without it.           |
+| `PYNUDGER6`  | Avoid using utils in class names. Name the class appropriately.           |
+| `PYNUDGER7`  | Avoid using utils in function names. Name the function appropriately.     |
+| `PYNUDGER8`  | Avoid defining utils modules. Move functionality to appropriate modules.  |
+| `PYNUDGER9`  | Avoid using helpers in class names. Name the class appropriately.         |
+| `PYNUDGER10` | Avoid using helpers in function names. Name the function appropriately.   |
+| `PYNUDGER11` | Avoid defining utils modules. Move functionality to appropriate modules.  |
+| `PYNUDGER12` | Avoid using common in class names. Name the class appropriately.          |
+| `PYNUDGER13` | Avoid using common in function names. Name the function appropriately.    |
+| `PYNUDGER14` | Avoid defining common modules. Move functionality to appropriate modules. |
+| `PYNUDGER15` | Avoid long class names. Specify intent by nesting modules/packages.       |
+| `PYNUDGER16` | Avoid long function names. Specify intent by nesting modules/packages.    |
+| `PYNUDGER17` | Avoid long path names. Specify intent by nesting modules/packages.        |
+
+with the following configurable options (in `pyproject.toml`
+or `.pynudger.toml`):
+
+<!-- pyml disable-num-lines 10 line-length-->
+
+| Option            | Description                                           | Affected rules         | Default |
+| ----------------- | ----------------------------------------------------- | ---------------------- | ------- |
+| `pascal_length`   | Maximum allowed length of PascalCase names            | PYNUDGER15             | 3       |
+| `snake_length`    | Maximum allowed length of snake_case names            | PYNUDGER16, PYNUDGER17 | 3       |
+| `pascal_excludes` | List of words to exclude from PascalCase length check | PYNUDGER15             | []      |
+| `snake_excludes`  | List of words to exclude from snake_case length check | PYNUDGER16, PYNUDGER17 | []      |
+
+## Contribute
+
+<!-- md-dead-link-check: off -->
+
+<!-- mkdocs remove start -->
+
+We welcome your contributions! Start here:
+
+- [Code of Conduct](/CODE_OF_CONDUCT.md)
+- [Contributing Guide](/CONTRIBUTING.md)
+- [Roadmap](/ROADMAP.md)
+- [Changelog](/CHANGELOG.md)
+- [Report security vulnerabilities](/SECURITY.md)
+- [Open an Issue](https://github.com/open-nudge/pynudger/issues)
+
+## Legal
+
+- This project is licensed under the _Apache 2.0 License_ - see
+    the [LICENSE](/LICENSE.md) file for details.
+- This project is copyrighted by _open-nudge_ - the
+    appropriate copyright notice is included in each file.
+
+<!-- mkdocs remove end -->
+
+<!-- md-dead-link-check: on -->

pynudger-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pynudger-0.1.0.dist-info/METADATA,sha256=6RN0mUgMUfsQmOuhU9_XFAHBjD2wHwA3s5urmOqve_8,9516
+pynudger-0.1.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+pynudger-0.1.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+pynudger/__init__.py,sha256=0bxelJimZJm0sOqrC0SOGnnRO67Da2Q__fQtSLfcDEk,346
+pynudger/__main__.py,sha256=kWeE4-k-Szhsb3lPs9ukvgf8_hlF6h5Q5gLsk1o_CJI,332
+pynudger/_check.py,sha256=_wqyeKghpncLlUahoNbLWZkrQIYIgs0bWzCrQdAX5dc,8003
+pynudger/_cli.py,sha256=-tcEgzKXhpJ0O7ojCeO82PWw0bX33N9PnMbt0_aXyOg,1507
+pynudger/_loader.py,sha256=-vN2Ixte5jKEATRgpHIfiCszMxUWjGPKhqOmexbSTl0,2182
+pynudger/_rule.py,sha256=CKuRe472tumdJU7kZ32pX4KWHXsBVdZ--INJIVzCZuE,5392
+pynudger/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pynudger/py.typed.license,sha256=N3aJoYmMm73hltVnRTMxUjsx8VeY0ltH2YNf7w4C4xQ,166
+pynudger-0.1.0.dist-info/RECORD,,

pynudger-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.5)
+Root-Is-Purelib: true
+Tag: py3-none-any

pynudger-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+