prune-cli 0.1.1__tar.gz

prune_cli-0.1.1/LICENSE

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

prune_cli-0.1.1/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+include README.md
+recursive-include src/prune *.py
+recursive-include tests *.py

prune_cli-0.1.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: prune-cli
+Version: 0.1.1
+Summary: A CLI tool named prune for cleaning Python code
+Author-email: vincentdeneuf <0189vn@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/vincentdeneuf/prune-cli
+Project-URL: Repository, https://github.com/vincentdeneuf/prune-cli
+Project-URL: Issues, https://github.com/vincentdeneuf/prune-cli/issues
+Keywords: cli,code,formatting,refactor,ast,prune
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: libcst
+Dynamic: license-file
+
+# prune
+
+A CLI tool named prune for cleaning Python code.
+
+## Installation
+
+```bash
+pip install prune-cli
+```
+
+## Usage
+
+```bash
+prune <command> [options]
+```
+
+### Commands
+
+- `prune comments` - Remove comments from Python files
+- `prune prints` - Remove print statements from Python files  
+- `prune docstrings` - Remove docstrings from Python files
+- `prune asserts` - Remove assert statements from Python files
+- `prune logs` - Remove logging statements from Python files
+
+### Examples
+
+```bash
+# Remove all print statements
+prune prints
+
+# Remove inline comments only (preserve noqa, type:, pragma)
+prune comments --default
+
+# Remove all types of comments
+prune comments --all
+
+# Remove specific log levels
+prune logs --debug --info --error
+
+# Remove all log levels
+prune logs --all
+
+# Show per-file details (verbose is default)
+prune prints
+
+# Suppress per-file output
+prune prints --quiet
+```
+
+## Development
+
+This project uses a src-layout packaging structure.
+
+### Requirements
+
+- Python >= 3.11
+- LibCST
+
+## License
+
+MIT License

prune_cli-0.1.1/README.md

@@ -0,0 +1,61 @@
+# prune
+
+A CLI tool named prune for cleaning Python code.
+
+## Installation
+
+```bash
+pip install prune-cli
+```
+
+## Usage
+
+```bash
+prune <command> [options]
+```
+
+### Commands
+
+- `prune comments` - Remove comments from Python files
+- `prune prints` - Remove print statements from Python files  
+- `prune docstrings` - Remove docstrings from Python files
+- `prune asserts` - Remove assert statements from Python files
+- `prune logs` - Remove logging statements from Python files
+
+### Examples
+
+```bash
+# Remove all print statements
+prune prints
+
+# Remove inline comments only (preserve noqa, type:, pragma)
+prune comments --default
+
+# Remove all types of comments
+prune comments --all
+
+# Remove specific log levels
+prune logs --debug --info --error
+
+# Remove all log levels
+prune logs --all
+
+# Show per-file details (verbose is default)
+prune prints
+
+# Suppress per-file output
+prune prints --quiet
+```
+
+## Development
+
+This project uses a src-layout packaging structure.
+
+### Requirements
+
+- Python >= 3.11
+- LibCST
+
+## License
+
+MIT License

prune_cli-0.1.1/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "prune-cli"
+version = "0.1.1"
+description = "A CLI tool named prune for cleaning Python code"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+
+authors = [
+  { name = "vincentdeneuf", email = "0189vn@gmail.com" },
+]
+
+dependencies = [
+  "libcst",
+]
+
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Software Development :: Code Generators",
+]
+
+keywords = ["cli", "code", "formatting", "refactor", "ast", "prune"]
+
+[project.urls]
+Homepage = "https://github.com/vincentdeneuf/prune-cli"
+Repository = "https://github.com/vincentdeneuf/prune-cli"
+Issues = "https://github.com/vincentdeneuf/prune-cli/issues"
+
+[project.scripts]
+prune = "prune.main:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[dependency-groups]
+dev = [
+  "build>=1.4.0",
+  "ruff>=0.15.0",
+  "twine>=6.2.0",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]

prune_cli-0.1.1/setup.cfg

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

prune_cli-0.1.1/src/prune/__init__.py

@@ -0,0 +1 @@
+"""prune - A CLI tool for cleaning Python code."""

prune_cli-0.1.1/src/prune/main.py

@@ -0,0 +1,418 @@
+"""Main entry point for the prune CLI."""
+
+import argparse
+import os
+import sys
+
+import libcst as cst
+
+from prune.transformers import (
+    AssertRemover,
+    DocstringRemover,
+    HeaderCommentRemover,
+    InlineCommentRemover,
+    LeadingCommentRemover,
+    LogRemover,
+    PrintRemover,
+)
+
+
+def find_python_files(start_dir: str) -> list[str]:
+    """Recursively find all .py files, excluding specified directories."""
+    skip_dirs = {".git", ".venv", "venv", "__pycache__"}
+    python_files = []
+
+    for root, dirs, files in os.walk(start_dir):
+        # Remove skip directories from in-place traversal
+        dirs[:] = [d for d in dirs if d not in skip_dirs]
+
+        for file in files:
+            if file.endswith(".py"):
+                python_files.append(os.path.join(root, file))
+
+    return python_files
+
+
+def process_file(
+    file_path: str,
+    remove_prints: bool = False,
+    remove_comments: bool = False,
+    remove_docstrings: bool = False,
+    remove_asserts: bool = False,
+    remove_logs: bool = False,
+    comment_options: dict = None,
+    log_levels: set[str] = None,
+) -> tuple[int, int, int, int, int]:
+    """Process a single file and return counts of removed items."""
+    prints_removed = 0
+    comments_removed = 0
+    docstrings_removed = 0
+    asserts_removed = 0
+    logs_removed = 0
+
+    if comment_options is None:
+        comment_options = {}
+
+    try:
+        with open(file_path, encoding="utf-8") as f:
+            source_code = f.read()
+
+        module = cst.parse_module(source_code)
+
+        if remove_prints:
+            print_remover = PrintRemover()
+            module = module.visit(print_remover)
+            prints_removed = print_remover.removed_count
+
+        if remove_comments:
+            # Handle different comment removal options
+            if comment_options.get("all", False):
+                # Remove all types of comments
+                inline_remover = InlineCommentRemover(remove_all=True)
+                leading_remover = LeadingCommentRemover()
+                header_remover = HeaderCommentRemover()
+
+                module = module.visit(inline_remover)
+                comments_removed += inline_remover.removed_count
+
+                module = module.visit(leading_remover)
+                comments_removed += leading_remover.removed_count
+
+                module = module.visit(header_remover)
+                comments_removed += header_remover.removed_count
+            else:
+                # Handle individual comment types
+                if comment_options.get("inline", False):
+                    inline_remover = InlineCommentRemover(remove_all=True)
+                    module = module.visit(inline_remover)
+                    comments_removed += inline_remover.removed_count
+
+                if comment_options.get("leading", False):
+                    leading_remover = LeadingCommentRemover()
+                    module = module.visit(leading_remover)
+                    comments_removed += leading_remover.removed_count
+
+                if comment_options.get("header", False):
+                    header_remover = HeaderCommentRemover()
+                    module = module.visit(header_remover)
+                    comments_removed += header_remover.removed_count
+
+                if comment_options.get("default", False):
+                    inline_remover = InlineCommentRemover(remove_all=False)
+                    module = module.visit(inline_remover)
+                    comments_removed += inline_remover.removed_count
+
+        if remove_docstrings:
+            docstring_remover = DocstringRemover()
+            module = module.visit(docstring_remover)
+            docstrings_removed = docstring_remover.removed_count
+
+        if remove_asserts:
+            assert_remover = AssertRemover()
+            module = module.visit(assert_remover)
+            asserts_removed = assert_remover.removed_count
+
+        if remove_logs:
+            log_remover = LogRemover(log_levels)
+            module = module.visit(log_remover)
+            logs_removed = log_remover.removed_count
+
+        # Write back to file if any changes were made
+        if (
+            prints_removed > 0
+            or comments_removed > 0
+            or docstrings_removed > 0
+            or asserts_removed > 0
+            or logs_removed > 0
+        ):
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(module.code)
+
+    except Exception:
+        # Skip files that can't be parsed or written
+        pass
+
+    return (
+        prints_removed,
+        comments_removed,
+        docstrings_removed,
+        asserts_removed,
+        logs_removed,
+    )
+
+
+def main() -> int:
+    """Main entry point for the prune CLI."""
+    parser = argparse.ArgumentParser(
+        description="Remove print statements, comments, docstrings, asserts, and logs from Python files."
+    )
+    parser.add_argument(
+        "command",
+        choices=["comments", "prints", "docstrings", "asserts", "logs"],
+        help="What to remove",
+    )
+    parser.add_argument(
+        "--quiet",
+        "-q",
+        action="store_true",
+        help="Suppress per-file output (verbose is default)",
+    )
+
+    # Comment-specific options
+    parser.add_argument(
+        "--inline",
+        action="store_true",
+        help="Remove all inline comments, including noqa, type, pragma",
+    )
+    parser.add_argument(
+        "--leading", action="store_true", help="Remove standalone/full-line comments"
+    )
+    parser.add_argument(
+        "--header", action="store_true", help="Remove shebang & coding comments"
+    )
+    parser.add_argument(
+        "--default",
+        action="store_true",
+        help="Remove inline comments only (preserve noqa, type:, pragma)",
+    )
+
+    # Log-specific options
+    parser.add_argument("--trace", action="store_true", help="Remove trace level logs")
+    parser.add_argument("--debug", action="store_true", help="Remove debug level logs")
+    parser.add_argument("--info", action="store_true", help="Remove info level logs")
+    parser.add_argument(
+        "--warning", action="store_true", help="Remove warning level logs"
+    )
+    parser.add_argument(
+        "--success", action="store_true", help="Remove success level logs"
+    )
+    parser.add_argument("--error", action="store_true", help="Remove error level logs")
+    parser.add_argument(
+        "--exception", action="store_true", help="Remove exception level logs"
+    )
+    parser.add_argument(
+        "--critical", action="store_true", help="Remove critical level logs"
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Remove all types (for comments) or all log levels (for logs)",
+    )
+
+    args = parser.parse_args()
+
+    # Validate comment options
+    if args.command == "comments":
+        comment_flags = {
+            "inline": args.inline,
+            "leading": args.leading,
+            "header": args.header,
+            "default": args.default,
+            "all": args.all,
+        }
+
+        # Require at least one flag
+        if not any(comment_flags.values()):
+            print("Error: prune comments requires at least one flag")
+            print("Available flags:")
+            print(
+                "  --default   Remove inline comments only (preserve noqa, type:, pragma)"
+            )
+            print(
+                "  --inline    Remove all inline comments, including noqa, type, pragma"
+            )
+            print("  --leading   Remove standalone/full-line comments")
+            print("  --header    Remove shebang & coding comments")
+            print("  --all       Remove all types of comments")
+            return 1
+
+    # Validate log options
+    if args.command == "logs":
+        log_flags = {
+            "trace": args.trace,
+            "debug": args.debug,
+            "info": args.info,
+            "warning": args.warning,
+            "success": args.success,
+            "error": args.error,
+            "exception": args.exception,
+            "critical": args.critical,
+            "all": args.all,
+        }
+
+        # Require at least one flag
+        if not any(log_flags.values()):
+            print("Error: prune logs requires at least one flag")
+            print("Available flags:")
+            print("  --trace      Remove trace level logs")
+            print("  --debug      Remove debug level logs")
+            print("  --info       Remove info level logs")
+            print("  --warning    Remove warning level logs")
+            print("  --success    Remove success level logs")
+            print("  --error      Remove error level logs")
+            print("  --exception  Remove exception level logs")
+            print("  --critical   Remove critical level logs")
+            print("  --all        Remove all log levels")
+            return 1
+
+    # Determine what to remove
+    remove_prints = args.command == "prints"
+    remove_comments = args.command == "comments"
+    remove_docstrings = args.command == "docstrings"
+    remove_asserts = args.command == "asserts"
+    remove_logs = args.command == "logs"
+
+    # Build comment options
+    comment_options = {}
+    if remove_comments:
+        # If --all is specified, ignore other flags
+        if args.all:
+            comment_options["all"] = True
+        else:
+            if args.inline:
+                comment_options["inline"] = True
+            if args.leading:
+                comment_options["leading"] = True
+            if args.header:
+                comment_options["header"] = True
+            if args.default:
+                comment_options["default"] = True
+
+    # Build log levels
+    log_levels = None
+    if remove_logs:
+        log_flags = {
+            "trace": args.trace,
+            "debug": args.debug,
+            "info": args.info,
+            "warning": args.warning,
+            "success": args.success,
+            "error": args.error,
+            "exception": args.exception,
+            "critical": args.critical,
+            "all": args.all,
+        }
+
+        # If --all is specified, ignore other flags and use all log levels
+        if args.all:
+            log_levels = {
+                "trace",
+                "debug",
+                "info",
+                "warning",
+                "success",
+                "error",
+                "exception",
+                "critical",
+            }
+        # If any specific log level flags are specified, only remove those levels
+        elif any(log_flags.values()):
+            log_levels = {
+                level
+                for level, enabled in log_flags.items()
+                if enabled and level != "all"
+            }
+        # No need for default case since validation requires at least one flag
+
+    # Find all Python files
+    python_files = find_python_files(".")
+
+    total_prints_removed = 0
+    total_comments_removed = 0
+    total_docstrings_removed = 0
+    total_asserts_removed = 0
+    total_logs_removed = 0
+    files_with_prints = 0
+    files_with_comments = 0
+    files_with_docstrings = 0
+    files_with_asserts = 0
+    files_with_logs = 0
+
+    # Verbose is default, quiet mode suppresses per-file output
+    verbose_mode = not args.quiet
+
+    # Process each file
+    for file_path in python_files:
+        (
+            prints_removed,
+            comments_removed,
+            docstrings_removed,
+            asserts_removed,
+            logs_removed,
+        ) = process_file(
+            file_path,
+            remove_prints,
+            remove_comments,
+            remove_docstrings,
+            remove_asserts,
+            remove_logs,
+            comment_options,
+            log_levels,
+        )
+
+        if prints_removed > 0:
+            files_with_prints += 1
+            total_prints_removed += prints_removed
+            if verbose_mode:
+                relative_path = os.path.relpath(file_path, ".")
+                print(
+                    f"{prints_removed} prints removed\t\t\033[90m{relative_path}\033[0m"
+                )
+
+        if comments_removed > 0:
+            files_with_comments += 1
+            total_comments_removed += comments_removed
+            if verbose_mode:
+                relative_path = os.path.relpath(file_path, ".")
+                print(
+                    f"{comments_removed} comments removed\t\t\033[90m{relative_path}\033[0m"
+                )
+
+        if docstrings_removed > 0:
+            files_with_docstrings += 1
+            total_docstrings_removed += docstrings_removed
+            if verbose_mode:
+                relative_path = os.path.relpath(file_path, ".")
+                print(
+                    f"{docstrings_removed} docstrings removed\t\t\033[90m{relative_path}\033[0m"
+                )
+
+        if asserts_removed > 0:
+            files_with_asserts += 1
+            total_asserts_removed += asserts_removed
+            if verbose_mode:
+                relative_path = os.path.relpath(file_path, ".")
+                print(
+                    f"{asserts_removed} asserts removed\t\t\033[90m{relative_path}\033[0m"
+                )
+
+        if logs_removed > 0:
+            files_with_logs += 1
+            total_logs_removed += logs_removed
+            if verbose_mode:
+                relative_path = os.path.relpath(file_path, ".")
+                print(f"{logs_removed} logs removed\t\t\033[90m{relative_path}\033[0m")
+
+    # Print summary
+    if remove_prints:
+        print(f"{total_prints_removed} prints removed from {files_with_prints} files")
+    if remove_comments:
+        print(
+            f"{total_comments_removed} comments removed from {files_with_comments} files"
+        )
+    if remove_docstrings:
+        print(
+            f"{total_docstrings_removed} docstrings removed from {files_with_docstrings} files"
+        )
+    if remove_asserts:
+        print(
+            f"{total_asserts_removed} asserts removed from {files_with_asserts} files"
+        )
+    if remove_logs:
+        print(f"{total_logs_removed} logs removed from {files_with_logs} files")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

prune_cli-0.1.1/src/prune/transformers.py

@@ -0,0 +1,264 @@
+"""LibCST transformers for removing print statements and comments."""
+
+import libcst as cst
+from libcst import matchers as m
+
+
+def remove_statement_preserve_comments(
+    node: cst.SimpleStatementLine,
+) -> cst.FlattenSentinel:
+    """Remove a statement but move its leading comments forward."""
+    new_nodes: list[cst.CSTNode] = []
+
+    for line in node.leading_lines:
+        new_nodes.append(line)
+
+    return cst.FlattenSentinel(new_nodes)
+
+
+class PrintRemover(cst.CSTTransformer):
+    """Transformer to remove standalone print() statements."""
+
+    def __init__(self):
+        self.removed_count = 0
+
+    def leave_SimpleStatementLine(
+        self,
+        original_node: cst.SimpleStatementLine,
+        updated_node: cst.SimpleStatementLine,
+    ):
+        if (
+            len(updated_node.body) == 1
+            and isinstance(updated_node.body[0], cst.Expr)
+            and m.matches(
+                updated_node.body[0].value,
+                m.Call(func=m.Name("print")),
+            )
+        ):
+            self.removed_count += 1
+            return remove_statement_preserve_comments(original_node)
+
+        return updated_node
+
+
+class InlineCommentRemover(cst.CSTTransformer):
+    """Transformer to remove inline (trailing) comments only."""
+
+    def __init__(self, remove_all: bool = False):
+        self.removed_count = 0
+        self.remove_all = remove_all
+
+    def leave_TrailingWhitespace(
+        self,
+        original_node: cst.TrailingWhitespace,
+        updated_node: cst.TrailingWhitespace,
+    ) -> cst.TrailingWhitespace:
+        if updated_node.comment:
+            comment_text = updated_node.comment.value
+
+            if not self.remove_all and any(
+                keyword in comment_text for keyword in ["noqa", "type:", "pragma"]
+            ):
+                return updated_node
+
+            self.removed_count += 1
+            return updated_node.with_changes(comment=None)
+
+        return updated_node
+
+class LeadingCommentRemover(cst.CSTTransformer):
+    """Transformer to remove standalone leading comments everywhere."""
+
+    def __init__(self):
+        self.removed_count = 0
+
+    def _filter_leading_lines(
+        self,
+        lines: list[cst.EmptyLine],
+    ) -> list[cst.EmptyLine]:
+        new_lines: list[cst.EmptyLine] = []
+
+        for line in lines:
+            if line.comment:
+                self.removed_count += 1
+                continue
+            new_lines.append(line)
+
+        return new_lines
+
+
+    def leave_SimpleStatementLine(
+        self,
+        original_node: cst.SimpleStatementLine,
+        updated_node: cst.SimpleStatementLine,
+    ):
+        if not updated_node.leading_lines:
+            return updated_node
+
+        new_lines = self._filter_leading_lines(updated_node.leading_lines)
+        return updated_node.with_changes(leading_lines=new_lines)
+
+    def leave_FunctionDef(
+        self,
+        original_node: cst.FunctionDef,
+        updated_node: cst.FunctionDef,
+    ):
+        if not updated_node.leading_lines:
+            return updated_node
+
+        new_lines = self._filter_leading_lines(updated_node.leading_lines)
+        return updated_node.with_changes(leading_lines=new_lines)
+
+    def leave_ClassDef(
+        self,
+        original_node: cst.ClassDef,
+        updated_node: cst.ClassDef,
+    ):
+        if not updated_node.leading_lines:
+            return updated_node
+
+        new_lines = self._filter_leading_lines(updated_node.leading_lines)
+        return updated_node.with_changes(leading_lines=new_lines)
+
+class HeaderCommentRemover(cst.CSTTransformer):
+    """Transformer to remove shebang and coding comments."""
+
+    def __init__(self):
+        self.removed_count = 0
+
+    def leave_Module(
+        self,
+        original_node: cst.Module,
+        updated_node: cst.Module,
+    ) -> cst.Module:
+        if not updated_node.header:
+            return updated_node
+
+        new_header: list[cst.EmptyLine] = []
+
+        for line in updated_node.header:
+            if line.comment:
+                comment = line.comment.value.lower()
+
+                if (
+                    comment.startswith("#")
+                    or "coding" in comment
+                    or comment.startswith("# vim:")
+                ):
+                    self.removed_count += 1
+                    continue
+
+            new_header.append(line)
+
+        return updated_node.with_changes(header=new_header)
+
+
+class DocstringRemover(cst.CSTTransformer):
+    """Transformer to remove docstrings."""
+
+    def __init__(self):
+        self.removed_count = 0
+
+    def _strip_docstring(
+        self,
+        body: list[cst.BaseStatement],
+    ) -> list[cst.BaseStatement]:
+        if (
+            body
+            and isinstance(body[0], cst.SimpleStatementLine)
+            and len(body[0].body) == 1
+            and isinstance(body[0].body[0], cst.Expr)
+            and isinstance(body[0].body[0].value, cst.SimpleString)
+        ):
+            self.removed_count += 1
+            return body[1:]
+
+        return body
+
+    def leave_Module(
+        self,
+        original_node: cst.Module,
+        updated_node: cst.Module,
+    ) -> cst.Module:
+        return updated_node.with_changes(
+            body=self._strip_docstring(list(updated_node.body)),
+        )
+
+    def leave_ClassDef(
+        self,
+        original_node: cst.ClassDef,
+        updated_node: cst.ClassDef,
+    ) -> cst.ClassDef:
+        new_body = updated_node.body.with_changes(
+            body=self._strip_docstring(list(updated_node.body.body)),
+        )
+        return updated_node.with_changes(body=new_body)
+
+    def leave_FunctionDef(
+        self,
+        original_node: cst.FunctionDef,
+        updated_node: cst.FunctionDef,
+    ) -> cst.FunctionDef:
+        new_body = updated_node.body.with_changes(
+            body=self._strip_docstring(list(updated_node.body.body)),
+        )
+        return updated_node.with_changes(body=new_body)
+
+
+class AssertRemover(cst.CSTTransformer):
+    """Transformer to remove assert statements."""
+
+    def __init__(self):
+        self.removed_count = 0
+
+    def leave_SimpleStatementLine(
+        self,
+        original_node: cst.SimpleStatementLine,
+        updated_node: cst.SimpleStatementLine,
+    ):
+        if len(updated_node.body) == 1 and isinstance(updated_node.body[0], cst.Assert):
+            self.removed_count += 1
+            return remove_statement_preserve_comments(original_node)
+
+        return updated_node
+
+
+class LogRemover(cst.CSTTransformer):
+    """Transformer to remove logging statements."""
+
+    def __init__(self, log_levels: set[str] | None = None):
+        self.removed_count = 0
+        self.log_levels = log_levels or {
+            "trace",
+            "debug",
+            "info",
+            "warning",
+            "success",
+            "error",
+            "exception",
+            "critical",
+        }
+
+    def leave_SimpleStatementLine(
+        self,
+        original_node: cst.SimpleStatementLine,
+        updated_node: cst.SimpleStatementLine,
+    ):
+        if (
+            len(updated_node.body) == 1
+            and isinstance(updated_node.body[0], cst.Expr)
+            and isinstance(updated_node.body[0].value, cst.Call)
+            and isinstance(updated_node.body[0].value.func, cst.Attribute)
+        ):
+            attr = updated_node.body[0].value.func
+
+            if (
+                isinstance(attr.attr, cst.Name)
+                and attr.attr.value in self.log_levels
+                and isinstance(attr.value, cst.Name)
+                and attr.value.value in {"log", "logger", "logging"}
+            ):
+                self.removed_count += 1
+                return remove_statement_preserve_comments(original_node)
+
+        return updated_node

prune_cli-0.1.1/src/prune_cli.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: prune-cli
+Version: 0.1.1
+Summary: A CLI tool named prune for cleaning Python code
+Author-email: vincentdeneuf <0189vn@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/vincentdeneuf/prune-cli
+Project-URL: Repository, https://github.com/vincentdeneuf/prune-cli
+Project-URL: Issues, https://github.com/vincentdeneuf/prune-cli/issues
+Keywords: cli,code,formatting,refactor,ast,prune
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: libcst
+Dynamic: license-file
+
+# prune
+
+A CLI tool named prune for cleaning Python code.
+
+## Installation
+
+```bash
+pip install prune-cli
+```
+
+## Usage
+
+```bash
+prune <command> [options]
+```
+
+### Commands
+
+- `prune comments` - Remove comments from Python files
+- `prune prints` - Remove print statements from Python files  
+- `prune docstrings` - Remove docstrings from Python files
+- `prune asserts` - Remove assert statements from Python files
+- `prune logs` - Remove logging statements from Python files
+
+### Examples
+
+```bash
+# Remove all print statements
+prune prints
+
+# Remove inline comments only (preserve noqa, type:, pragma)
+prune comments --default
+
+# Remove all types of comments
+prune comments --all
+
+# Remove specific log levels
+prune logs --debug --info --error
+
+# Remove all log levels
+prune logs --all
+
+# Show per-file details (verbose is default)
+prune prints
+
+# Suppress per-file output
+prune prints --quiet
+```
+
+## Development
+
+This project uses a src-layout packaging structure.
+
+### Requirements
+
+- Python >= 3.11
+- LibCST
+
+## License
+
+MIT License

prune_cli-0.1.1/src/prune_cli.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/prune/__init__.py
+src/prune/main.py
+src/prune/transformers.py
+src/prune_cli.egg-info/PKG-INFO
+src/prune_cli.egg-info/SOURCES.txt
+src/prune_cli.egg-info/dependency_links.txt
+src/prune_cli.egg-info/entry_points.txt
+src/prune_cli.egg-info/requires.txt
+src/prune_cli.egg-info/top_level.txt
+tests/__init__.py
+tests/test.py
+tests/test_copy.py
+tests/.venv/Lib/site-packages/_virtualenv.py
+tests/.venv/Scripts/activate_this.py

prune_cli-0.1.1/src/prune_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

prune_cli-0.1.1/src/prune_cli.egg-info/entry_points.txt

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

prune_cli-0.1.1/src/prune_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+libcst

prune_cli-0.1.1/src/prune_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+prune

prune_cli-0.1.1/tests/.venv/Lib/site-packages/_virtualenv.py

@@ -0,0 +1,101 @@
+"""Patches that are applied at runtime to the virtual environment."""
+
+import os
+import sys
+
+VIRTUALENV_PATCH_FILE = os.path.join(__file__)
+
+
+def patch_dist(dist):
+    """
+    Distutils allows user to configure some arguments via a configuration file:
+    https://docs.python.org/3.11/install/index.html#distutils-configuration-files.
+
+    Some of this arguments though don't make sense in context of the virtual environment files, let's fix them up.
+    """  # noqa: D205
+    # we cannot allow some install config as that would get packages installed outside of the virtual environment
+    old_parse_config_files = dist.Distribution.parse_config_files
+
+    def parse_config_files(self, *args, **kwargs):
+        result = old_parse_config_files(self, *args, **kwargs)
+        install = self.get_option_dict("install")
+
+        if "prefix" in install:  # the prefix governs where to install the libraries
+            install["prefix"] = VIRTUALENV_PATCH_FILE, os.path.abspath(sys.prefix)
+        for base in ("purelib", "platlib", "headers", "scripts", "data"):
+            key = f"install_{base}"
+            if key in install:  # do not allow global configs to hijack venv paths
+                install.pop(key, None)
+        return result
+
+    dist.Distribution.parse_config_files = parse_config_files
+
+
+# Import hook that patches some modules to ignore configuration values that break package installation in case
+# of virtual environments.
+_DISTUTILS_PATCH = "distutils.dist", "setuptools.dist"
+# https://docs.python.org/3/library/importlib.html#setting-up-an-importer
+
+
+class _Finder:
+    """A meta path finder that allows patching the imported distutils modules."""
+
+    fullname = None
+
+    # lock[0] is threading.Lock(), but initialized lazily to avoid importing threading very early at startup,
+    # because there are gevent-based applications that need to be first to import threading by themselves.
+    # See https://github.com/pypa/virtualenv/issues/1895 for details.
+    lock = []  # noqa: RUF012
+
+    def find_spec(self, fullname, path, target=None):  # noqa: ARG002
+        if fullname in _DISTUTILS_PATCH and self.fullname is None:
+            # initialize lock[0] lazily
+            if len(self.lock) == 0:
+                import threading
+
+                lock = threading.Lock()
+                # there is possibility that two threads T1 and T2 are simultaneously running into find_spec,
+                # observing .lock as empty, and further going into hereby initialization. However due to the GIL,
+                # list.append() operation is atomic and this way only one of the threads will "win" to put the lock
+                # - that every thread will use - into .lock[0].
+                # https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe
+                self.lock.append(lock)
+
+            from functools import partial
+            from importlib.util import find_spec
+
+            with self.lock[0]:
+                self.fullname = fullname
+                try:
+                    spec = find_spec(fullname, path)
+                    if spec is not None:
+                        # https://www.python.org/dev/peps/pep-0451/#how-loading-will-work
+                        is_new_api = hasattr(spec.loader, "exec_module")
+                        func_name = "exec_module" if is_new_api else "load_module"
+                        old = getattr(spec.loader, func_name)
+                        func = self.exec_module if is_new_api else self.load_module
+                        if old is not func:
+                            try:  # noqa: SIM105
+                                setattr(spec.loader, func_name, partial(func, old))
+                            except AttributeError:
+                                pass  # C-Extension loaders are r/o such as zipimporter with <3.7
+                        return spec
+                finally:
+                    self.fullname = None
+        return None
+
+    @staticmethod
+    def exec_module(old, module):
+        old(module)
+        if module.__name__ in _DISTUTILS_PATCH:
+            patch_dist(module)
+
+    @staticmethod
+    def load_module(old, name):
+        module = old(name)
+        if module.__name__ in _DISTUTILS_PATCH:
+            patch_dist(module)
+        return module
+
+
+sys.meta_path.insert(0, _Finder())

prune_cli-0.1.1/tests/.venv/Scripts/activate_this.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# 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.
+
+"""
+Activate virtualenv for current interpreter:
+
+import runpy
+runpy.run_path(this_file)
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError as exc:
+    msg = "You must use import runpy; runpy.run_path(this_file)"
+    raise AssertionError(msg) from exc
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len("Scripts") - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)])
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+os.environ["VIRTUAL_ENV_PROMPT"] = "tests" or os.path.basename(base)  # noqa: SIM222
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in "..\\Lib\\site-packages".split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

prune_cli-0.1.1/tests/__init__.py

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

prune_cli-0.1.1/tests/test.py

@@ -0,0 +1,41 @@
+
+"""This is a module docstring that should be removed with tidy docstrings."""
+import logging
+logging.basicConfig(level=logging.DEBUG)
+class LoggerWrapper:
+    def __init__(self, logger: logging.Logger) -> None:
+        self.logger = logger
+    def trace(self, message: str) -> None:
+        self.logger.debug(message)
+    def success(self, message: str) -> None:
+        self.logger.info(message)
+    def info(self, message: str) -> None:
+        self.logger.info(message)
+    def warning(self, message: str) -> None:
+        self.logger.warning(message)
+    def exception(self, message: str) -> None:
+        self.logger.exception(message)
+    def critical(self, message: str) -> None:
+        self.logger.critical(message)
+log = LoggerWrapper(logging.getLogger("log"))
+logger = logging.getLogger(__name__)
+custom_logger = logging.getLogger("custom")
+class DummyObject:
+    def print(self, message: str) -> None:
+        pass
+obj = DummyObject()
+def example_function():
+    """This is a function docstring that should be removed with tidy docstrings."""
+    x = 5  
+    y = 10  
+    z = 15  
+    x = logger.info("This should not be removed")
+    logger.debug("This should not be removed").strip()
+    custom_logger.info("This should not be removed")
+    obj.print("This should not be removed")  
+    return x + y + z
+class ExampleClass:
+    """This is a class docstring that should be removed with tidy docstrings."""
+    def method(self):
+        """This is a method docstring that should be removed with tidy docstrings."""
+        return 42

prune_cli-0.1.1/tests/test_copy.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3 -> should be removed with --header
+# This is a leading comment that should be removed with --leading
+# This is a leading comment that should be removed with --leading
+
+# This is another leading comment that should be removed with --leading
+
+"""This is a module docstring that should be removed with tidy docstrings."""
+
+import logging
+
+# Configure basic logging
+logging.basicConfig(level=logging.DEBUG)
+
+
+# Custom logger wrapper to support trace and success
+class LoggerWrapper:
+    def __init__(self, logger: logging.Logger) -> None:
+        self.logger = logger
+
+    def trace(self, message: str) -> None:
+        self.logger.debug(message)
+
+    def success(self, message: str) -> None:
+        self.logger.info(message)
+
+    def info(self, message: str) -> None:
+        self.logger.info(message)
+
+    def warning(self, message: str) -> None:
+        self.logger.warning(message)
+
+    def exception(self, message: str) -> None:
+        self.logger.exception(message)
+
+    def critical(self, message: str) -> None:
+        self.logger.critical(message)
+
+
+log = LoggerWrapper(logging.getLogger("log"))
+logger = logging.getLogger(__name__)
+custom_logger = logging.getLogger("custom")
+
+
+# Define an object with a print method, as used later
+class DummyObject:
+    def print(self, message: str) -> None:
+        pass
+
+
+obj = DummyObject()
+
+
+# This is a leading comment that should be removed with --leading
+def example_function():
+    """This is a function docstring that should be removed with tidy docstrings."""
+    print(
+        "This should be removed with tidy prints"
+    )  # This inline comment should be removed with tidy comments
+    x = 5  # type: int  # This comment should be preserved by default, removed with --inline
+    y = 10  # noqa: E501  # This comment should be preserved by default, removed with --inline
+    z = 15  # pragma: no cover  # This comment should be preserved by default, removed with --inline
+
+    # This is another type of leading comment that should be removed with --leading
+    assert x > 0, (
+        "x must be positive"
+    )  # This assert should be removed with tidy asserts
+    assert y is not None  # This assert should be removed with tidy asserts
+
+    # This is another type of leading comment that should be removed with --leading
+
+    log.trace("This is a trace log")
+    log.info("This is an info log")
+    log.warning("This is a warning log")
+    log.success("This is a success log")
+    log.exception("This is an exception log")
+    log.critical("This is a critical log")
+    # This is yet another type of leading comment that should be removed with --leading
+
+    # More logging with different base names
+    logger.info("Logger info message")
+    logging.warning("Logging warning message")
+
+    # These should NOT be removed (not standalone expressions)
+    x = logger.info("This should not be removed")
+    logger.debug("This should not be removed").strip()
+    custom_logger.info("This should not be removed")
+
+    print("Another print to remove")
+    obj.print("This should not be removed")  # This comment should be removed
+
+    return x + y + z
+
+
+class ExampleClass:
+    """This is a class docstring that should be removed with tidy docstrings."""
+
+    def method(self):
+        """This is a method docstring that should be removed with tidy docstrings."""
+        assert True  # This assert should be removed with tidy asserts
+
+        # Logging in method
+        log.info("Method log message")
+
+        return 42
+
+
+# Another leading comment
+print("Third print to remove")  # Final inline comment to remove
+
+# Another leading comment