crackerjack 0.11.4__py3-none-any.whl → 0.12.0__py3-none-any.whl

crackerjack/.gitignore

@@ -13,3 +13,5 @@
 /*.pyc
 /.crackerjack.yaml
 /scratch/
+
+.qodo

crackerjack/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pdm-project/pdm
-    rev: 2.22.3  # a PDM release exposing the hook
+    rev: 2.22.4  # a PDM release exposing the hook
     hooks:
       - id: pdm-lock-check
   - repo: https://github.com/pre-commit/pre-commit-hooks
@@ -17,7 +17,7 @@ repos:
       - id: check-added-large-files
         name: check-added-large-files
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.9
+    rev: v0.9.10
     hooks:
       - id: ruff-format
       - id: ruff
@@ -69,7 +69,7 @@ repos:
     hooks:
       - id: pyright
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.9
+    rev: v0.9.10
     hooks:
       - id: ruff
       - id: ruff-format

crackerjack/.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

crackerjack/.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

crackerjack/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

crackerjack/.pytest_cache/v/cache/nodeids

@@ -0,0 +1 @@
+[]

crackerjack/.pytest_cache/v/cache/stepwise

@@ -0,0 +1 @@
+[]

crackerjack/__init__.py

@@ -1,7 +1,4 @@
 from typing import Sequence
+from .crackerjack import Crackerjack, crackerjack_it
 
-from .crackerjack import crackerjack_it
-
-__all__: Sequence[str] = [
-    "crackerjack_it",
-]
+__all__: Sequence[str] = ["crackerjack_it", "Crackerjack"]

crackerjack/__main__.py

@@ -1,64 +1,119 @@
 import typing as t
-
-from click import command, help_option, option
-from pydantic import BaseModel
+from enum import Enum
+import typer
+from pydantic import BaseModel, field_validator
+from rich.console import Console
 from crackerjack import crackerjack_it
 
+console = Console(force_terminal=True)
+app = typer.Typer(
+    help="Crackerjack: Your Python project setup and style enforcement tool."
+)
+
+
+class BumpOption(str, Enum):
+    micro = "micro"
+    minor = "minor"
+    major = "major"
+
+    def __str__(self) -> str:
+        return self.value
+
 
 class Options(BaseModel):
     commit: bool = False
     interactive: bool = False
     doc: bool = False
-    do_not_update_configs: bool = False
-    publish: t.Literal["micro", "minor", "major"] | bool = False
-    bump: t.Literal["micro", "minor", "major"] | bool = False
+    no_config_updates: bool = False
+    publish: t.Optional[BumpOption] = None
+    bump: t.Optional[BumpOption] = None
     verbose: bool = False
     update_precommit: bool = False
+    clean: bool = False
+    test: bool = False
+
+    @classmethod
+    @field_validator("publish", "bump", mode="before")
+    def validate_bump_options(cls, value: t.Optional[str]) -> t.Optional[BumpOption]:
+        if value is None:
+            return None
+        try:
+            return BumpOption(value.lower())
+        except ValueError:
+            valid_options = ", ".join([o.value for o in BumpOption])
+            raise ValueError(
+                f"Invalid bump option: {value}. Must be one of: {valid_options}"
+            )
+
+
+cli_options = {
+    "commit": typer.Option(False, "-c", "--commit", help="Commit changes to Git."),
+    "interactive": typer.Option(
+        False, "-i", "--interactive", help="Run pre-commit hooks interactively."
+    ),
+    "doc": typer.Option(False, "-d", "--doc", help="Generate documentation."),
+    "no_config_updates": typer.Option(
+        False, "-n", "--no-config-updates", help="Do not update configuration files."
+    ),
+    "update_precommit": typer.Option(
+        False, "-u", "--update-precommit", help="Update pre-commit hooks."
+    ),
+    "verbose": typer.Option(False, "-v", "--verbose", help="Enable verbose output."),
+    "publish": typer.Option(
+        None,
+        "-p",
+        "--publish",
+        help="Bump version and publish to PyPI (micro, minor, major).",
+        case_sensitive=False,
+    ),
+    "bump": typer.Option(
+        None,
+        "-b",
+        "--bump",
+        help="Bump version (micro, minor, major).",
+        case_sensitive=False,
+    ),
+    "clean": typer.Option(
+        False,
+        "-x",
+        "--clean",
+        help="Remove docstrings, line comments, and unnecessary whitespace.",
+    ),
+    "test": typer.Option(False, "-t", "--test", help="Run tests."),
+}
 
 
-options = Options()
+def create_options(**kwargs: t.Any) -> Options:
+    return Options(**kwargs)
 
 
-@command()
-@help_option("-h", is_flag=True, help="help")
-@option("-c", is_flag=True, help="commit")
-@option("-i", is_flag=True, help="interactive")
-@option("-d", is_flag=True, help="doc")
-@option("-x", is_flag=True, help="do not update configs")
-@option("-u", is_flag=True, help="update pre-commit")
-@option("-v", is_flag=True, help="verbose")
-@option("-p", help="bump version and publish: -p [micro, minor, major]")
-@option("-b", help="bump version: -b [micro, minor, major]")
-# @option("-f", help="format: -f [module]")
-def crackerjack(
-    c: bool = False,
-    i: bool = False,
-    d: bool = False,
-    u: bool = False,
-    v: bool = False,
-    x: bool = False,
-    p: str | bool = False,
-    b: str | bool = False,
+@app.command()
+def main(
+    commit: bool = cli_options["commit"],
+    interactive: bool = cli_options["interactive"],
+    doc: bool = cli_options["doc"],
+    no_config_updates: bool = cli_options["no_config_updates"],
+    update_precommit: bool = cli_options["update_precommit"],
+    verbose: bool = cli_options["verbose"],
+    publish: t.Optional[BumpOption] = cli_options["publish"],
+    bump: t.Optional[BumpOption] = cli_options["bump"],
+    clean: bool = cli_options["clean"],
+    test: bool = cli_options["test"],
 ) -> None:
-    if c:
-        options.commit = c
-    if i:
-        options.interactive = i
-    if d:
-        options.doc = d
-    if u:
-        options.update_precommit = u
-    if x:
-        options.do_not_update_configs = x
-    if p in ("micro", "minor", "major"):
-        options.publish = p
-    if b in ("micro", "minor", "major"):
-        options.bump = b
-    if v:
-        print("-v not currently implemented")
-        options.verbose = v
-    crackerjack_it(options=options)
+    options = create_options(
+        commit=commit,
+        interactive=interactive,
+        doc=doc,
+        no_config_updates=no_config_updates,
+        update_precommit=update_precommit,
+        verbose=verbose,
+        publish=publish,
+        bump=bump,
+        clean=clean,
+        test=test,
+    )
+    crackerjack_it(options)
 
 
 if __name__ == "__main__":
-    crackerjack()
+    app()

crackerjack/crackerjack.py

@@ -1,43 +1,190 @@
+import ast
 import re
+import subprocess
 import typing as t
+from contextlib import suppress
 from pathlib import Path
+from subprocess import CompletedProcess
 from subprocess import run as execute
 from tomllib import loads
-
 from pydantic import BaseModel
+from rich.console import Console
 from tomli_w import dumps
 
+config_files = (".gitignore", ".pre-commit-config.yaml", ".libcst.codemod.yaml")
+interactive_hooks = ("refurb", "bandit", "pyright")
+default_python_version = "3.13"
 
-class Crackerjack(BaseModel, arbitrary_types_allowed=True):
-    our_path: Path = Path(__file__).parent
-    pkg_path: Path = Path(Path.cwd())
-    pkg_dir: t.Optional[Path] = None
-    pkg_name: str = "crackerjack"
-    our_toml: t.Optional[dict[str, t.Any]] = None
-    pkg_toml: t.Optional[dict[str, t.Any]] = None
-    our_toml_path: t.Optional[Path] = None
-    pkg_toml_path: t.Optional[Path] = None
-    python_version: str = "3.13"
+
+class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
+    console: Console
+
+    def clean_files(self, pkg_dir: Path | None) -> None:
+        if pkg_dir is None:
+            return
+        for file_path in pkg_dir.rglob("*.py"):
+            if not str(file_path.parent).startswith("__"):
+                self.clean_file(file_path)
+        if pkg_dir.parent.joinpath("__pycache__").exists():
+            pkg_dir.parent.joinpath("__pycache__").rmdir()
+
+    def clean_file(self, file_path: Path) -> None:
+        try:
+            code = file_path.read_text()
+            code = self.remove_docstrings(code)
+            code = self.remove_line_comments(code)
+            code = self.remove_extra_whitespace(code)
+            code = self.reformat_code(code)
+            file_path.write_text(code)
+            print(f"Cleaned: {file_path}")
+        except Exception as e:
+            print(f"Error cleaning {file_path}: {e}")
+
+    def remove_docstrings(self, code: str) -> str:
+        tree = ast.parse(code)
+        for node in ast.walk(tree):
+            if isinstance(
+                node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Module)
+            ):
+                if ast.get_docstring(node):
+                    node.body = (
+                        node.body[1:]
+                        if isinstance(node.body[0], ast.Expr)
+                        else node.body
+                    )
+        return ast.unparse(tree)
+
+    def remove_line_comments(self, code: str) -> str:
+        lines = code.split("\n")
+        cleaned_lines = []
+        for line in lines:
+            comment_match = re.search("(?<!\\S)#(.*)", line)
+            if comment_match is None:
+                cleaned_lines.append(line)
+                continue
+            comment_start = comment_match.start()
+            code_part = line[:comment_start].rstrip()
+            comment = line[comment_start:].strip()
+            if code_part:
+                if re.match("^#(?: type: ignore| noqa)(.*)?$", comment):
+                    cleaned_lines.append(line)
+                else:
+                    cleaned_lines.append(code_part)
+        return "\n".join(cleaned_lines)
+
+    def remove_extra_whitespace(self, code: str) -> str:
+        lines = code.split("\n")
+        cleaned_lines = []
+        for i, line in enumerate(lines):
+            line = line.rstrip()
+            if i > 0 and (not line) and (not cleaned_lines[-1]):
+                continue
+            cleaned_lines.append(line)
+        return "\n".join(cleaned_lines)
+
+    def reformat_code(self, code: str) -> str:
+        try:
+            import tempfile
+
+            with tempfile.NamedTemporaryFile(
+                suffix=".py", mode="w+", delete=False
+            ) as temp:
+                temp_path = Path(temp.name)
+                temp_path.write_text(code)
+            try:
+                result = subprocess.run(
+                    ["ruff", "format", str(temp_path)],
+                    check=False,
+                    capture_output=True,
+                    text=True,
+                )
+                if result.returncode == 0:
+                    formatted_code = temp_path.read_text()
+                else:
+                    print(f"Ruff formatting failed: {result.stderr}")
+                    formatted_code = code
+            except Exception as e:
+                print(f"Error running Ruff: {e}")
+                formatted_code = code
+            finally:
+                with suppress(FileNotFoundError):
+                    temp_path.unlink()
+            return formatted_code
+        except Exception as e:
+            print(f"Error during reformatting: {e}")
+            return code
+
+
+class ConfigManager(BaseModel, arbitrary_types_allowed=True):
+    our_path: Path
+    pkg_path: Path
+    pkg_name: str
+    console: Console
+    our_toml_path: Path | None = None
+    pkg_toml_path: Path | None = None
+    python_version: str = default_python_version
+    dry_run: bool = False
+
+    def swap_package_name(self, value: list[str] | str) -> list[str] | str:
+        if isinstance(value, list):
+            value.remove("crackerjack")
+            value.append(self.pkg_name)
+        else:
+            value = value.replace("crackerjack", self.pkg_name)
+        return value
 
     def update_pyproject_configs(self) -> None:
+        self._setup_toml_paths()
+        if self._is_crackerjack_project():
+            self._handle_crackerjack_project()
+            return
+        our_toml_config = self._load_our_toml()
+        pkg_toml_config = self._load_pkg_toml()
+        self._ensure_required_sections(pkg_toml_config)
+        self._update_tool_settings(our_toml_config, pkg_toml_config)
+        self._update_python_version(our_toml_config, pkg_toml_config)
+        self._save_pkg_toml(pkg_toml_config)
+
+    def _setup_toml_paths(self) -> None:
         toml_file = "pyproject.toml"
         self.our_toml_path = self.our_path / toml_file
         self.pkg_toml_path = self.pkg_path / toml_file
-        if self.pkg_path.stem == "crackerjack":
+
+    def _is_crackerjack_project(self) -> bool:
+        return self.pkg_path.stem == "crackerjack"
+
+    def _handle_crackerjack_project(self) -> None:
+        if self.our_toml_path and self.pkg_toml_path:
             self.our_toml_path.write_text(self.pkg_toml_path.read_text())
-            return
-        our_toml_config: t.Any = loads(self.our_toml_path.read_text())
-        pkg_toml_config: t.Any = loads(self.pkg_toml_path.read_text())
+
+    def _load_our_toml(self) -> dict[str, t.Any]:
+        if self.our_toml_path:
+            return loads(self.our_toml_path.read_text())
+        return {}
+
+    def _load_pkg_toml(self) -> dict[str, t.Any]:
+        if self.pkg_toml_path:
+            return loads(self.pkg_toml_path.read_text())
+        return {}
+
+    def _ensure_required_sections(self, pkg_toml_config: dict[str, t.Any]) -> None:
         pkg_toml_config.setdefault("tool", {})
         pkg_toml_config.setdefault("project", {})
-        for tool, settings in our_toml_config["tool"].items():
+
+    def _update_tool_settings(
+        self, our_toml_config: dict[str, t.Any], pkg_toml_config: dict[str, t.Any]
+    ) -> None:
+        for tool, settings in our_toml_config.get("tool", {}).items():
             for setting, value in settings.items():
-                if isinstance(value, str | list) and "crackerjack" in value:
-                    if isinstance(value, list):
-                        value.remove("crackerjack")
-                        value.append(self.pkg_name)
-                    else:
-                        value = value.replace("crackerjack", self.pkg_name)
+                if isinstance(value, dict):
+                    for k, v in {
+                        x: self.swap_package_name(y)
+                        for x, y in value.items()
+                        if isinstance(y, (str, list)) and "crackerjack" in str(y)
+                    }.items():
+                        settings[setting][k] = v
+                elif isinstance(value, (str, list)) and "crackerjack" in str(value):
+                    value = self.swap_package_name(value)
                     settings[setting] = value
                 if setting in (
                     "exclude-deps",
@@ -49,20 +196,27 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
                     conf = pkg_toml_config["tool"].get(tool, {}).get(setting, [])
                     settings[setting] = list(set(conf + value))
             pkg_toml_config["tool"][tool] = settings
-        python_version_pattern = r"\s*W*(\d\.\d*)"
-        requires_python = our_toml_config["project"]["requires-python"]
+
+    def _update_python_version(
+        self, our_toml_config: dict[str, t.Any], pkg_toml_config: dict[str, t.Any]
+    ) -> None:
+        python_version_pattern = "\\s*W*(\\d\\.\\d*)"
+        requires_python = our_toml_config.get("project", {}).get("requires-python", "")
         classifiers = []
-        for classifier in pkg_toml_config["project"].get("classifiers", []):
+        for classifier in pkg_toml_config.get("project", {}).get("classifiers", []):
             classifier = re.sub(
                 python_version_pattern, f" {self.python_version}", classifier
             )
             classifiers.append(classifier)
         pkg_toml_config["project"]["classifiers"] = classifiers
-        pkg_toml_config["project"]["requires-python"] = requires_python
-        self.pkg_toml_path.write_text(dumps(pkg_toml_config))
+        if requires_python:
+            pkg_toml_config["project"]["requires-python"] = requires_python
+
+    def _save_pkg_toml(self, pkg_toml_config: dict[str, t.Any]) -> None:
+        if self.pkg_toml_path:
+            self.pkg_toml_path.write_text(dumps(pkg_toml_config))
 
     def copy_configs(self) -> None:
-        config_files = (".gitignore", ".pre-commit-config.yaml", ".libcst.codemod.yaml")
         for config in config_files:
             config_path = self.our_path / config
             pkg_config_path = self.pkg_path / config
@@ -72,90 +226,212 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
                 continue
             if config != ".gitignore":
                 pkg_config_path.write_text(
-                    (config_path.read_text()).replace("crackerjack", self.pkg_name)
+                    config_path.read_text().replace("crackerjack", self.pkg_name)
                 )
-            execute(["git", "add", config])
+            self.execute_command(["git", "add", config])
+
+    def execute_command(
+        self, cmd: list[str], **kwargs: t.Any
+    ) -> subprocess.CompletedProcess[str]:
+        if self.dry_run:
+            self.console.print(f"[yellow]Would run: {' '.join(cmd)}[/yellow]")
+            return CompletedProcess(cmd, 0, "", "")
+        return execute(cmd, **kwargs)
+
+
+class ProjectManager(BaseModel, arbitrary_types_allowed=True):
+    our_path: Path
+    pkg_path: Path
+    pkg_dir: Path | None = None
+    pkg_name: str = "crackerjack"
+    console: Console
+    code_cleaner: CodeCleaner
+    config_manager: ConfigManager
+    dry_run: bool = False
 
     def run_interactive(self, hook: str) -> None:
         success: bool = False
         while not success:
-            fail = execute(["pre-commit", "run", hook.lower(), "--all-files"])
+            fail = self.execute_command(
+                ["pre-commit", "run", hook.lower(), "--all-files"]
+            )
             if fail.returncode > 0:
                 retry = input(f"\n\n{hook.title()} failed. Retry? (y/N): ")
-                print()
+                self.console.print()
                 if retry.strip().lower() == "y":
                     continue
                 raise SystemExit(1)
             success = True
 
     def update_pkg_configs(self) -> None:
-        self.copy_configs()
-        installed_pkgs = execute(
-            ["pdm", "list", "--freeze"],
-            capture_output=True,
-            text=True,
+        self.config_manager.copy_configs()
+        installed_pkgs = self.execute_command(
+            ["pdm", "list", "--freeze"], capture_output=True, text=True
         ).stdout.splitlines()
         if not len([pkg for pkg in installed_pkgs if "pre-commit" in pkg]):
-            print("Initializing project...")
-            execute(["pdm", "self", "add", "keyring"])
-            execute(["pdm", "config", "python.use_uv", "true"])
-            execute(["git", "init"])
-            execute(["git", "branch", "-m", "main"])
-            execute(["git", "add", "pyproject.toml"])
-            execute(["git", "add", "pdm.lock"])
-            execute(["pre-commit", "install"])
-            execute(["git", "config", "advice.addIgnoredFile", "false"])
-        self.update_pyproject_configs()
+            self.console.print("Initializing project...")
+            self.execute_command(["pdm", "self", "add", "keyring"])
+            self.execute_command(["pdm", "config", "python.use_uv", "true"])
+            self.execute_command(["git", "init"])
+            self.execute_command(["git", "branch", "-m", "main"])
+            self.execute_command(["git", "add", "pyproject.toml"])
+            self.execute_command(["git", "add", "pdm.lock"])
+            self.execute_command(["pre-commit", "install"])
+            self.execute_command(["git", "config", "advice.addIgnoredFile", "false"])
+        self.config_manager.update_pyproject_configs()
 
     def run_pre_commit(self) -> None:
-        check_all = execute(["pre-commit", "run", "--all-files"])
+        self.console.print("\nRunning pre-commit hooks...\n")
+        check_all = self.execute_command(["pre-commit", "run", "--all-files"])
         if check_all.returncode > 0:
-            check_all = execute(["pre-commit", "run", "--all-files"])
+            check_all = self.execute_command(["pre-commit", "run", "--all-files"])
             if check_all.returncode > 0:
-                print("\n\nPre-commit failed. Please fix errors.\n")
+                self.console.print("\n\nPre-commit failed. Please fix errors.\n")
                 raise SystemExit(1)
 
-    def process(self, options: t.Any) -> None:
+    def execute_command(
+        self, cmd: list[str], **kwargs: t.Any
+    ) -> subprocess.CompletedProcess[str]:
+        if self.dry_run:
+            self.console.print(f"[yellow]Would run: {' '.join(cmd)}[/yellow]")
+            return CompletedProcess(cmd, 0, "", "")
+        return execute(cmd, **kwargs)
+
+
+class Crackerjack(BaseModel, arbitrary_types_allowed=True):
+    our_path: Path = Path(__file__).parent
+    pkg_path: Path = Path(Path.cwd())
+    pkg_dir: Path | None = None
+    pkg_name: str = "crackerjack"
+    python_version: str = default_python_version
+    console: Console = Console(force_terminal=True)
+    dry_run: bool = False
+    code_cleaner: CodeCleaner | None = None
+    config_manager: ConfigManager | None = None
+    project_manager: ProjectManager | None = None
+
+    def __init__(self, **data: t.Any) -> None:
+        super().__init__(**data)
+        self.code_cleaner = CodeCleaner(console=self.console)
+        self.config_manager = ConfigManager(
+            our_path=self.our_path,
+            pkg_path=self.pkg_path,
+            pkg_name=self.pkg_name,
+            console=self.console,
+            python_version=self.python_version,
+            dry_run=self.dry_run,
+        )
+        self.project_manager = ProjectManager(
+            our_path=self.our_path,
+            pkg_path=self.pkg_path,
+            pkg_dir=self.pkg_dir,
+            pkg_name=self.pkg_name,
+            console=self.console,
+            code_cleaner=self.code_cleaner,
+            config_manager=self.config_manager,
+            dry_run=self.dry_run,
+        )
+
+    def _setup_package(self) -> None:
         self.pkg_name = self.pkg_path.stem.lower().replace("-", "_")
         self.pkg_dir = self.pkg_path / self.pkg_name
         self.pkg_dir.mkdir(exist_ok=True)
-        print("\nCrackerjacking...\n")
-        if not options.do_not_update_configs:
-            self.update_pkg_configs()
-            execute(["pdm", "install"])
+        self.console.print("\nCrackerjacking...\n")
+        self.config_manager.pkg_name = self.pkg_name
+        self.project_manager.pkg_name = self.pkg_name
+        self.project_manager.pkg_dir = self.pkg_dir
+
+    def _update_project(self, options: t.Any) -> None:
+        if not options.no_config_updates:
+            self.project_manager.update_pkg_configs()
+            result: CompletedProcess[str] = self.execute_command(
+                ["pdm", "install"], capture_output=True, text=True
+            )
+            if result.returncode == 0:
+                self.console.print("PDM installed: ✅\n")
+            else:
+                self.console.print(
+                    "\n\n❌ PDM installation failed. Is PDM is installed? Run `pipx install pdm` and try again.\n\n"
+                )
+
+    def _update_precommit(self, options: t.Any) -> None:
         if self.pkg_path.stem == "crackerjack" and options.update_precommit:
-            execute(["pre-commit", "autoupdate"])
+            self.execute_command(["pre-commit", "autoupdate"])
+
+    def _run_interactive_hooks(self, options: t.Any) -> None:
         if options.interactive:
-            for hook in ("refurb", "bandit", "pyright"):
-                self.run_interactive(hook)
-        self.run_pre_commit()
+            for hook in interactive_hooks:
+                self.project_manager.run_interactive(hook)
+
+    def _clean_project(self, options: t.Any) -> None:
+        if options.clean:
+            if self.pkg_dir:
+                self.code_cleaner.clean_files(self.pkg_dir)
+            if self.pkg_path.stem == "crackerjack":
+                tests_dir = self.pkg_path / "tests"
+                if tests_dir.exists() and tests_dir.is_dir():
+                    self.console.print("\nCleaning tests directory...\n")
+                    self.code_cleaner.clean_files(tests_dir)
+
+    def _run_tests(self, options: t.Any) -> None:
+        if options.test:
+            self.console.print("\n\nRunning tests...\n")
+            result = self.execute_command(["pytest"], capture_output=True, text=True)
+            if result.stdout:
+                self.console.print(result.stdout)
+            if result.returncode > 0:
+                if result.stderr:
+                    self.console.print(result.stderr)
+                self.console.print("\n\n❌ Tests failed. Please fix errors.\n")
+                return
+            self.console.print("\n\n✅ Tests passed successfully!\n")
+
+    def _bump_version(self, options: t.Any) -> None:
         for option in (options.publish, options.bump):
             if option:
-                execute(["pdm", "bump", option])
+                self.execute_command(["pdm", "bump", option])
                 break
+
+    def _publish_project(self, options: t.Any) -> None:
         if options.publish:
-            build = execute(["pdm", "build"], capture_output=True, text=True)
-            print(build.stdout)
+            build = self.execute_command(
+                ["pdm", "build"], capture_output=True, text=True
+            )
+            self.console.print(build.stdout)
             if build.returncode > 0:
-                print(build.stderr)
-                print("\n\nBuild failed. Please fix errors.\n")
+                self.console.print(build.stderr)
+                self.console.print("\n\nBuild failed. Please fix errors.\n")
                 raise SystemExit(1)
-            execute(["pdm", "publish", "--no-build"])
+            self.execute_command(["pdm", "publish", "--no-build"])
+
+    def _commit_and_push(self, options: t.Any) -> None:
         if options.commit:
             commit_msg = input("\nCommit message: ")
-            execute(
-                [
-                    "git",
-                    "commit",
-                    "-m",
-                    commit_msg,
-                    "--no-verify",
-                    "--",
-                    ".",
-                ]
+            self.execute_command(
+                ["git", "commit", "-m", commit_msg, "--no-verify", "--", "."]
             )
-            execute(["git", "push", "origin", "main"])
-        print("\nCrackerjack complete!\n")
+            self.execute_command(["git", "push", "origin", "main"])
+
+    def execute_command(
+        self, cmd: list[str], **kwargs: t.Any
+    ) -> subprocess.CompletedProcess[str]:
+        if self.dry_run:
+            self.console.print(f"[yellow]Would run: {' '.join(cmd)}[/yellow]")
+            return CompletedProcess(cmd, 0, "", "")
+        return execute(cmd, **kwargs)
+
+    def process(self, options: t.Any) -> None:
+        self._setup_package()
+        self._update_project(options)
+        self._update_precommit(options)
+        self._run_interactive_hooks(options)
+        self._clean_project(options)
+        self.project_manager.run_pre_commit()
+        self._run_tests(options)
+        self._bump_version(options)
+        self._publish_project(options)
+        self._commit_and_push(options)
+        self.console.print("\nCrackerjack complete!\n")
 
 
 crackerjack_it = Crackerjack().process

crackerjack/pyproject.toml

@@ -49,8 +49,9 @@ max-complexity = 12
 convention = "google"
 
 [tool.vulture]
-min_confidence = 84
+min_confidence = 86
 paths = ["crackerjack",]
+ignore_names = ["cls"]
 
 [tool.creosote]
 paths = [
@@ -119,7 +120,7 @@ pythonPlatform = "Darwin"
 
 [project]
 name = "crackerjack"
-version = "0.11.3"
+version = "0.11.5"
 description = "Default template for PDM package"
 requires-python = ">=3.13"
 readme = "README.md"
@@ -145,18 +146,19 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "click>=8.1.8",
     "autotyping>=24.9.0",
     "pre-commit>=4.1.0",
     "pytest>=8.3.5",
     "pydantic>=2.10.6",
     "pdm-bump>=0.9.10",
-    "pdm>=2.22.3",
-    "uv>=0.6.4",
+    "pdm>=2.22.4",
+    "uv>=0.6.5",
     "pytest-cov>=6.0.0",
     "pytest-mock>=3.14.0",
     "tomli-w>=1.2.0",
     "pytest-asyncio>=0.25.3",
+    "rich>=13.9.4",
+    "typer>=0.15.2",
 ]
 authors = [
     { name = "lesleslie", email = "les@wedgwoodwebworks.com" },

crackerjack-0.12.0.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.1
+Name: crackerjack
+Version: 0.12.0
+Summary: Default template for PDM package
+Keywords: black,ruff,mypy,creosote,refurb
+Author-Email: lesleslie <les@wedgwoodwebworks.com>
+Maintainer-Email: lesleslie <les@wedgwoodwebworks.com>
+License: BSD-3-CLAUSE
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Typing :: Typed
+Project-URL: homepage, https://github.com/lesleslie/crackerjack
+Project-URL: documentation, https://github.com/lesleslie/crackerjack
+Project-URL: repository, https://github.com/lesleslie/crackerjack
+Requires-Python: >=3.13
+Requires-Dist: autotyping>=24.9.0
+Requires-Dist: pre-commit>=4.1.0
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: pdm-bump>=0.9.10
+Requires-Dist: pdm>=2.22.4
+Requires-Dist: uv>=0.6.5
+Requires-Dist: pytest-cov>=6.0.0
+Requires-Dist: pytest-mock>=3.14.0
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: pytest-asyncio>=0.25.3
+Requires-Dist: rich>=13.9.4
+Requires-Dist: typer>=0.15.2
+Description-Content-Type: text/markdown
+
+# Crackerjack: Elevate Your Python Development
+
+[![Code style: crackerjack](https://img.shields.io/badge/code%20style-crackerjack-000042)](https://github.com/lesleslie/crackerjack)
+[![Python Version](https://img.shields.io/badge/python-3.13-blue.svg)](https://www.python.org/downloads/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)
+[![pdm-managed](https://img.shields.io/badge/pdm-managed-blueviolet)](https://pdm.fming.dev)
+[![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+
+**Crackerjack** (`ˈkra-kər-ˌjak`): *a person or thing of marked excellence.*
+
+Crackerjack is an opinionated Python project management tool designed to help you create, maintain, and publish high-quality Python projects with ease. It combines best-in-class tools and a streamlined workflow to ensure code quality, consistency, and reliability.
+
+## The Crackerjack Philosophy
+
+Crackerjack is built on the following core principles:
+
+-   **Code Clarity:** Code should be easy to read, understand, and maintain.
+-   **Automation:** Tedious tasks should be automated, allowing developers to focus on solving problems.
+-   **Consistency:** Code style, formatting, and project structure should be consistent across projects.
+-   **Reliability:** Tests are essential, and code should be checked rigorously.
+-   **Tool Integration:** Leverage powerful existing tools instead of reinventing the wheel.
+- **Static Typing:** Static typing is essential for all development.
+
+## Key Features
+
+Crackerjack provides:
+
+-   **Effortless Project Setup:** Initializes new Python projects with a standard directory structure, `pyproject.toml`, and essential configuration files.
+-   **PDM Integration:** Manages dependencies and virtual environments using [PDM](https://pdm.fming.dev/) (with [uv](https://github.com/astral-sh/uv) enabled for speed).
+-   **Automated Code Cleaning:** Removes unnecessary docstrings, line comments, and trailing whitespace.
+-   **Consistent Code Formatting:** Enforces a consistent style using [Ruff](https://github.com/astral-sh/ruff), the lightning-fast Python linter and formatter.
+-   **Comprehensive Pre-commit Hooks:** Installs and manages a robust suite of pre-commit hooks to ensure code quality (see the "Pre-commit Hooks" section below).
+-   **Interactive Checks:** Supports interactive pre-commit hooks (like `refurb`, `bandit`, and `pyright`) to allow you to fix issues in real-time.
+-   **Built-in Testing:** Automatically runs tests using `pytest`.
+-   **Easy Version Bumping:** Provides commands to bump the project version (micro, minor, or major).
+-   **Simplified Publishing:** Automates publishing to PyPI via PDM.
+- **Commit and Push:** Commits and pushes your changes.
+
+## Pre-commit Hooks
+
+Crackerjack automatically installs and manages these pre-commit hooks:
+
+1.  **pdm-lock-check:** Ensures the `pdm.lock` file is up to date.
+2.  **Core pre-commit-hooks:** Essential hooks from [pre-commit-hooks](https://github.com/pre-commit/pre-commit-hooks) (e.g., `trailing-whitespace`, `end-of-file-fixer`).
+3.  **Ruff:** [Ruff](https://github.com/astral-sh/ruff) for linting, code formatting, and general code style enforcement.
+4.  **Vulture:** [Vulture](https://github.com/jendrikseipp/vulture) to identify dead code.
+5.  **Creosote:** [Creosote](https://github.com/fredrikaverpil/creosote) to detect unused dependencies.
+6.  **Flynt:** [Flynt](https://github.com/ikamensh/flynt/) for converting string formatting to f-strings.
+7.  **Codespell:** [Codespell](https://github.com/codespell-project/codespell) for correcting typos in the code.
+8.  **Autotyping:** [Autotyping](https://github.com/JelleZijlstra/autotyping) for adding type hints.
+9.  **Refurb:** [Refurb](https://github.com/dosisod/refurb) to suggest code improvements.
+10. **Bandit:** [Bandit](https://github.com/PyCQA/bandit) to identify potential security vulnerabilities.
+11. **Pyright:** [Pyright](https://github.com/RobertCraigie/pyright-python) for static type checking.
+12. **Ruff (again):** A final Ruff pass to ensure all changes comply with the enforced style.
+
+## The Crackerjack Style Guide
+
+Crackerjack projects adhere to these guidelines:
+
+-   **Static Typing:** Use type hints consistently throughout your code.
+-   **Explicit Naming:** Choose clear, descriptive names for classes, functions, variables, and other identifiers.
+-   **Markdown for Documentation:** Use Markdown (`.md`) for all documentation, including docstrings, READMEs, etc.
+-   **Pathlib:** Use `pathlib.Path` for handling file and directory paths instead of `os.path`.
+-   **Consistent Imports:** Use `import typing as t` for type hinting.
+-   **Constants and Config:** Do not use all-caps for constants or configuration settings.
+-   **Path Parameters:** Functions that handle file operations should accept `pathlib.Path` objects as parameters.
+-   **Dependency Management:** Use PDM for dependency management, package building, and publishing.
+-   **Testing:** Use pytest as your testing framework.
+-   **Python Version:** Crackerjack projects support the latest Python versions.
+-   **Clear Code:** Avoid overly complex code.
+-   **Modular:** Functions should do one thing well.
+
+## Installation
+
+1.  **Python:** Ensure you have Python 3.13 installed.
+2.  **PDM:** Install [PDM](https://pdm.fming.dev/) using `pipx`:
+
+    ```
+    pipx install pdm
+    ```
+
+3.  **Crackerjack:** Install Crackerjack and initialize in your project root using:
+    ```
+    pip install crackerjack
+    cd your_project_root
+    python -m crackerjack
+    ```
+
+## Usage
+
+Run Crackerjack from the root of your Python project using:
+
+    python -m crackerjack
+
+
+### Command-Line Options
+
+-   `-c`, `--commit`: Commit changes to Git.
+-   `-i`, `--interactive`: Run pre-commit hooks interactively when possible.
+-   `-n`, `--no-config-updates`: Skip updating configuration files (e.g., `pyproject.toml`).
+-   `-u`, `--update-precommit`: Update pre-commit hooks to the latest versions.
+-   `-v`, `--verbose`: Enable verbose output.
+-   `-p`, `--publish <micro|minor|major>`: Bump the project version and publish to PyPI using PDM.
+-   `-b`, `--bump <micro|minor|major>`: Bump the project version without publishing.
+-   `-x`, `--clean`: Clean code by removing docstrings, line comments, and extra whitespace.
+-   `-t`, `--test`: Run tests using `pytest`.
+-   `-h`, `--help`: Display help.
+
+### Example Workflows
+
+-   **Run checks, bump version, publish, then commit:**
+    ```
+    python -m crackerjack -p minor -c
+    ```
+
+-   **Clean code, run checks, run tests, then commit:**
+    ````
+    python -m crackerjack -c -x -t
+    ```
+
+-   **Run checks skipping config updates:**
+    ```
+    python -m crackerjack -n
+    ```
+
+-   **Bump the version and publish to PyPI:**
+    ```
+    python -m crackerjack -p micro
+    ```
+
+-   **Bump the version without publishing:**
+    ```
+    python -m crackerjack -b major
+    ```
+- **Update pre-commit hooks:**
+    ```
+    python -m crackerjack -u
+    ```
+- **Get help:**
+    ```
+    python -m crackerjack -h
+    ```
+
+## Contributing
+
+Crackerjack is an evolving project. Contributions are welcome! Please open a pull request or issue.
+
+To contribute:
+
+1. Add Crackerjack as a development dependency to your project:
+  ```
+  pdm add -G dev crackerjack
+  ```
+
+2. Run checks and tests before submitting:
+  ```
+  python -m crackerjack -x -t
+  ```
+
+This ensures your code meets all quality standards before submission.
+
+## License
+
+This project is licensed under the terms of the BSD 3-Clause license.
+
+## Acknowledgments
+
+-   **PDM:** For excellent dependency and virtual environment management.
+-   **Ruff:** For lightning-fast linting and code formatting.
+-   **pre-commit:** For the robust hook management system.
+-   **pytest:** For the flexible and powerful testing framework.
+-   **uv:** For greatly improving PDM speeds.
+- **bandit:** For finding security vulnerabilities.
+- **vulture:** for dead code detection.
+- **creosote:** For unused dependency detection.
+- **flynt:** For f-string conversion.
+- **codespell:** For spelling correction.
+- **autotyping:** For automatically adding type hints.
+- **refurb:** For code improvement suggestions.
+- **pyright:** For static type checking.
+- **Typer:** For the creation of the CLI.
+
+---

{crackerjack-0.11.4.dist-info → crackerjack-0.12.0.dist-info}/RECORD

@@ -1,11 +1,17 @@
-crackerjack-0.11.4.dist-info/METADATA,sha256=sscYWhgl7F0TpE_pcQqrLV_882tSTQEYM1ipKOwBPys,6322
-crackerjack-0.11.4.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-crackerjack-0.11.4.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-crackerjack-0.11.4.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
-crackerjack/.gitignore,sha256=7qePRaD8q-U6oV3gvgAcwFF8GudcRGAWf-Z-0IDqMaE,207
+crackerjack-0.12.0.dist-info/METADATA,sha256=WvBhT8kVf9gxBhKuM_yH4EwNdnuYGEpBEBKYIlptc8A,10289
+crackerjack-0.12.0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+crackerjack-0.12.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+crackerjack-0.12.0.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
+crackerjack/.coverage,sha256=dLzPzp72qZEXohNfxnOAlRwvM9dqF06-HoFqfvXZd1U,53248
+crackerjack/.gitignore,sha256=l8ErBAypC3rI6N9lhc7ZMdOw87t0Tz69ZW5C6uj15Wg,214
 crackerjack/.libcst.codemod.yaml,sha256=a8DlErRAIPV1nE6QlyXPAzTOgkB24_spl2E9hphuf5s,772
 crackerjack/.pdm.toml,sha256=dZe44HRcuxxCFESGG8SZIjmc-cGzSoyK3Hs6t4NYA8w,23
-crackerjack/.pre-commit-config.yaml,sha256=MdCTkavvr84yaP8B3DYuSjCfR_X4q3tpDO8yZAR5t9s,2265
+crackerjack/.pre-commit-config.yaml,sha256=cLIzulHerHmCHjo5UWA2JAMm5d5PjwGpIp5Lx-nL3FQ,2267
+crackerjack/.pytest_cache/.gitignore,sha256=Ptcxtl0GFQwTji2tsL4Gl1UIiKa0frjEXsya26i46b0,37
+crackerjack/.pytest_cache/CACHEDIR.TAG,sha256=N9yI75oKvt2-gQU6bdj9-xOvthMEXqHrSlyBWnSjveQ,191
+crackerjack/.pytest_cache/README.md,sha256=c_1vzN2ALEGaay2YPWwxc7fal1WKxLWJ7ewt_kQ9ua0,302
+crackerjack/.pytest_cache/v/cache/nodeids,sha256=T1PNoYwrqgwDVLtfmj7L5e0Sq02OEbqHPC8RFhICuUU,2
+crackerjack/.pytest_cache/v/cache/stepwise,sha256=T1PNoYwrqgwDVLtfmj7L5e0Sq02OEbqHPC8RFhICuUU,2
 crackerjack/.ruff_cache/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
 crackerjack/.ruff_cache/0.1.11/3256171999636029978,sha256=-RLDsRf5uj09SyFQVzjwQ1HkTxjIRxNLLE24SEJxD4g,248
 crackerjack/.ruff_cache/0.1.14/602324811142551221,sha256=HIYvldb69IHdMzquAA8JpzU2RDT9shEB_dPvzyeFZ_g,248
@@ -34,11 +40,13 @@ crackerjack/.ruff_cache/0.7.1/1024065805990144819,sha256=3Sww592NB0PWBNHU_UIqvqg
 crackerjack/.ruff_cache/0.7.1/285614542852677309,sha256=mOHKRzKoSvW-1sHtqI_LHWRt-mBinJ4rQRtp9Yqzv5I,224
 crackerjack/.ruff_cache/0.7.3/16061516852537040135,sha256=AWJR9gmaO7-wpv8mY1homuwI8CrMPI3VrnbXH-wRPlg,224
 crackerjack/.ruff_cache/0.8.4/16354268377385700367,sha256=Ksz4X8N6Z1i83N0vV1PxmBRlqgjrtzmDCOg7VBF4baQ,224
+crackerjack/.ruff_cache/0.9.10/12813592349865671909,sha256=c68BYIC0rNDH3TrWX-RKYI1gb7KGKAck8MOpwzySX7U,224
 crackerjack/.ruff_cache/0.9.3/13948373885254993391,sha256=kGhtIkzPUtKAgvlKs3D8j4QM4qG8RhsHrmQJI69Sv3o,224
-crackerjack/.ruff_cache/0.9.9/12813592349865671909,sha256=RfNLBMX23ATK_GzSmnPl0h8AsUG9sZU3GwPCsVHe2FU,224
+crackerjack/.ruff_cache/0.9.9/12813592349865671909,sha256=tmr8_vhRD2OxsVuMfbJPdT9fDFX-d5tfC5U9jgziyho,224
+crackerjack/.ruff_cache/0.9.9/8843823720003377982,sha256=e4ymkXfQsUg5e_mtO34xTsaTvs1uA3_fI216Qq9qCAM,136
 crackerjack/.ruff_cache/CACHEDIR.TAG,sha256=WVMVbX4MVkpCclExbq8m-IcOZIOuIZf5FrYw5Pk-Ma4,43
-crackerjack/__init__.py,sha256=AuglbbJHkUJ2GdvyT0ca35ntexo1RkT2V6DgypoFeEk,121
-crackerjack/__main__.py,sha256=3TrS-Hejbx315O558j3MI2L59VX0Y6t0tz5L41NTVG0,1738
-crackerjack/crackerjack.py,sha256=Aa5Mb0p63W2AG0rcYzU1H2iez-z42eGqDP3dWPRbh9A,6693
-crackerjack/pyproject.toml,sha256=DMmVRWWGE0KWuaO_DrGp8YhqheIiaZim9ArfoGH_waw,3398
-crackerjack-0.11.4.dist-info/RECORD,,
+crackerjack/__init__.py,sha256=EOKnIXfBAvxS55uPkpk5DbcNqVS29wja_IcCPaGwyus,141
+crackerjack/__main__.py,sha256=nraD_3T7XokPEniztNRxfh6hMCRS7ihRucQWswb7j9I,3485
+crackerjack/crackerjack.py,sha256=W7azMMGcZ5xZjthU6vIqHhXm0UAmENFSPJvb4pFaxjY,17401
+crackerjack/pyproject.toml,sha256=z5FPRNjNaa9_6cb4gnEOdRdjqAOKI57Lunk-E3F3ZeM,3442
+crackerjack-0.12.0.dist-info/RECORD,,

crackerjack-0.11.4.dist-info/METADATA

@@ -1,164 +0,0 @@
-Metadata-Version: 2.1
-Name: crackerjack
-Version: 0.11.4
-Summary: Default template for PDM package
-Keywords: black,ruff,mypy,creosote,refurb
-Author-Email: lesleslie <les@wedgwoodwebworks.com>
-Maintainer-Email: lesleslie <les@wedgwoodwebworks.com>
-License: BSD-3-CLAUSE
-Classifier: Environment :: Console
-Classifier: Operating System :: POSIX
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Development Status :: 4 - Beta
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Software Development :: Quality Assurance
-Classifier: Topic :: Software Development :: Testing
-Classifier: Topic :: Utilities
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Typing :: Typed
-Project-URL: homepage, https://github.com/lesleslie/crackerjack
-Project-URL: documentation, https://github.com/lesleslie/crackerjack
-Project-URL: repository, https://github.com/lesleslie/crackerjack
-Requires-Python: >=3.13
-Requires-Dist: click>=8.1.8
-Requires-Dist: autotyping>=24.9.0
-Requires-Dist: pre-commit>=4.1.0
-Requires-Dist: pytest>=8.3.5
-Requires-Dist: pydantic>=2.10.6
-Requires-Dist: pdm-bump>=0.9.10
-Requires-Dist: pdm>=2.22.3
-Requires-Dist: uv>=0.6.4
-Requires-Dist: pytest-cov>=6.0.0
-Requires-Dist: pytest-mock>=3.14.0
-Requires-Dist: tomli-w>=1.2.0
-Requires-Dist: pytest-asyncio>=0.25.3
-Description-Content-Type: text/markdown
-
-# Crackerjack Python
-
-[![Python: 3.13](https://img.shields.io/badge/python-3.13%2B-blue)](https://docs.python.org/3/)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
-[![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)
-[![pdm-managed](https://img.shields.io/badge/pdm-managed-blueviolet)](https://pdm.fming.dev)
-[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
-[![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
-[![Code style: crackerjack](https://img.shields.io/badge/code%20style-crackerjack-000042)](https://github.com/lesleslie/crackerjack)
-
-Crackerjack is a python coding style which uses a minimalist approach to produce elegant, easy to read, code.
-
-crack·​er·​jack ˈkra-kər-ˌjak
-: a person or thing of marked excellence
-
-### **Why Crackerjack?**
-
-Crackerjack works on the theory that with static typing and explicit class,
-function, variable, and other object names - the code should be
-straight forward to read. Documentation and tests should be able to write themselves using a generative ai.
-Crackerjack provides a set of guidelines and utilities to keep the codebase clean, elegant, standardized, and
-easily readable.
-
-### **What does this package do?**
-
-This package:
-
-- streamlines and standardizes code style across numerous packages
-
-- installs, or updates, a project's pre-commit tools as well as .gitignore & other config files
-  to comply with evolving crackerjack standards
-
-- runs the following pre-commit hooks (in order):
-  * [pdm-lock-check](https://github.com/pdm-project/pdm)
-  * various core [pre-commit-hooks](https://github.com/pre-commit/pre-commit-hooks)
-  * [ruff](https://github.com/charliermarsh/ruff-pre-commit)
-  * [vulture](https://github.com/jendrikseipp/vulture)
-  * [creosote](https://github.com/fredrikaverpil/creosote)
-  * [flynt](https://github.com/ikamensh/flynt/)
-  * [codespell](https://github.com/codespell-project/codespell)
-  * [autotyping](https://github.com/JelleZijlstra/autotyping)
-  * [refurb](https://github.com/dosisod/refurb)
-  * [bandit](https://github.com/PyCQA/bandit)
-  * [pyright](https://github.com/RobertCraigie/pyright-python)
-  * [ruff](https://github.com/charliermarsh/ruff-pre-commit) (again for sanity checking)
-
-- converts/creates documentation in Markdown (md) (work in progress)
-
-- runs tests and generates pytest mock stubs if needed (work in progress)
-
-- bumps the project version and publishes it to PyPI
-
-- commits changes to git repositories
-
-### **What are the rules?**
-
-(...more what you'd call "guidelines" than actual rules. -Captain Barbossa )
-
-- code is statically typed
-
-- all docstrings, README's, and other documentation is to be done in Markdown (md)
-
-- use aiopath.AsyncPath or pathlib.Path not os.path
-
-- import typing as t
-
-- do not capitalize all letters in configuration settings or constants (we diverge from PEP-8 here
- for not other reason than it looks ugly)
-
-- functions that deal with path operations should get passed AsyncPaths or Paths - not strings
-
-- use PDM (uv support enabled) for dependency management and package building/publishing
-
-- use pdoc and mkdocs for producing documentation
-
-- use pytest for testing
-
-- be compliant with, and only support, the latest python version within 2 months after release
-
-
-
-[//]: # (- variable docstrings are supported as outlined in)
-
-[//]: # (  [PEP-224]&#40;https://www.python.org/dev/peps/pep-0224/&#41; as well as the module-level)
-
-[//]: # (  __pdoc__ dictionary &#40;see [pdoc docs]&#40;)
-
-[//]: # (  https://pdoc3.github.io/pdoc/doc/pdoc/#overriding-docstrings-with-__pdoc__&#41;&#41;)
-
-
-### **Installation**
-
-From your projects root directory:
-
-```pdm add -d crackerjack```
-
-### **Usage**
-
-From your projects root directory:
-
-```python -m crackerjack```
-
-For a full list of options:
-
-```python -m crackerjack -h```
-
-When you ready to publish your project:
-
-``python -m crackerjack -p micro``
-
-The -p option not only publishes your project but will bump your
-project version for you. The options are 'micro', 'minor', and 'major'.
-Put the -c option at the end and commit the bumped version to your git
-repository at the same time:
-
-``python -m crackerjack -p micro -c``
-
-### **Contributing**
-
-Crackerjack is currently an evolving standard. If you like the idea, but don't like certain things about it, or
-would like new features added, let me know in Discussions, Issues, or email me.
-
-### **License**
-
-BSD-3-Clause