placard 2026.5.29.63299.dev1__tar.gz

placard-2026.5.29.63299.dev1/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: placard
+Version: 2026.5.29.63299.dev1
+Author-email: Moshe Zadka <moshez@zadka.club>
+License: Permission is hereby granted, free of charge, to any person obtaining a
+        copy of this software and associated documentation files (the "Software"),
+        to deal in the Software without restriction, including without limitation the
+        rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is furnished
+        to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+        INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+        PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+        HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+        CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+        OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/moshez/placard
+Description-Content-Type: text/x-rst
+Provides-Extra: tests
+Requires-Dist: virtue; extra == "tests"
+Requires-Dist: pyhamcrest; extra == "tests"
+Requires-Dist: coverage; extra == "tests"
+Provides-Extra: mypy
+Requires-Dist: mypy; extra == "mypy"
+Provides-Extra: lint
+Requires-Dist: flake8; extra == "lint"
+Requires-Dist: black; extra == "lint"
+Requires-Dist: stolid; extra == "lint"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+
+placard
+========================
+
+Stuff

placard-2026.5.29.63299.dev1/README.rst

@@ -0,0 +1,4 @@
+placard
+========================
+
+Stuff

placard-2026.5.29.63299.dev1/git-log-head

@@ -0,0 +1,16 @@
+commit 2919a6c42842c8a9d2fa482c59fdf6d6b0687ebf
+Author: Claude <noreply@anthropic.com>
+Date:   2026-05-29 17:34:59 +0000
+
+    Match stolid's lint setup; self-apply placard via flake8 plugin discovery
+    
+    Drop the project-local [tool.black] line-length=79 (which conflicted
+    with the upstream black default and forced noxfile.py to wrap) in favor
+    of stolid's own pattern: black at the default 88 and stolid passed
+    --max-line-length=88 --ignore=E203,E503,W503 so the two agree.
+    
+    Self-application is automatic: nox lint installs placard via
+    ``pip install -e .``, and ``python -m stolid`` invokes flake8, which
+    discovers placard's flake8.extension entry point alongside stolid's.
+    ``flake8 --version`` in the lint venv now reports both plugins, and
+    ``flake8 --select=PLC src/`` is clean.

placard-2026.5.29.63299.dev1/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = [
+    "setuptools",
+    "autocalver",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "placard"
+dynamic = ["version"]
+description = ""
+readme = "README.rst"
+authors = [{name = "Moshe Zadka", email = "moshez@zadka.club"}]
+
+[project.optional-dependencies]
+tests = ["virtue", "pyhamcrest", "coverage"]
+mypy = ["mypy"]
+lint = ["flake8", "black", "stolid"]
+docs = ["sphinx"]
+
+[project.license]
+text = """
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+[project.urls]
+Homepage = "https://github.com/moshez/placard"
+
+[tool.autocalver]
+use = true
+log = "git-log-head"
+log_command = "git log -n 1 --date=iso"
+is_main_var = "GITHUB_REF"
+is_main_match = ".*/trunk$"
+
+[project.entry-points."flake8.extension"]
+PLC = "placard:Plugin"

placard-2026.5.29.63299.dev1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

placard-2026.5.29.63299.dev1/src/placard/__init__.py

@@ -0,0 +1,10 @@
+"""The placard flake8 plugin: Google-style docstring shape checks."""
+
+from __future__ import annotations
+
+import importlib.metadata
+
+from ._plugin import Plugin
+
+__version__ = importlib.metadata.version(__name__)
+__all__ = ["Plugin", "__version__"]

placard-2026.5.29.63299.dev1/src/placard/_plugin.py

@@ -0,0 +1,49 @@
+# Flake8 plugin glue: walks the AST and yields PLC violations for each
+# node whose docstring exists.
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from typing import Iterator
+
+from ._rules import _violations
+
+_DOCSTRING_NODES = (
+    ast.Module,
+    ast.ClassDef,
+    ast.FunctionDef,
+    ast.AsyncFunctionDef,
+)
+
+
+# SLD503 (kw_only=True) is intentionally omitted: flake8 introspects
+# the plugin class's positional ``__init__`` parameters via
+# ``inspect.signature`` to decide which fixtures (``tree``, ``lines``,
+# ``filename``, ...) to inject, and keyword-only parameters fall out of
+# that lookup.
+@dataclass(frozen=True, slots=True)
+class Plugin:  # noqa: SLD503
+    """Flake8 plugin: walks ``tree`` and yields placard's ``PLC`` codes."""
+
+    tree: ast.AST
+
+    def run(  # noqa: SLD303
+        self,
+    ) -> Iterator[tuple[int, int, str, type[Plugin]]]:
+        """Yield ``(line, col, message, type)`` for each PLC violation."""
+        owner = type(self)
+        for node in ast.walk(self.tree):
+            if not isinstance(node, _DOCSTRING_NODES):
+                continue
+            text = ast.get_docstring(node)
+            if text is None:
+                continue
+            anchor = node.body[0]
+            for problem in _violations(text):
+                yield (
+                    anchor.lineno,
+                    anchor.col_offset,
+                    f"{problem.code} {problem.message}",
+                    owner,
+                )

placard-2026.5.29.63299.dev1/src/placard/_rules.py

@@ -0,0 +1,151 @@
+# Pure docstring-shape checks. Every function takes the cleaned string
+# returned by ``ast.get_docstring(node)`` (or a derived view of it) and
+# yields PLC violations without consulting the AST or raw source.
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Iterator
+
+RECOGNIZED: frozenset[str] = frozenset({"Args", "Returns", "Raises", "Yields"})
+_RECOGNIZED_LOWER: frozenset[str] = frozenset(label.lower() for label in RECOGNIZED)
+_CANONICAL_HEADERS: frozenset[str] = frozenset(f"{label}:" for label in RECOGNIZED)
+_CANONICAL_ARGS = "Args:"
+
+_SIGNATURE_LIKE = re.compile(r"^[A-Za-z_]\w*\(")
+_PURE_WORD = re.compile(r"^[A-Za-z]+$")
+_VALID_ARGS_ENTRY = re.compile(r"^[^():]*?[^():\s][^():]*?: \S")
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Violation:
+    """A placard violation: ``code`` is the PLCxxx, ``message`` the prose."""
+
+    code: str
+    message: str
+
+
+def _violations(text: str) -> Iterator[Violation]:
+    cleaned_lines = tuple(text.splitlines())
+    yield from _summary_violations(cleaned_lines)
+    yield from _header_violations(cleaned_lines)
+    for body in _args_bodies(cleaned_lines):
+        yield from _args_body_violations(body)
+
+
+def _summary_violations(
+    cleaned_lines: tuple[str, ...],
+) -> Iterator[Violation]:
+    if not cleaned_lines or not cleaned_lines[0].strip():
+        yield Violation(code="PLC101", message="Summary is empty")
+        return
+    summary = cleaned_lines[0]
+    if not summary.endswith("."):
+        yield Violation(
+            code="PLC102",
+            message="Summary lacks trailing period",
+        )
+    if _SIGNATURE_LIKE.match(summary):
+        yield Violation(
+            code="PLC103",
+            message=f"Summary mirrors signature: {summary!r}",
+        )
+    if len(cleaned_lines) > 1 and cleaned_lines[1].strip():
+        yield Violation(
+            code="PLC104",
+            message="Missing blank line after summary",
+        )
+
+
+def _header_violations(
+    cleaned_lines: tuple[str, ...],
+) -> Iterator[Violation]:
+    for entry in cleaned_lines[1:]:
+        if entry != entry.lstrip():
+            continue
+        defect = _header_defect(entry.rstrip())
+        if defect is not None:
+            yield defect
+
+
+def _header_defect(stripped: str) -> Violation | None:
+    if not stripped or stripped in _CANONICAL_HEADERS:
+        return None
+    head, sep, tail = stripped.partition(":")
+    label = head.strip()
+    if not _PURE_WORD.match(label):
+        return None
+    if sep == "":
+        return _bare_word_defect(label, stripped)
+    return _colon_form_defect(label, tail, stripped)
+
+
+def _bare_word_defect(label: str, stripped: str) -> Violation | None:
+    if label.lower() not in _RECOGNIZED_LOWER:
+        return None
+    return Violation(
+        code="PLC203",
+        message=f"Section header missing colon: {stripped!r}",
+    )
+
+
+def _colon_form_defect(label: str, tail: str, stripped: str) -> Violation | None:
+    if label in RECOGNIZED:
+        if tail.strip():
+            return Violation(
+                code="PLC204",
+                message=f"Section header trailing content: {stripped!r}",
+            )
+        return None
+    if label.lower() in _RECOGNIZED_LOWER:
+        return Violation(
+            code="PLC202",
+            message=f"Section header wrong case: {stripped!r}",
+        )
+    return Violation(
+        code="PLC201",
+        message=f"Unrecognized section header: {stripped!r}",
+    )
+
+
+def _args_bodies(
+    cleaned_lines: tuple[str, ...],
+) -> Iterator[tuple[str, ...]]:
+    cursor = 1
+    while cursor < len(cleaned_lines):
+        entry = cleaned_lines[cursor]
+        cursor += 1
+        if entry != entry.lstrip() or entry.rstrip() != _CANONICAL_ARGS:
+            continue
+        body_start = cursor
+        while cursor < len(cleaned_lines) and _is_body_member(cleaned_lines[cursor]):
+            cursor += 1
+        yield cleaned_lines[body_start:cursor]
+
+
+def _is_body_member(entry: str) -> bool:
+    if not entry.strip():
+        return True
+    return entry != entry.lstrip()
+
+
+def _args_body_violations(body: tuple[str, ...]) -> Iterator[Violation]:
+    nonblank = tuple(entry for entry in body if entry.strip())
+    if not nonblank:
+        yield Violation(
+            code="PLC302",
+            message="Args section is empty",
+        )
+        return
+    base_indent = min(len(entry) - len(entry.lstrip()) for entry in nonblank)
+    for entry in nonblank:
+        current_indent = len(entry) - len(entry.lstrip())
+        if current_indent != base_indent:
+            continue
+        content = entry.lstrip()
+        if _VALID_ARGS_ENTRY.match(content) is None:
+            yield Violation(
+                code="PLC301",
+                message=f"Args entry malformed: {content!r}",
+            )

placard-2026.5.29.63299.dev1/src/placard/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for placard."""

placard-2026.5.29.63299.dev1/src/placard/tests/test_init.py

@@ -0,0 +1,14 @@
+"""Smoke tests for the placard package."""
+
+import unittest
+from hamcrest import assert_that, contains_string
+
+from .. import __version__
+
+
+class TestInit(unittest.TestCase):
+    """Check that package-level attributes are wired up."""
+
+    def test_version(self) -> None:
+        """The package exposes a dotted version string."""
+        assert_that(__version__, contains_string("."))

placard-2026.5.29.63299.dev1/src/placard/tests/test_plugin.py

@@ -0,0 +1,80 @@
+"""Cover the flake8 plugin entry point that drives placard's rules."""
+
+from __future__ import annotations
+
+import ast
+import unittest
+
+from hamcrest import assert_that, contains_string, equal_to, has_item
+
+from .._plugin import Plugin
+
+
+def _runs(
+    tree: ast.AST,
+) -> list[tuple[int, int, str, type[Plugin]]]:
+    return list(Plugin(tree=tree).run())
+
+
+def _codes_in(source: str) -> list[str]:
+    return [run[2].split()[0] for run in _runs(ast.parse(source))]
+
+
+def _first_run(source: str) -> tuple[int, int, str, type[Plugin]]:
+    return _runs(ast.parse(source))[0]
+
+
+class TestPluginDispatch(unittest.TestCase):
+    """Plugin.run walks the AST and emits PLC violations for docstrings."""
+
+    def test_module_docstring_line_and_code(self) -> None:
+        """A module docstring violation reports at line 1 with its code."""
+        first = _first_run('"""bad summary"""\n')
+        assert_that(first[0], equal_to(1))
+        assert_that(first[2], contains_string("PLC102"))
+
+    def test_function_docstring_violations_emitted(self) -> None:
+        """A function docstring is checked just like a module docstring."""
+        source = 'def f():\n    """bad summary"""\n    return 1\n'
+        assert_that(_codes_in(source), has_item("PLC102"))
+
+    def test_class_docstring_violations_emitted(self) -> None:
+        """A class docstring is checked."""
+        source = 'class C:\n    """bad summary"""\n    pass\n'
+        assert_that(_codes_in(source), has_item("PLC102"))
+
+    def test_async_function_docstring_violations_emitted(self) -> None:
+        """An async function docstring is checked."""
+        source = 'async def f():\n    """bad summary"""\n    return 1\n'
+        assert_that(_codes_in(source), has_item("PLC102"))
+
+    def test_missing_docstring_is_skipped(self) -> None:
+        """A function without a docstring produces no output."""
+        source = "def f():\n    return 1\n"
+        assert_that(_codes_in(source), equal_to([]))
+
+    def test_good_docstring_produces_no_violations(self) -> None:
+        """A well-formed docstring produces no violations."""
+        source = 'def f():\n    """Do the thing."""\n    return 1\n'
+        assert_that(_codes_in(source), equal_to([]))
+
+    def test_yielded_class_is_plugin(self) -> None:
+        """The fourth tuple element is the Plugin class itself."""
+        first = _first_run('"""bad"""\n')
+        assert_that(first[3], equal_to(Plugin))
+
+    def test_nested_function_docstring_is_checked(self) -> None:
+        """Docstring rules apply to functions nested inside other nodes."""
+        source = (
+            "def outer():\n"
+            "    def inner():\n"
+            '        """bad summary"""\n'
+            "        return 1\n"
+            "    return inner\n"
+        )
+        assert_that(_codes_in(source), has_item("PLC102"))
+
+    def test_column_matches_docstring_col_offset(self) -> None:
+        """The reported column equals the docstring node's col_offset."""
+        first = _first_run('def f():\n    """bad"""\n    return 1\n')
+        assert_that(first[1], equal_to(4))

placard-2026.5.29.63299.dev1/src/placard/tests/test_rules.py

@@ -0,0 +1,228 @@
+"""Cover every PLC rule and every branch of placard's docstring checks."""
+
+from __future__ import annotations
+
+import unittest
+
+from hamcrest import assert_that, contains_string, equal_to, has_item
+
+from .._rules import Violation, _violations
+
+
+def _codes(text: str) -> list[str]:
+    return [problem.code for problem in _violations(text)]
+
+
+def _messages(text: str) -> list[str]:
+    return [problem.message for problem in _violations(text)]
+
+
+class TestSummaryRules(unittest.TestCase):
+    """Cover PLC101-PLC104 against the docstring summary line."""
+
+    def test_empty_string_raises_plc101(self) -> None:
+        """An entirely empty docstring fires PLC101."""
+        assert_that(_codes(""), equal_to(["PLC101"]))
+
+    def test_whitespace_only_summary_raises_plc101(self) -> None:
+        """A summary containing only whitespace fires PLC101."""
+        assert_that(_codes("   "), equal_to(["PLC101"]))
+
+    def test_summary_missing_period_raises_plc102(self) -> None:
+        """A summary that doesn't end with a period fires PLC102."""
+        assert_that(_codes("Summarize the thing"), equal_to(["PLC102"]))
+
+    def test_signature_shape_raises_plc103(self) -> None:
+        """A summary shaped like a call signature fires PLC103."""
+        assert_that(_codes("process(data, config)."), equal_to(["PLC103"]))
+
+    def test_prose_summary_does_not_fire_plc103(self) -> None:
+        """A normal prose summary does not fire PLC103."""
+        assert_that(_codes("Process the input."), equal_to([]))
+
+    def test_no_blank_line_after_summary_raises_plc104(self) -> None:
+        """A multi-line docstring without a blank line fires PLC104."""
+        text = "Summarize.\nMore detail follows."
+        assert_that(_codes(text), equal_to(["PLC104"]))
+
+    def test_blank_line_after_summary_is_clean(self) -> None:
+        """A blank line after the summary satisfies PLC104."""
+        text = "Summarize.\n\nMore detail follows."
+        assert_that(_codes(text), equal_to([]))
+
+    def test_single_line_summary_no_plc104(self) -> None:
+        """A one-line docstring never triggers PLC104."""
+        assert_that(_codes("Just one line."), equal_to([]))
+
+    def test_plc103_message_includes_summary(self) -> None:
+        """The PLC103 message includes the offending summary verbatim."""
+        assert_that(
+            _messages("connect(host, port).")[0],
+            contains_string("connect(host, port)."),
+        )
+
+
+class TestHeaderRules(unittest.TestCase):
+    """Cover PLC201-PLC204 against section header lines."""
+
+    def test_canonical_args_header_is_clean(self) -> None:
+        """An exact ``Args:`` header is accepted with a valid entry."""
+        text = "Summary.\n\nArgs:\n    x: the input.\n"
+        assert_that(_codes(text), equal_to([]))
+
+    def test_unrecognized_header_raises_plc201(self) -> None:
+        """A non-recognized ``Word:`` header fires PLC201."""
+        text = "Summary.\n\nArguments:\n    x: the input.\n"
+        codes = _codes(text)
+        assert_that(codes, has_item("PLC201"))
+
+    def test_lowercased_header_raises_plc202(self) -> None:
+        """A wrong-case header (``args:``) fires PLC202."""
+        text = "Summary.\n\nargs:\n    x: the input.\n"
+        codes = _codes(text)
+        assert_that(codes, has_item("PLC202"))
+
+    def test_missing_colon_raises_plc203(self) -> None:
+        """A bare recognized name (``Args``) fires PLC203."""
+        text = "Summary.\n\nArgs\n    x: the input.\n"
+        codes = _codes(text)
+        assert_that(codes, has_item("PLC203"))
+
+    def test_trailing_content_raises_plc204(self) -> None:
+        """A canonical header with trailing content fires PLC204."""
+        text = "Summary.\n\nArgs: some.\n    x: the input.\n"
+        codes = _codes(text)
+        assert_that(codes, has_item("PLC204"))
+
+    def test_indented_word_is_not_header(self) -> None:
+        """An indented ``Args:`` line is body content, not a header."""
+        text = "Summary.\n\n    Args:\n"
+        assert_that(_codes(text), equal_to([]))
+
+    def test_blank_lines_after_summary_are_ignored(self) -> None:
+        """Blank body lines are not classified as headers."""
+        text = "Summary.\n\n\n"
+        assert_that(_codes(text), equal_to([]))
+
+    def test_multi_word_prose_is_not_a_header(self) -> None:
+        """Prose containing a colon is not flagged as a header."""
+        text = "Summary.\n\nNotes about: the implementation.\n"
+        assert_that(_codes(text), equal_to([]))
+
+    def test_bare_unrecognized_word_is_not_a_header(self) -> None:
+        """A bare unrecognized word at col 0 is not flagged."""
+        text = "Summary.\n\nFoo\n"
+        assert_that(_codes(text), equal_to([]))
+
+    def test_lowercased_bare_name_raises_plc203(self) -> None:
+        """A bare lowercase recognized name still fires PLC203."""
+        text = "Summary.\n\nargs\n"
+        assert_that(_codes(text), has_item("PLC203"))
+
+    def test_canonical_returns_header_is_clean(self) -> None:
+        """The other canonical headers are also accepted."""
+        text = "Summary.\n\nReturns:\n    the value.\n"
+        assert_that(_codes(text), equal_to([]))
+
+    def test_recognized_name_with_space_before_colon_passes(self) -> None:
+        """``Args :`` (space before colon, no trailing content) is not flagged.
+
+        Placard reports PLC204 only when there is real content after the
+        colon; whitespace-only oddities silently pass.
+        """
+        text = "Summary.\n\nArgs :\n"
+        assert_that(_codes(text), equal_to([]))
+
+
+class TestArgsBodyRules(unittest.TestCase):
+    """Cover PLC301 and PLC302 inside ``Args:`` bodies."""
+
+    def test_valid_entry_is_clean(self) -> None:
+        """A ``name: description`` entry passes."""
+        text = "Summary.\n\nArgs:\n    x: the input value.\n"
+        assert_that(_codes(text), equal_to([]))
+
+    def test_empty_args_body_raises_plc302(self) -> None:
+        """An ``Args:`` header with no entries fires PLC302."""
+        text = "Summary.\n\nArgs:\n"
+        assert_that(_codes(text), equal_to(["PLC302"]))
+
+    def test_parenthesized_type_raises_plc301(self) -> None:
+        """An entry with a parenthesized type fires PLC301."""
+        text = "Summary.\n\nArgs:\n    x (int): the value.\n"
+        assert_that(_codes(text), equal_to(["PLC301"]))
+
+    def test_no_colon_in_entry_raises_plc301(self) -> None:
+        """An entry without a colon fires PLC301."""
+        text = "Summary.\n\nArgs:\n    just a word\n"
+        assert_that(_codes(text), equal_to(["PLC301"]))
+
+    def test_no_description_after_colon_raises_plc301(self) -> None:
+        """An entry with a colon but no description fires PLC301."""
+        text = "Summary.\n\nArgs:\n    x:\n"
+        assert_that(_codes(text), equal_to(["PLC301"]))
+
+    def test_no_space_after_colon_raises_plc301(self) -> None:
+        """An entry must have a space between the colon and description."""
+        text = "Summary.\n\nArgs:\n    x:description\n"
+        assert_that(_codes(text), equal_to(["PLC301"]))
+
+    def test_continuation_lines_do_not_double_report(self) -> None:
+        """Lines deeper than the entry indent are continuations."""
+        text = (
+            "Summary.\n"
+            "\n"
+            "Args:\n"
+            "    x: the value.\n"
+            "        wraps across lines.\n"
+            "    y: the other value.\n"
+        )
+        assert_that(_codes(text), equal_to([]))
+
+    def test_blank_line_inside_body_stays_in_section(self) -> None:
+        """Blank lines inside the ``Args`` body do not end the section."""
+        text = (
+            "Summary.\n"
+            "\n"
+            "Args:\n"
+            "    x: the first.\n"
+            "\n"
+            "    y: the second.\n"
+        )
+        assert_that(_codes(text), equal_to([]))
+
+    def test_body_ends_at_next_header(self) -> None:
+        """A non-indented line after the body ends the Args section."""
+        text = (
+            "Summary.\n"
+            "\n"
+            "Args:\n"
+            "    x: the input.\n"
+            "Returns:\n"
+            "    the output.\n"
+        )
+        assert_that(_codes(text), equal_to([]))
+
+    def test_plc301_message_includes_offending_entry(self) -> None:
+        """The PLC301 message mentions the offending entry text."""
+        text = "Summary.\n\nArgs:\n    x (int): the value.\n"
+        assert_that(
+            _messages(text)[0],
+            contains_string("x (int): the value."),
+        )
+
+
+class TestViolationDataclass(unittest.TestCase):
+    """Cover the Violation dataclass contract."""
+
+    def test_violation_is_frozen(self) -> None:
+        """``Violation`` instances are immutable."""
+        problem = Violation(code="PLC101", message="x")
+        with self.assertRaises(Exception):
+            problem.code = "PLC102"  # type: ignore[misc]
+
+    def test_violation_carries_code_and_message(self) -> None:
+        """``Violation`` exposes ``code`` and ``message`` attributes."""
+        problem = Violation(code="PLC101", message="x")
+        assert_that(problem.code, equal_to("PLC101"))
+        assert_that(problem.message, equal_to("x"))

placard-2026.5.29.63299.dev1/src/placard.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: placard
+Version: 2026.5.29.63299.dev1
+Author-email: Moshe Zadka <moshez@zadka.club>
+License: Permission is hereby granted, free of charge, to any person obtaining a
+        copy of this software and associated documentation files (the "Software"),
+        to deal in the Software without restriction, including without limitation the
+        rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is furnished
+        to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+        INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+        PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+        HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+        CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+        OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/moshez/placard
+Description-Content-Type: text/x-rst
+Provides-Extra: tests
+Requires-Dist: virtue; extra == "tests"
+Requires-Dist: pyhamcrest; extra == "tests"
+Requires-Dist: coverage; extra == "tests"
+Provides-Extra: mypy
+Requires-Dist: mypy; extra == "mypy"
+Provides-Extra: lint
+Requires-Dist: flake8; extra == "lint"
+Requires-Dist: black; extra == "lint"
+Requires-Dist: stolid; extra == "lint"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+
+placard
+========================
+
+Stuff

placard-2026.5.29.63299.dev1/src/placard.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.rst
+git-log-head
+pyproject.toml
+src/placard/__init__.py
+src/placard/_plugin.py
+src/placard/_rules.py
+src/placard.egg-info/PKG-INFO
+src/placard.egg-info/SOURCES.txt
+src/placard.egg-info/dependency_links.txt
+src/placard.egg-info/entry_points.txt
+src/placard.egg-info/requires.txt
+src/placard.egg-info/top_level.txt
+src/placard/tests/__init__.py
+src/placard/tests/test_init.py
+src/placard/tests/test_plugin.py
+src/placard/tests/test_rules.py

placard-2026.5.29.63299.dev1/src/placard.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

placard-2026.5.29.63299.dev1/src/placard.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[flake8.extension]
+PLC = placard:Plugin

placard-2026.5.29.63299.dev1/src/placard.egg-info/requires.txt

@@ -0,0 +1,16 @@
+
+[docs]
+sphinx
+
+[lint]
+flake8
+black
+stolid
+
+[mypy]
+mypy
+
+[tests]
+virtue
+pyhamcrest
+coverage

placard-2026.5.29.63299.dev1/src/placard.egg-info/top_level.txt

@@ -0,0 +1 @@
+placard