pyletree 1.0.0__py3-none-any.whl

pyletree/__init__.py

@@ -0,0 +1,5 @@
+'''Top-level package for Pyletree (based on RP Tree).'''
+
+__all__ = ['__version__']
+
+__version__ = '1.0.0'

pyletree/__main__.py

@@ -0,0 +1,48 @@
+'''Entry point for Pyletree CLI.'''
+
+import pathlib
+import sys
+
+from .cli import parse_cmd_line_arguments
+from .pyletree import DirectoryTree
+
+
+def main() -> None:
+    args = parse_cmd_line_arguments()
+    root_dir = pathlib.Path(args.root_dir).resolve()
+
+    if not root_dir.exists():
+        print(f'Error: directory not found: {root_dir}', file=sys.stderr)
+        sys.exit(1)
+
+    if not root_dir.is_dir():
+        print(f'Error: path is not a directory: {root_dir}', file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        tree = DirectoryTree(
+            root_dir=root_dir,
+            dir_only=args.dir_only,
+            files_only=args.files_only,
+            dirs_first=args.dirs_first,
+            files_first=args.files_first,
+            no_pipes=args.no_pipes,
+            ignore=args.ignore,
+            use_gitignore=args.gitignore,
+            depth_level=args.depth_level,
+            output_file=args.output_file,
+        )
+
+        tree.generate()
+
+    except KeyboardInterrupt:
+        print('\nOperation cancelled.', file=sys.stderr)
+        sys.exit(130)
+
+    except Exception as e:
+        print(f'Error: {e}', file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

pyletree/cli.py

@@ -0,0 +1,108 @@
+'''This module provides the Pyletree CLI.'''
+
+import argparse
+
+from . import __version__
+
+
+def parse_cmd_line_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog='pyletree',
+        description='Generate a directory tree',
+        epilog='Thanks for using Pyletree!',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    parser.add_argument(
+        '-v',
+        '--version',
+        action='version',
+        version=f'Pyletree v{__version__}',
+    )
+
+    parser.add_argument(
+        'root_dir',
+        metavar='ROOT_DIR',
+        nargs='?',
+        default='.',
+        help='root directory to generate the tree from',
+    )
+
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument(
+        '-d',
+        '--dir-only',
+        action='store_true',
+        help='show directories only',
+    )
+    mode.add_argument(
+        '-f',
+        '--files-only',
+        action='store_true',
+        help='show files only',
+    )
+
+    ordering = parser.add_mutually_exclusive_group()
+    ordering.add_argument(
+        '-df',
+        '--dirs-first',
+        action='store_true',
+        help='list directories before files',
+    )
+    ordering.add_argument(
+        '-ff',
+        '--files-first',
+        action='store_true',
+        help='list files before directories',
+    )
+
+    parser.add_argument(
+        '-n',
+        '--no-pipes',
+        action='store_true',
+        help='remove vertical pipes between branches',
+    )
+
+    parser.add_argument(
+        '-i',
+        '--ignore',
+        metavar='PATTERN',
+        nargs='*',
+        default=None,
+        help='ignore files or directories (e.g. *.py __pycache__)',
+    )
+
+    parser.add_argument(
+        '-gi',
+        '--gitignore',
+        action='store_true',
+        help='respect .gitignore rules',
+    )
+
+    parser.add_argument(
+        '-dl',
+        '--depth-level',
+        metavar='N',
+        type=int,
+        help='limit tree depth (>= 0)',
+    )
+
+    parser.add_argument(
+        '-o',
+        '--output-file',
+        metavar='FILE',
+        help='write output to file (markdown format)',
+    )
+
+    args = parser.parse_args()
+
+    # validações
+    if (args.dir_only or args.files_only) and (
+        args.dirs_first or args.files_first
+    ):
+        parser.error('ordering options cannot be used with --dir-only or --files-only')
+
+    if args.depth_level is not None and args.depth_level < 0:
+        parser.error('--depth-level must be >= 0')
+
+    return args

pyletree/pyletree.py

@@ -0,0 +1,180 @@
+'''This module provides Pyletree main module.'''
+
+from __future__ import annotations
+
+import pathlib
+import sys
+from collections import deque
+from fnmatch import fnmatch
+from typing import Deque, List, Optional, Set
+
+PIPE = '│'
+ELBOW = '└──'
+TEE = '├──'
+PIPE_PREFIX = '│   '
+SPACE_PREFIX = '    '
+
+
+class DirectoryTree:
+    def __init__(
+        self,
+        root_dir: pathlib.Path,
+        *,
+        dir_only: bool = False,
+        files_only: bool = False,
+        dirs_first: bool = False,
+        files_first: bool = False,
+        no_pipes: bool = False,
+        ignore: Optional[List[str]] = None,
+        use_gitignore: bool = False,
+        depth_level: Optional[int] = None,
+        output_file: Optional[str] = None,
+    ) -> None:
+        self._output_file = output_file
+        self._generator = _TreeGenerator(
+            root_dir=root_dir,
+            dir_only=dir_only,
+            files_only=files_only,
+            dirs_first=dirs_first,
+            files_first=files_first,
+            no_pipes=no_pipes,
+            ignore=ignore,
+            use_gitignore=use_gitignore,
+            depth_level=depth_level,
+        )
+
+    def generate(self) -> None:
+        tree = self._generator.build_tree()
+
+        if self._output_file:
+            tree.appendleft('```')
+            tree.append('```')
+            with open(self._output_file, 'w', encoding='utf-8') as f:
+                for line in tree:
+                    print(line, file=f)
+        else:
+            for line in tree:
+                print(line)
+
+
+class _TreeGenerator:
+    def __init__(
+        self,
+        *,
+        root_dir: pathlib.Path,
+        dir_only: bool,
+        files_only: bool,
+        dirs_first: bool,
+        files_first: bool,
+        no_pipes: bool,
+        ignore: Optional[List[str]],
+        use_gitignore: bool,
+        depth_level: Optional[int],
+    ) -> None:
+        self._root_dir = root_dir.resolve()
+        self._dir_only = dir_only
+        self._files_only = files_only
+        self._dirs_first = dirs_first
+        self._files_first = files_first
+        self._no_pipes = no_pipes
+        self._ignore: Set[str] = set(ignore or [])
+        self._depth_level = depth_level
+        self._tree: Deque[str] = deque()
+
+        self._gitignore = None
+        if use_gitignore:
+            try:
+                import pathspec
+
+                gitignore = self._root_dir / '.gitignore'
+                if gitignore.exists():
+                    patterns = gitignore.read_text().splitlines()
+                    self._gitignore = pathspec.PathSpec.from_lines(
+                        'gitwildmatch', patterns
+                    )
+            except ImportError:
+                print('Warning: pathspec not installed', file=sys.stderr)
+
+    def build_tree(self) -> Deque[str]:
+        root_name = self._root_dir.name or str(self._root_dir)
+        self._tree.append(f'{root_name}/')
+
+        if not self._no_pipes:
+            entries = self._prepare_entries(self._root_dir)
+            if entries:
+                self._tree.append(PIPE)
+
+        self._tree_body(self._root_dir, prefix='', depth=0)
+        return self._tree
+
+    def _tree_body(
+        self,
+        directory: pathlib.Path,
+        prefix: str,
+        depth: int,
+    ) -> None:
+        if self._depth_level is not None and depth >= self._depth_level:
+            return
+
+        entries = self._prepare_entries(directory)
+        if not entries:
+            return
+
+        last_index = len(entries) - 1
+
+        for index, entry in enumerate(entries):
+            is_last = index == last_index
+            connector = ELBOW if is_last else TEE
+
+            self._tree.append(
+                f'{prefix}{connector} {entry.name}{'/' if entry.is_dir() else ''}'
+            )
+
+            if entry.is_dir():
+                new_prefix = prefix + (SPACE_PREFIX if is_last else PIPE_PREFIX)
+                self._tree_body(entry, new_prefix, depth + 1)
+
+                if not self._no_pipes and not is_last:
+                    self._tree.append(prefix + PIPE)
+
+    def _prepare_entries(self, directory: pathlib.Path) -> List[pathlib.Path]:
+        try:
+            entries = sorted(directory.iterdir(), key=lambda e: e.name.lower())
+        except PermissionError:
+            return []
+
+        entries = [e for e in entries if not self._is_ignored(e)]
+
+        if self._dir_only:
+            return [e for e in entries if e.is_dir()]
+
+        if self._files_only:
+            return [e for e in entries if e.is_file()]
+
+        if self._dirs_first:
+            entries.sort(key=lambda e: (e.is_file(), e.name.lower()))
+        elif self._files_first:
+            entries.sort(key=lambda e: (e.is_dir(), e.name.lower()))
+
+        return entries
+
+    def _is_ignored(self, entry: pathlib.Path) -> bool:
+        for pattern in self._ignore:
+            if fnmatch(entry.name, pattern):
+                return True
+
+        if self._gitignore:
+            try:
+                rel = entry.relative_to(self._root_dir)
+                rel_str = str(rel)
+
+                if self._gitignore.match_file(rel_str):
+                    return True
+
+                if entry.is_dir() and self._gitignore.match_file(rel_str + '/'):
+                    return True
+
+            except ValueError:
+                pass
+
+        return False

pyletree-1.0.0.dist-info/METADATA

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: pyletree
+Version: 1.0.0
+Summary: Generate directory tree diagrams from the command line
+Author: Davi Reis Furtado, Leodanis Pozo Ramos
+License: MIT License
+        
+        Copyright (c) 2021 Real Python
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/davi-furtado/pyletree
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pathspec
+Dynamic: license-file
+
+<div align="center">
+  <h1 align="center">Pyletree</h1>
+  
+  <img src="https://img.shields.io/badge/python-3.8%2B-blue">
+  <img src="https://img.shields.io/badge/license-MIT-green">
+  <img src="https://img.shields.io/badge/version-1.0.0-orange">
+</div>
+
+<p align="right"><i>Pyletree is a simple and fast CLI tool to generate directory tree diagrams.</i></p>
+
+## Installation
+
+```bash
+pip install pyletree
+```
+
+## Usage
+
+```bash
+pyletree [ROOT_DIR]
+```
+
+If no directory is provided, the current directory is used:
+
+```bash
+pyletree
+```
+
+Show help:
+
+```bash
+pyletree -h
+```
+
+## Options
+
+### General
+
+- `-h`, `--help` Show help message
+- `-v`, `--version` Show version
+
+### Modes
+
+- `-d`, `--dir-only` Show directories only
+- `-f`, `--files-only` Show files only
+
+### Ordering
+
+- `-df`, `--dirs-first` List directories before files
+- `-ff`, `--files-first` List files before directories
+
+> Alphabetical order is always applied as base sorting.
+
+### Display
+
+- `-n`, `--no-pipes` Remove vertical pipes between branches
+
+### Ignoring
+
+- `-i`, `--ignore PATTERN [PATTERN ...]` Ignore files/directories
+- `-gi`, `--gitignore` Respect `.gitignore` rules
+
+### Depth
+
+- `-dl`, `--depth-level N` Limit depth
+
+### Output
+
+- `-o`, `--output-file FILE` Save output to file (Markdown format)
+
+## Examples
+
+Basic:
+
+```bash
+pyletree
+```
+
+Directories first:
+
+```bash
+pyletree . -df
+```
+
+Files only:
+
+```bash
+pyletree . -f
+```
+
+Limit depth:
+
+```bash
+pyletree . -dl 2
+```
+
+Ignore entries:
+
+```bash
+pyletree . -i node_modules dist .git
+```
+
+Use `.gitignore`:
+
+```bash
+pyletree . -gi
+```
+
+No pipes mode:
+
+```bash
+pyletree . -n
+```
+
+Save to file:
+
+```bash
+pyletree . -o tree.md
+```
+
+## Sample Output
+
+### Default
+
+```text
+project/
+│
+├── src/
+│   ├── main.py
+│   └── utils.py
+│
+├── tests/
+│   └── test_main.py
+│
+└── README.md
+```
+
+### No pipes (`-n`)
+
+```text
+project/
+├── src/
+│   ├── main.py
+│   └── utils.py
+├── tests/
+│   └── test_main.py
+└── README.md
+```
+
+## Features
+
+- Clean and readable tree output
+- `.gitignore` support (it does not ignore either the `.git` directory or the `.gitignore` file; if you want to ignore them, add them to the ignore patterns)
+- Custom ignore patterns
+- Depth limiting
+- Flexible sorting
+- Optional compact mode (`--no-pipes`)
+
+## Release History
+
+### 1.0.0
+
+- Initial release
+
+## Authors
+
+Davi Reis Furtado
+
+**Original RP Tree Author:**
+Leodanis Pozo Ramos
+
+## License
+
+_Pyletree_ is distributed under the MIT license. See [LICENSE](LICENSE) for more information.

pyletree-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyletree/__init__.py,sha256=1sOP-7TZCSgyXVqLJvp3-578zvUPUJoic2ZPha5xmq0,110
+pyletree/__main__.py,sha256=nNrE3-ObCkC51tFL-cxzEK3EtZiO-o4mk_nBsOTn0WY,1257
+pyletree/cli.py,sha256=4_oNljshZlV7RnJXk3RLC8khmrMV2SAGPTDtXBz_yTg,2616
+pyletree/pyletree.py,sha256=veN4JmV1VYgLGiljvZTB2z7I7WUJl7iKvDg5lnYHvoE,5506
+pyletree-1.0.0.dist-info/licenses/LICENSE,sha256=pENUFHvskdPC8qj2Sf-XjwRDgCwz5cD4bg5A-BJr_jw,1089
+pyletree-1.0.0.dist-info/METADATA,sha256=NogojFKkwVU3OpILZa8KMeMxBg03zh5qbc5HVIMqCFk,4383
+pyletree-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyletree-1.0.0.dist-info/entry_points.txt,sha256=5x_IatHdODVLBMn1RluFPCAztyVIgCkMc1MwCtSj0y0,52
+pyletree-1.0.0.dist-info/top_level.txt,sha256=RXW33Hcj8p9OxX53oLBGl8n4no4az0HZSjqTD-uYI7o,9
+pyletree-1.0.0.dist-info/RECORD,,

pyletree-1.0.0.dist-info/WHEEL

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

pyletree-1.0.0.dist-info/entry_points.txt

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

pyletree-1.0.0.dist-info/licenses/LICENSE

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

pyletree-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyletree