dukatools 0.1.0__tar.gz

dukatools-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.dist/
+dist/
+build/
+*.egg-info/
+.venv/

dukatools-0.1.0/DEV.md

@@ -0,0 +1,14 @@
+# Developer Guide
+
+## Add a new CLI
+1) Create file: src/dukatools/<tool>.py with `def main(): ...`
+2) Register entry point in pyproject.toml under [project.scripts]: `<tool> = "dukatools.<tool>:main"`
+3) Bump version in pyproject.toml (e.g., 0.1.0 -> 0.2.0)
+4) Build & test locally
+5) Tag & push to GitHub (CI will publish to PyPI)
+
+## Local build & test
+python -m pip install -U build twine
+python -m build
+pipx install dist/dukatools-<ver>-py3-none-any.whl
+treex --help

dukatools-0.1.0/LICENSE

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

dukatools-0.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: dukatools
+Version: 0.1.0
+Summary: Small cross-platform CLI toolbelt: treex, dirproc, and more.
+Project-URL: Homepage, https://github.com/<your-user>/dukatools
+Project-URL: Issues, https://github.com/<your-user>/dukatools/issues
+Author: rexologue
+License: MIT
+License-File: LICENSE
+Keywords: cli,filesystem,tree,utilities
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# dukatools
+
+Cross-platform CLI toolbelt.
+
+## Install
+uv tool install dukatools
+
+## Upgrade
+uv tool upgrade dukatools
+
+## Commands
+- treex — enhanced directory tree
+- dirproc — directory batch processor
+
+## Usage
+treex --help
+dirproc --help

dukatools-0.1.0/README.md

@@ -0,0 +1,17 @@
+# dukatools
+
+Cross-platform CLI toolbelt.
+
+## Install
+uv tool install dukatools
+
+## Upgrade
+uv tool upgrade dukatools
+
+## Commands
+- treex — enhanced directory tree
+- dirproc — directory batch processor
+
+## Usage
+treex --help
+dirproc --help

dukatools-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dukatools"
+version = "0.1.0"
+description = "Small cross-platform CLI toolbelt: treex, dirproc, and more."
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [{name = "rexologue"}]
+keywords = ["cli", "utilities", "filesystem", "tree"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+# Здесь «магия» команд:
+[project.scripts]
+treex = "dukatools.treex:main"
+dirproc = "dukatools.dirproc:main"
+
+[project.urls]
+Homepage = "https://github.com/<your-user>/dukatools"
+Issues = "https://github.com/<your-user>/dukatools/issues"

dukatools-0.1.0/src/dukatools/__init__.py

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

dukatools-0.1.0/src/dukatools/dirproc.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+import os
+import re
+import fnmatch  # не используется, но оставлю на случай расширений
+import chardet
+from pathlib import Path
+from argparse import ArgumentParser, Namespace
+from typing import Iterable, List, Set, Optional
+
+
+def detect_encoding(file_path: str) -> str:
+    with open(file_path, "rb") as file:
+        raw_data = file.read()
+        result = chardet.detect(raw_data)
+        return result.get("encoding") or "latin1"
+
+
+def compile_patterns(patterns: Iterable[str]) -> List[re.Pattern]:
+    compiled = []
+    for pat in patterns:
+        try:
+            compiled.append(re.compile(pat))
+        except re.error as e:
+            raise SystemExit(f"Invalid regex in --exclude-pattern: {pat!r} -> {e}")
+    return compiled
+
+
+def should_exclude(path: Path, rel_posix: str, exclude_names: Set[str], exclude_regex: List[re.Pattern]) -> bool:
+    # Точное совпадение имени (базовое имя, без пути)
+    if path.name in exclude_names:
+        return True
+
+    # Соответствие любому из regex по относительному POSIX-пути
+    for rx in exclude_regex:
+        if rx.search(rel_posix):
+            return True
+
+    return False
+
+
+def process_directory(
+    root_dir: Path,
+    current_rel: Path,
+    out_fh,  # текстовый файл или None (stdout)
+    recursive: bool,
+    exclude_names: Set[str],
+    exclude_regex: List[re.Pattern],
+) -> None:
+    base = root_dir / current_rel
+    try:
+        entries = list(os.scandir(base))
+    except FileNotFoundError:
+        msg = f"Path not found: {base}"
+        if out_fh:
+            print(msg, file=out_fh)
+        else:
+            print(msg)
+        return
+
+    for entry in entries:
+        p = Path(entry.path)
+        rel = current_rel / entry.name
+        rel_posix = rel.as_posix()
+
+        if should_exclude(p, rel_posix, exclude_names, exclude_regex):
+            # Если это директория — не заходим внутрь
+            continue
+
+        if entry.is_dir(follow_symlinks=False):
+            if recursive:
+                process_directory(root_dir, rel, out_fh, recursive, exclude_names, exclude_regex)
+        elif entry.is_file(follow_symlinks=False):
+            result = f"File: {rel_posix}\n\n"
+            try:
+                encoding = detect_encoding(str(p))
+                with open(p, "r", encoding=encoding, errors="replace") as f:
+                    content = f.read()
+                result += f"Content:\n{content}\n\n"
+            except Exception as e:
+                result += f"Error reading file {rel_posix}: {e}\n\n"
+
+            if out_fh:
+                out_fh.write(result)
+            else:
+                print(result)
+
+
+def main() -> None:
+    parser = ArgumentParser(description="Dump files of a directory; optionally save to a file. No auto-excludes.")
+    parser.add_argument("root_dir", type=str, help="Root directory to process.")
+    parser.add_argument("--output-file", type=str, default=None, help="Where to save output (UTF-8).")
+    parser.add_argument("-nR", "--non-recursive", action="store_true", help="Disable recursion.")
+    parser.add_argument(
+        "--exclude-name",
+        action="append",
+        default=[],
+        help="Exclude by exact base name (file or directory). Can be repeated.",
+    )
+    parser.add_argument(
+        "--exclude-pattern",
+        action="append",
+        default=[],
+        help="Exclude by regex applied to relative POSIX path. Can be repeated.",
+    )
+
+    args: Namespace = parser.parse_args()
+
+    root_dir = Path(args.root_dir).resolve()
+
+    # Собрать список паттернов (append -> может быть списком списков, нормализуем)
+    # Здесь action='append', так что это уже плоский список или None -> []
+    exclude_names: Set[str] = set(args.exclude_name or [])
+    exclude_regex: List[re.Pattern] = compile_patterns(args.exclude_pattern or [])
+
+    out_fh = None
+    try:
+        if args.output_file:
+            out_path = Path(args.output_file)
+            out_path.parent.mkdir(parents=True, exist_ok=True)
+            out_fh = open(out_path, "w", encoding="utf-8")
+
+        process_directory(
+            root_dir=root_dir,
+            current_rel=Path("."),
+            out_fh=out_fh,
+            recursive=not args.non_recursive,
+            exclude_names=exclude_names,
+            exclude_regex=exclude_regex,
+        )
+    finally:
+        if out_fh:
+            out_fh.close()
+
+
+if __name__ == "__main__":
+    main()

dukatools-0.1.0/src/dukatools/treex.py

@@ -0,0 +1,50 @@
+import os
+import fnmatch
+from argparse import ArgumentParser
+
+
+def print_tree(directory: str, prefix: str = "", exclude_names: list[str] | None = None, exclude_patterns: list[str] | None = None) -> None:
+    exclude_names = exclude_names or []
+    exclude_patterns = exclude_patterns or []
+
+    try:
+        entries = os.listdir(directory)
+    except PermissionError:
+        print(f"{prefix}└── [Permission denied]")
+        return
+
+    # Filter entries by exact names and glob patterns
+    filtered: list[str] = []
+    for e in entries:
+        if e in exclude_names:
+            continue
+        if any(fnmatch.fnmatch(e, pat) for pat in exclude_patterns):
+            continue
+        filtered.append(e)
+
+    filtered.sort()
+
+    for index, entry in enumerate(filtered):
+        full_path = os.path.join(directory, entry)
+        connector = "└── " if index == len(filtered) - 1 else "├── "
+        print(f"{prefix}{connector}{entry}")
+
+        if os.path.isdir(full_path):
+            new_prefix = "    " if index == len(filtered) - 1 else "│   "
+            print_tree(full_path, prefix + new_prefix, exclude_names, exclude_patterns)
+
+
+def main() -> None:
+    parser = ArgumentParser(description="Draw a directory in a tree format with exclusion patterns.")
+    parser.add_argument("--path", type=str, default=".", help="Path to directory to tree.")
+    parser.add_argument("--exclude", type=str, nargs="*", default=[], help="List of directory/file names to exclude (exact match).")
+    parser.add_argument("--exclude-pattern", type=str, nargs="*", default=[], help="List of glob patterns to exclude (e.g. __pycache__, *.egg-info)")
+    args = parser.parse_args()
+
+    print(f"Directory tree for: {args.path}")
+    if args.exclude:
+        print(f"Excluded names: {', '.join(args.exclude)}")
+    if args.exclude_pattern:
+        print(f"Excluded patterns: {', '.join(args.exclude_pattern)}")
+
+    print_tree(args.path, exclude_names=args.exclude, exclude_patterns=args.exclude_pattern)