prune-cli 0.1.0__py3-none-any.whl

prune/__init__.py

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

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/transformers.py

@@ -0,0 +1,247 @@
+"""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/full-line 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.leading_lines:
+            return updated_node
+
+        new_lines: list[cst.EmptyLine] = []
+
+        for line in updated_node.leading_lines:
+            if isinstance(line, cst.EmptyLine) and line.comment:
+                self.removed_count += 1
+                continue
+            new_lines.append(line)
+
+        return updated_node.with_changes(leading_lines=new_lines)
+
+    def leave_EmptyLine(
+        self,
+        original_node: cst.EmptyLine,
+        updated_node: cst.EmptyLine,
+    ) -> cst.EmptyLine:
+        if updated_node.comment:
+            self.removed_count += 1
+            return updated_node.with_changes(comment=None)
+
+        return updated_node
+
+
+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.leading_lines:
+            return updated_node
+
+        new_lines: list[cst.EmptyLine] = []
+
+        for line in updated_node.leading_lines:
+            if isinstance(line, cst.EmptyLine) and line.comment:
+                comment_text = line.comment.value.strip().lower()
+
+                if (
+                    comment_text.startswith("#!")
+                    or "coding" in comment_text
+                    or comment_text.startswith("# vim:")
+                ):
+                    self.removed_count += 1
+                    continue
+
+            new_lines.append(line)
+
+        return updated_node.with_changes(leading_lines=new_lines)
+
+
+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.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: prune-cli
+Version: 0.1.0
+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.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+prune/__init__.py,sha256=FPNPkMGSrTJKVOzqLUPuXm_CANnYzFwVIL8Nwl5xa5c,52
+prune/main.py,sha256=Y1kKiB3TJELrXh5M3__9KHm5PRMVsaQtaKrhodkIn6Q,14499
+prune/transformers.py,sha256=Dk26A2ncWpcfeoLmongv6N0QFUFtdddOXj1Iygp84Zw,7466
+prune_cli-0.1.0.dist-info/licenses/LICENSE,sha256=XKKSDU9WlUEAyPNlRhq6e2xhVNpJc097JwPZJ1rUnRE,1077
+prune_cli-0.1.0.dist-info/METADATA,sha256=EiQ81nJ82PY6XOirfrL3cyvssJOMpND9W2QI5_Ava7o,2160
+prune_cli-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+prune_cli-0.1.0.dist-info/entry_points.txt,sha256=0P9nFJ9URKjgHQEiF61_2_Fb-MDj1wBLkYGQOPi4mD4,42
+prune_cli-0.1.0.dist-info/top_level.txt,sha256=pIjROT6gT2MV16IHIiJnaAFGhOcmcji6omu6LqwRfMQ,6
+prune_cli-0.1.0.dist-info/RECORD,,

prune_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

prune_cli-0.1.0.dist-info/entry_points.txt

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

prune_cli-0.1.0.dist-info/licenses/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.0.dist-info/top_level.txt

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