sectionise 0.1.0__py3-none-any.whl

sectionise/cli.py

@@ -0,0 +1,150 @@
+"""Command-line entry point for sectionise.
+
+Resolves settings with the precedence flags > `[tool.sectionise]` in the nearest
+`pyproject.toml` > built-in defaults, then lints or autofixes the given files.
+Exits non-zero when it changed anything or hit an over-long title, matching the
+pre-commit formatter convention.
+"""
+
+import argparse
+import tomllib
+from pathlib import Path
+
+from . import core
+
+
+def _find_pyproject(start: Path) -> Path | None:
+    """Return the nearest `pyproject.toml` at or above `start`, else `None`."""
+    start = start.resolve()
+    for parent in (start, *start.parents):
+        candidate = parent / "pyproject.toml"
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def _load_config(path: Path | None) -> dict:
+    """Read the `[tool.sectionise]` table from a `pyproject.toml`.
+
+    Args:
+        path: The file to read, or `None`.
+
+    Returns:
+        The table as a dict, or an empty dict when absent or unreadable.
+    """
+    if path is None or not path.is_file():
+        return {}
+    try:
+        with open(path, "rb") as handle:
+            data = tomllib.load(handle)
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}
+    tool = data.get("tool", {})
+    section = tool.get("sectionise", {})
+    return section if isinstance(section, dict) else {}
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """Build the argument parser.
+
+    Overridable options default to `None` so an unset flag falls through to
+    `pyproject.toml` and then the built-in default.
+    """
+    parser = argparse.ArgumentParser(
+        prog="sectionise",
+        description="Standardise section-header comment banners.",
+    )
+    parser.add_argument("filenames", nargs="*", help="Files to process.")
+    parser.add_argument("--config", type=Path, default=None, help="pyproject.toml to read.")
+    parser.add_argument("--width", type=int, default=None, help="Target line length.")
+    parser.add_argument("--fill", default=None, help="Output fill character.")
+    parser.add_argument(
+        "--detect-chars", default=None, help="Characters recognised as banner fill."
+    )
+    parser.add_argument("--min-run", type=int, default=None, help="Minimum fill-run length.")
+    parser.add_argument(
+        "--style", choices=("single", "box"), default=None, help="Output form."
+    )
+    parser.add_argument(
+        "--max-title", type=int, default=None, help="Hard cap on title length."
+    )
+    parser.add_argument(
+        "--require-both-sides",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="Only treat comments with fill on both sides as banners.",
+    )
+    parser.add_argument(
+        "--dividers",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="Also standardise stand-alone title-less rules.",
+    )
+    parser.add_argument(
+        "--check", action="store_true", help="Report only; do not rewrite files."
+    )
+    return parser
+
+
+def _resolve_style(args: argparse.Namespace, config: dict) -> core.Style:
+    """Merge flags over `pyproject.toml` over defaults into a `Style`."""
+
+    def pick(flag_value, key, default):
+        if flag_value is not None:
+            return flag_value
+        return config.get(key, default)
+
+    return core.Style(
+        width=pick(args.width, "width", core.DEFAULT_WIDTH),
+        fill=pick(args.fill, "fill", core.DEFAULT_FILL),
+        detect_chars=pick(args.detect_chars, "detect_chars", core.DEFAULT_DETECT_CHARS),
+        min_run=pick(args.min_run, "min_run", core.DEFAULT_MIN_RUN),
+        require_both_sides=pick(args.require_both_sides, "require_both_sides", False),
+        dividers=pick(args.dividers, "dividers", False),
+        style=pick(args.style, "style", core.DEFAULT_STYLE),
+        max_title=pick(args.max_title, "max_title", None),
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Lint or autofix section-header banners in the given files.
+
+    Args:
+        argv: Argument list; defaults to `sys.argv[1:]`.
+
+    Returns:
+        `1` if any file was (or would be) changed or a title was too long, else
+        `0`.
+    """
+    args = _build_parser().parse_args(argv)
+    config = _load_config(args.config or _find_pyproject(Path.cwd()))
+    style = _resolve_style(args, config)
+
+    changed_files: list[str] = []
+    all_errors: list[str] = []
+    for name in args.filenames:
+        path = Path(name)
+        syntax = core.syntax_for(path.suffix)
+        if syntax is None:
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        new_text, changed, errors = core.process_text(text, syntax, style, name)
+        all_errors.extend(errors)
+        if changed:
+            changed_files.append(name)
+            if not args.check:
+                path.write_text(new_text, encoding="utf-8")
+
+    verb = "would reformat" if args.check else "reformatted"
+    for name in changed_files:
+        print(f"{verb} section headers in {name}")
+    for error in all_errors:
+        print(error)
+    return 1 if changed_files or all_errors else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sectionise/core.py

@@ -0,0 +1,383 @@
+"""Detect and standardise section-header comment banners.
+
+A section header is a comment styled as a banner: a title framed by a run of
+fill characters. Real code carries many variants, all of which this module
+detects and rewrites to one canonical style:
+
+* single-line, framed both sides:  `# ------- Loading models -------`
+* single-line, filled one side:     `# Ancillary functions ----------`
+* Unicode fill (em/en dash, rules): `# --- Loading models ---`
+* three-line box:                   a rule, a title comment, a rule
+
+Detection is deliberately conservative: only full-line comments whose content
+is framed by a fill run of at least `min_run` characters are touched, so
+ordinary comments, trailing comments, and commented-out code (for example
+`# print("=== x ===")`) are left alone. Title-less rules are ignored unless
+`dividers` is enabled.
+
+The pure functions here have no I/O; `cli` wires configuration and files around
+them.
+"""
+
+from dataclasses import dataclass
+
+DEFAULT_WIDTH = 88
+DEFAULT_FILL = "-"
+# ASCII banner fills plus common Unicode ones (em dash, en dash, box rules).
+DEFAULT_DETECT_CHARS = "-=*_~#—–─═"
+DEFAULT_MIN_RUN = 3
+DEFAULT_STYLE = "single"
+
+# Comment syntax per file extension as (opener, closer). The closer is empty for
+# line comments and non-empty for block comments (HTML/XML/Markdown).
+_LINE_HASH = ("#", "")
+_LINE_SLASH = ("//", "")
+_BLOCK_HTML = ("<!--", "-->")
+
+_SYNTAX_BY_SUFFIX = {
+    ".py": _LINE_HASH,
+    ".pyi": _LINE_HASH,
+    ".sh": _LINE_HASH,
+    ".bash": _LINE_HASH,
+    ".toml": _LINE_HASH,
+    ".yaml": _LINE_HASH,
+    ".yml": _LINE_HASH,
+    ".cfg": _LINE_HASH,
+    ".ini": _LINE_HASH,
+    ".js": _LINE_SLASH,
+    ".jsx": _LINE_SLASH,
+    ".ts": _LINE_SLASH,
+    ".tsx": _LINE_SLASH,
+    ".c": _LINE_SLASH,
+    ".h": _LINE_SLASH,
+    ".cpp": _LINE_SLASH,
+    ".cc": _LINE_SLASH,
+    ".java": _LINE_SLASH,
+    ".css": _LINE_SLASH,
+    ".go": _LINE_SLASH,
+    ".rs": _LINE_SLASH,
+    ".html": _BLOCK_HTML,
+    ".htm": _BLOCK_HTML,
+    ".xml": _BLOCK_HTML,
+    ".md": _BLOCK_HTML,
+}
+
+
+@dataclass(frozen=True)
+class Style:
+    """Banner detection and output settings.
+
+    Attributes:
+        width: Target total line length for a rewritten banner or rule.
+        fill: The single fill character used in output.
+        detect_chars: Characters recognised as banner fill in input.
+        min_run: Minimum identical-fill run length to count as a banner side.
+        require_both_sides: Only treat a comment as a banner when it has a fill
+            run on both sides of the title.
+        dividers: Also standardise stand-alone title-less rules.
+        style: Output form, `single` (one line) or `box` (three lines).
+        max_title: Optional hard cap on title length, on top of the width fit.
+    """
+
+    width: int = DEFAULT_WIDTH
+    fill: str = DEFAULT_FILL
+    detect_chars: str = DEFAULT_DETECT_CHARS
+    min_run: int = DEFAULT_MIN_RUN
+    require_both_sides: bool = False
+    dividers: bool = False
+    style: str = DEFAULT_STYLE
+    max_title: int | None = None
+
+
+def syntax_for(suffix: str) -> tuple[str, str] | None:
+    """Return the comment syntax for a file suffix, or `None` if unsupported.
+
+    Args:
+        suffix: A file extension including the dot (for example `.py`).
+
+    Returns:
+        The `(opener, closer)` comment tokens, or `None`.
+    """
+    return _SYNTAX_BY_SUFFIX.get(suffix.lower())
+
+
+def _content(line: str) -> str:
+    """Return `line` without its trailing newline."""
+    return line.rstrip("\r\n")
+
+
+def _eol(line: str) -> str:
+    """Return the trailing newline of a keepends line, or empty at end of file."""
+    return line[len(_content(line)) :]
+
+
+def _extract(content: str, syntax: tuple[str, str]) -> tuple[str, str] | None:
+    """Split a full-line comment into its indent and inner text.
+
+    Args:
+        content: One line with the newline already removed.
+        syntax: The `(opener, closer)` comment tokens.
+
+    Returns:
+        `(indent, inner)` when the whole line is a comment in this syntax, else
+        `None` (a code line, or a trailing comment).
+    """
+    opener, closer = syntax
+    stripped = content.lstrip()
+    indent = content[: len(content) - len(stripped)]
+    if not stripped.startswith(opener):
+        return None
+    inner = stripped[len(opener) :]
+    if closer:
+        if not inner.rstrip().endswith(closer):
+            return None
+        inner = inner.rstrip()[: -len(closer)]
+    return indent, inner
+
+
+def _side_runs(inner: str, style: Style) -> tuple[int, int, str]:
+    """Measure the leading and trailing fill runs and the title between them.
+
+    Args:
+        inner: The comment's inner text (between the comment tokens).
+        style: The active settings.
+
+    Returns:
+        `(leading_run, trailing_run, title)` for the stripped inner text.
+    """
+    stripped = inner.strip()
+    if not stripped:
+        return 0, 0, ""
+    lead = 0
+    if stripped[0] in style.detect_chars:
+        char = stripped[0]
+        while lead < len(stripped) and stripped[lead] == char:
+            lead += 1
+    trail = 0
+    if stripped[-1] in style.detect_chars:
+        char = stripped[-1]
+        while trail < len(stripped) and stripped[-1 - trail] == char:
+            trail += 1
+    title = stripped[lead : len(stripped) - trail].strip()
+    return lead, trail, title
+
+
+def _is_rule(content: str, syntax: tuple[str, str], style: Style) -> bool:
+    """Return whether a line is a title-less fill rule."""
+    extracted = _extract(content, syntax)
+    if extracted is None:
+        return False
+    lead, trail, title = _side_runs(extracted[1], style)
+    return not title and (lead >= style.min_run or trail >= style.min_run)
+
+
+def _banner_title(content: str, syntax: tuple[str, str], style: Style) -> str | None:
+    """Return the title if a line is a single-line banner, else `None`."""
+    extracted = _extract(content, syntax)
+    if extracted is None:
+        return None
+    lead, trail, title = _side_runs(extracted[1], style)
+    if not title:
+        return None
+    has_lead = lead >= style.min_run
+    has_trail = trail >= style.min_run
+    ok = (has_lead and has_trail) if style.require_both_sides else (has_lead or has_trail)
+    return title if ok else None
+
+
+def _box_title(content: str, syntax: tuple[str, str], style: Style) -> str | None:
+    """Return the title of a box's middle comment line, else `None`."""
+    extracted = _extract(content, syntax)
+    if extracted is None:
+        return None
+    title = _side_runs(extracted[1], style)[2]
+    return title or None
+
+
+def _format_banner(indent: str, syntax: tuple[str, str], title: str, style: Style) -> str:
+    """Render a canonical single-line banner: fill padded around a centred title."""
+    opener, closer = syntax
+    open_part = f"{opener} "
+    close_part = f" {closer}" if closer else ""
+    fixed = len(indent) + len(open_part) + 1 + len(title) + 1 + len(close_part)
+    total = max(style.width - fixed, 2 * style.min_run)
+    left = total // 2
+    right = total - left
+    return f"{indent}{open_part}{style.fill * left} {title} {style.fill * right}{close_part}"
+
+
+def _format_rule(indent: str, syntax: tuple[str, str], style: Style) -> str:
+    """Render a canonical title-less fill rule padded to the target width."""
+    opener, closer = syntax
+    open_part = f"{opener} "
+    close_part = f" {closer}" if closer else ""
+    count = max(style.width - len(indent) - len(open_part) - len(close_part), style.min_run)
+    return f"{indent}{open_part}{style.fill * count}{close_part}"
+
+
+def _format_title_line(indent: str, syntax: tuple[str, str], title: str) -> str:
+    """Render the middle title line of a box header."""
+    opener, closer = syntax
+    close_part = f" {closer}" if closer else ""
+    return f"{indent}{opener} {title}{close_part}"
+
+
+def _render(indent: str, syntax: tuple[str, str], title: str, style: Style) -> list[str]:
+    """Return the canonical output lines for a banner in the chosen style."""
+    if style.style == "box":
+        rule = _format_rule(indent, syntax, style)
+        return [rule, _format_title_line(indent, syntax, title), rule]
+    return [_format_banner(indent, syntax, title, style)]
+
+
+def _title_limit(indent: str, syntax: tuple[str, str], style: Style) -> int:
+    """Return the maximum title length that fits the chosen style and cap."""
+    opener, closer = syntax
+    open_part = f"{opener} "
+    close_part = f" {closer}" if closer else ""
+    if style.style == "box":
+        fit = style.width - len(indent) - len(open_part) - len(close_part)
+    else:
+        fit = (
+            style.width
+            - len(indent)
+            - len(open_part)
+            - 2  # the two spaces framing the title
+            - len(close_part)
+            - 2 * style.min_run
+        )
+    fit = max(fit, 1)
+    return min(fit, style.max_title) if style.max_title is not None else fit
+
+
+def _too_long_error(path: str, lineno: int, title: str, limit: int, style: Style) -> str:
+    """Build the error message for an over-long title."""
+    base = (
+        f"{path}:{lineno}: section title is {len(title)} chars but the limit is "
+        f"{limit} ({style.style} style, width {style.width})."
+    )
+    if style.style == "single":
+        return base + " Shorten it, or use box style for a multi-line header."
+    return base + " Shorten it."
+
+
+def _emit_unit(
+    lines: list[str],
+    start: int,
+    end: int,
+    indent: str,
+    title: str,
+    syntax: tuple[str, str],
+    style: Style,
+    path: str,
+    file_eol: str,
+) -> tuple[str, bool, str | None]:
+    """Render one banner unit, or pass it through on an over-long title.
+
+    Args:
+        lines: The file split with line endings kept.
+        start: Index of the unit's first source line.
+        end: Index of the unit's last source line.
+        indent: The unit's leading whitespace.
+        title: The extracted title.
+        syntax: The `(opener, closer)` comment tokens.
+        style: The active settings.
+        path: Display path for error messages.
+        file_eol: The file's dominant newline, used when a source line has none.
+
+    Returns:
+        `(chunk, changed, error)`. On error, `chunk` is the original text so the
+        source is left untouched.
+    """
+    original = "".join(lines[start : end + 1])
+    limit = _title_limit(indent, syntax, style)
+    if len(title) > limit:
+        return original, False, _too_long_error(path, start + 1, title, limit, style)
+
+    rendered = _render(indent, syntax, title, style)
+    eol = _eol(lines[start]) or file_eol
+    had_final_newline = bool(_eol(lines[end]))
+    chunk = ""
+    for idx, out_line in enumerate(rendered):
+        chunk += out_line
+        if idx < len(rendered) - 1 or had_final_newline:
+            chunk += eol
+    return chunk, chunk != original, None
+
+
+def process_text(
+    text: str, syntax: tuple[str, str], style: Style, path: str = "<text>"
+) -> tuple[str, int, list[str]]:
+    """Reformat every section-header banner in `text`.
+
+    Args:
+        text: The full file contents.
+        syntax: The `(opener, closer)` comment tokens for the file.
+        style: The active settings.
+        path: Display path used in error messages.
+
+    Returns:
+        `(new_text, changed_count, errors)`. Passthrough lines keep their exact
+        original newline; rewritten units use their first source line's newline.
+    """
+    lines = text.splitlines(keepends=True)
+    n = len(lines)
+    file_eol = "\r\n" if "\r\n" in text else "\n"
+    out: list[str] = []
+    changed = 0
+    errors: list[str] = []
+
+    i = 0
+    while i < n:
+        c0 = _content(lines[i])
+
+        # Three-line box: rule / title comment / rule, all the same indent.
+        if i + 2 < n:
+            c1, c2 = _content(lines[i + 1]), _content(lines[i + 2])
+            if (
+                _is_rule(c0, syntax, style)
+                and not _is_rule(c1, syntax, style)
+                and _is_rule(c2, syntax, style)
+            ):
+                title = _box_title(c1, syntax, style)
+                indents = [_extract(c, syntax) for c in (c0, c1, c2)]
+                if title and all(indents) and len({e[0] for e in indents}) == 1:
+                    chunk, did, error = _emit_unit(
+                        lines, i, i + 2, indents[0][0], title, syntax, style, path, file_eol
+                    )
+                    out.append(chunk)
+                    changed += did
+                    if error:
+                        errors.append(error)
+                    i += 3
+                    continue
+
+        # Stand-alone title-less rule.
+        if _is_rule(c0, syntax, style):
+            if style.dividers:
+                rule = _format_rule(_extract(c0, syntax)[0], syntax, style)
+                new_line = rule + (_eol(lines[i]) or file_eol) if _eol(lines[i]) else rule
+                out.append(new_line)
+                changed += new_line != lines[i]
+            else:
+                out.append(lines[i])
+            i += 1
+            continue
+
+        # Single-line banner.
+        title = _banner_title(c0, syntax, style)
+        if title:
+            chunk, did, error = _emit_unit(
+                lines, i, i, _extract(c0, syntax)[0], title, syntax, style, path, file_eol
+            )
+            out.append(chunk)
+            changed += did
+            if error:
+                errors.append(error)
+            i += 1
+            continue
+
+        out.append(lines[i])
+        i += 1
+
+    return "".join(out), changed, errors

sectionise-0.1.0.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: sectionise
+Version: 0.1.0
+Summary: Standardise section-header comment banners
+Project-URL: Homepage, https://github.com/MitchellNeedham/sectionise
+Project-URL: Repository, https://github.com/MitchellNeedham/sectionise
+Author-email: Mitchell Needham <contact@mitchellneedham.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: comments,formatter,linter,pre-commit,section-headers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# sectionise
+
+[![PyPI](https://img.shields.io/pypi/v/sectionise.svg)](https://pypi.org/project/sectionise/)
+[![Python](https://img.shields.io/pypi/pyversions/sectionise.svg)](https://pypi.org/project/sectionise/)
+
+Standardise section-header comment banners across a codebase to one canonical
+style. Runs as a pre-commit hook or a CLI, and is configured from
+`pyproject.toml` (with flag overrides).
+
+A section header is a comment styled as a banner: a title framed by a run of
+fill characters. Real code accumulates many variants; `sectionise` detects them
+and rewrites each to the same shape.
+
+## What it standardises
+
+| Variant | Example in |
+| --- | --- |
+| Single-line, framed both sides | `# ------- Loading models -------` |
+| Single-line, filled one side | `# Ancillary functions ----------` |
+| Unicode fill (em/en dash, box rules) | `# ——— Loading models ———` |
+| Three-line box | a rule line, a title comment, a rule line |
+
+All of them normalise to the configured style, for example the single-line form:
+
+```
+# ---------------------------- Loading models -----------------------------
+```
+
+Detection is conservative: only full-line comments whose content is framed by a
+fill run of at least `min_run` characters are touched. Ordinary comments,
+trailing comments, and commented-out code (`# print("=== run ===")`) are left
+alone. Title-less rules (`# --------`) are ignored unless `dividers` is enabled.
+
+A title too long to fit the chosen style is reported as an error suggesting a
+shorter title or the multi-line `box` style, rather than being silently
+overflowed.
+
+## Installation
+
+```bash
+pip install sectionise
+# or: uv add sectionise    (add to a project)
+# or: uvx sectionise ...   (run without installing)
+```
+
+## Use as a pre-commit hook
+
+```yaml
+- repo: https://github.com/MitchellNeedham/sectionise
+  rev: 0.1.0
+  hooks:
+      - id: sectionise
+```
+
+It fixes in place and fails the commit if it changed anything (re-stage and
+commit again), the same way `ruff-format` behaves.
+
+## Use as a CLI
+
+```bash
+sectionise path/to/file.py          # fix in place
+sectionise --check path/to/file.py  # report only, no writes
+```
+
+## Configuration
+
+Settings resolve with the precedence **flags > `[tool.sectionise]` > defaults**.
+Put shared settings in each repo's `pyproject.toml`:
+
+```toml
+[tool.sectionise]
+width = 88
+style = "single"        # or "box"
+fill = "-"
+detect_chars = "-=*_~#—–─═"
+min_run = 3
+require_both_sides = false
+dividers = false
+# max_title = 60        # optional hard cap on title length
+```
+
+| Setting | Flag | Default | Meaning |
+| --- | --- | --- | --- |
+| `width` | `--width` | `88` | Target total line length. |
+| `style` | `--style` | `single` | Output form: `single` line or 3-line `box`. |
+| `fill` | `--fill` | `-` | Output fill character. |
+| `detect_chars` | `--detect-chars` | `-=*_~#—–─═` | Characters recognised as fill in input. |
+| `min_run` | `--min-run` | `3` | Minimum fill-run length to count as a banner side. |
+| `require_both_sides` | `--require-both-sides` | `false` | Only treat both-sided comments as banners. |
+| `dividers` | `--dividers` | `false` | Also standardise title-less rules. |
+| `max_title` | `--max-title` | none | Hard cap on title length, on top of the width fit. |
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check
+```
+
+## Publishing
+
+Releases go to [PyPI](https://pypi.org/project/sectionise/) on a version tag.
+
+- **Set the token once.** In the GitHub repo, add a repository secret named
+  `PYPI_API_TOKEN` holding a PyPI API token
+  (Settings > Secrets and variables > Actions).
+- **Release.** Tag a version and push it; the publish workflow builds and
+  uploads:
+
+  ```bash
+  git tag 0.1.0
+  git push origin 0.1.0
+  ```
+
+  The version comes from the tag via `hatch-vcs`, so the tag is the single
+  source of truth.
+
+To publish from your machine instead, copy `.env.example` to `.env`, paste your
+token, and run:
+
+```bash
+set -a && source .env && set +a
+uv build && uv publish dist/*
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

sectionise-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+sectionise/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sectionise/cli.py,sha256=JCcyGTAH5bNcd1N9XLloMCbcAroz0i84DCxb9RTPf1M,5214
+sectionise/core.py,sha256=o3znwH_oJUM9ZJNmYrQ4JVmJ5wOYUmYFCDVhbMUL2K4,13458
+sectionise-0.1.0.dist-info/METADATA,sha256=2QenkoDpEDoN7vP6o49n3swAwCZYl5xWSNTME4DfC30,4740
+sectionise-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+sectionise-0.1.0.dist-info/entry_points.txt,sha256=nucBwiJ1zfWLzS4nO5yjPstuC67PbPjc8uN2eXVm_oQ,51
+sectionise-0.1.0.dist-info/licenses/LICENSE,sha256=DgHBfjd2VifqW82gIJBB0calAMjf5mEtxQGyptIpEfw,1073
+sectionise-0.1.0.dist-info/RECORD,,

sectionise-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sectionise-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sectionise = sectionise.cli:main

sectionise-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mitchell Needham
+
+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.