reposnap 0.6.3__py3-none-any.whl → 0.6.4__py3-none-any.whl

{reposnap-0.6.3.dist-info → reposnap-0.6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reposnap
-Version: 0.6.3
+Version: 0.6.4
 Summary: Generate a Markdown file with all contents of your project
 Author: agoloborodko
 License-File: LICENSE

reposnap-0.6.4.dist-info/RECORD

@@ -0,0 +1,5 @@
+reposnap-0.6.4.dist-info/METADATA,sha256=ZD55J-JVXgwC_ENrX8dmcIT5s3KlJqG26gPAzj74wlU,5348
+reposnap-0.6.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+reposnap-0.6.4.dist-info/entry_points.txt,sha256=o3GyO7bpR0dujPCjsvvZMPv4pXNJlFwD49_pA1r5FOA,102
+reposnap-0.6.4.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
+reposnap-0.6.4.dist-info/RECORD,,

reposnap/controllers/project_controller.py

@@ -1,199 +0,0 @@
-import logging
-from pathlib import Path
-from reposnap.core.file_system import FileSystem
-from reposnap.models.file_tree import FileTree
-import pathspec
-from typing import List, Optional
-
-class ProjectController:
-    def __init__(self, args: Optional[object] = None):
-        self.logger = logging.getLogger(__name__)
-        # Always determine repository root using Git (or cwd)
-        self.root_dir = self._get_repo_root().resolve()
-        if args:
-            self.args = args
-            # Treat positional arguments as literal file/directory names.
-            input_paths = [Path(p) for p in (args.paths if hasattr(args, 'paths') else [args.path])]
-            self.input_paths = []
-            for p in input_paths:
-                candidate = (self.root_dir / p).resolve()
-                if candidate.exists():
-                    try:
-                        rel = candidate.relative_to(self.root_dir)
-                        if rel != Path('.'):
-                            self.input_paths.append(rel)
-                    except ValueError:
-                        self.logger.warning(f"Path {p} is not under repository root {self.root_dir}. Ignoring.")
-                else:
-                    self.logger.warning(f"Path {p} does not exist relative to repository root {self.root_dir}.")
-            self.output_file: Path = Path(args.output).resolve() if args.output else self.root_dir / 'output.md'
-            self.structure_only: bool = args.structure_only if hasattr(args, 'structure_only') else False
-            self.include_patterns: List[str] = args.include if hasattr(args, 'include') else []
-            self.exclude_patterns: List[str] = args.exclude if hasattr(args, 'exclude') else []
-        else:
-            self.args = None
-            self.input_paths = []
-            self.output_file = self.root_dir / 'output.md'
-            self.structure_only = False
-            self.include_patterns = []
-            self.exclude_patterns = []
-        self.file_tree: Optional[FileTree] = None
-        self.gitignore_patterns: List[str] = []
-        if self.root_dir:
-            self.gitignore_patterns = self._load_gitignore_patterns()
-
-    def _get_repo_root(self) -> Path:
-        """
-        Determine the repository root using Git if available,
-        otherwise use the current directory.
-        """
-        from git import Repo, InvalidGitRepositoryError
-        try:
-            repo = Repo(Path.cwd(), search_parent_directories=True)
-            return Path(repo.working_tree_dir).resolve()
-        except InvalidGitRepositoryError:
-            self.logger.warning("Not a git repository. Using current directory as root.")
-            return Path.cwd().resolve()
-
-    def set_root_dir(self, root_dir: Path) -> None:
-        self.root_dir = root_dir.resolve()
-        self.gitignore_patterns = self._load_gitignore_patterns()
-
-    def get_file_tree(self) -> Optional[FileTree]:
-        return self.file_tree
-
-    def _apply_include_exclude(self, files: List[Path]) -> List[Path]:
-        """Filter a list of file paths using include and exclude patterns."""
-        def adjust_patterns(patterns):
-            adjusted = []
-            for p in patterns:
-                if any(ch in p for ch in ['*', '?', '[']):
-                    adjusted.append(p)
-                else:
-                    adjusted.append(f'*{p}*')
-            return adjusted
-        if self.include_patterns:
-            inc = adjust_patterns(self.include_patterns)
-            spec_inc = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, inc)
-            files = [f for f in files if spec_inc.match_file(f.as_posix())]
-        if self.exclude_patterns:
-            exc = adjust_patterns(self.exclude_patterns)
-            spec_exc = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, exc)
-            files = [f for f in files if not spec_exc.match_file(f.as_posix())]
-        return files
-
-    def collect_file_tree(self) -> None:
-        self.logger.info("Collecting files from Git tracked files if available.")
-        try:
-            from reposnap.core.git_repo import GitRepo
-            git_repo = GitRepo(self.root_dir)
-            all_files = git_repo.get_git_files()
-            self.logger.debug(f"Git tracked files: {all_files}")
-        except Exception as e:
-            self.logger.warning(f"Error obtaining Git tracked files: {e}.")
-            all_files = []
-        # If Git returns an empty list but files exist on disk, fall back to filesystem scan.
-        if not all_files:
-            file_list = [p for p in self.root_dir.rglob("*") if p.is_file()]
-            if file_list:
-                self.logger.info("Git tracked files empty, using filesystem scan fallback.")
-                all_files = []
-                for path in file_list:
-                    try:
-                        rel = path.relative_to(self.root_dir)
-                        all_files.append(rel)
-                    except ValueError:
-                        continue
-        all_files = self._apply_include_exclude(all_files)
-        self.logger.debug(f"All files after applying include/exclude: {all_files}")
-        if self.input_paths:
-            trees = []
-            for input_path in self.input_paths:
-                subset = [f for f in all_files if f == input_path or list(f.parts[:len(input_path.parts)]) == list(input_path.parts)]
-                self.logger.debug(f"Files for input path '{input_path}': {subset}")
-                if subset:
-                    tree = FileSystem(self.root_dir).build_tree_structure(subset)
-                    trees.append(tree)
-            if trees:
-                merged_tree = self.merge_trees(trees)
-            else:
-                merged_tree = {}
-        else:
-            merged_tree = FileSystem(self.root_dir).build_tree_structure(all_files)
-        self.logger.info("Merged tree built from input paths.")
-        self.file_tree = FileTree(merged_tree)
-        self.logger.debug(f"Merged tree structure: {self.file_tree.structure}")
-
-    def merge_trees(self, trees: List[dict]) -> dict:
-        """Recursively merge a list of tree dictionaries."""
-        merged = {}
-        for tree in trees:
-            merged = self._merge_two_trees(merged, tree)
-        return merged
-
-    def _merge_two_trees(self, tree1: dict, tree2: dict) -> dict:
-        merged = dict(tree1)
-        for key, value in tree2.items():
-            if key in merged:
-                if isinstance(merged[key], dict) and isinstance(value, dict):
-                    merged[key] = self._merge_two_trees(merged[key], value)
-                else:
-                    merged[key] = value
-            else:
-                merged[key] = value
-        return merged
-
-    def apply_filters(self) -> None:
-        self.logger.info("Applying .gitignore filters to the merged tree.")
-        spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, self.gitignore_patterns)
-        self.logger.debug(f".gitignore patterns: {self.gitignore_patterns}")
-        self.file_tree.filter_files(spec)
-
-    def generate_output(self) -> None:
-        self.logger.info("Starting Markdown generation.")
-        from reposnap.core.markdown_generator import MarkdownGenerator
-        markdown_generator = MarkdownGenerator(
-            root_dir=self.root_dir,
-            output_file=self.output_file,
-            structure_only=self.structure_only
-        )
-        markdown_generator.generate_markdown(self.file_tree.structure, self.file_tree.get_all_files())
-        self.logger.info(f"Markdown generated at {self.output_file}.")
-
-    def generate_output_from_selected(self, selected_files: set) -> None:
-        self.logger.info("Generating Markdown from selected files.")
-        pruned_tree = self.file_tree.prune_tree(selected_files)
-        from reposnap.core.markdown_generator import MarkdownGenerator
-        markdown_generator = MarkdownGenerator(
-            root_dir=self.root_dir,
-            output_file=self.output_file,
-            structure_only=False,
-            hide_untoggled=True
-        )
-        markdown_generator.generate_markdown(pruned_tree, [Path(f) for f in selected_files])
-        self.logger.info(f"Markdown generated at {self.output_file}.")
-
-    def run(self) -> None:
-        """Run the entire process: collect files, apply filters, and generate Markdown."""
-        self.collect_file_tree()
-        self.apply_filters()
-        self.generate_output()
-
-    def _load_gitignore_patterns(self) -> List[str]:
-        gitignore_path = self.root_dir / '.gitignore'
-        if not gitignore_path.exists():
-            for parent in self.root_dir.parents:
-                candidate = parent / '.gitignore'
-                if candidate.exists():
-                    gitignore_path = candidate
-                    break
-            else:
-                gitignore_path = None
-        if gitignore_path and gitignore_path.exists():
-            with gitignore_path.open('r') as gitignore:
-                patterns = [line.strip() for line in gitignore if line.strip() and not line.strip().startswith('#')]
-            self.logger.debug(f"Loaded .gitignore patterns from {gitignore_path.parent}: {patterns}")
-            return patterns
-        else:
-            self.logger.debug(f"No .gitignore found starting from {self.root_dir}.")
-            return []

reposnap/core/file_system.py

@@ -1,32 +0,0 @@
-# src/reposnap/core/file_system.py
-
-import logging
-from pathlib import Path
-from typing import List, Dict, Any
-
-
-class FileSystem:
-    def __init__(self, root_dir: Path):
-        self.root_dir: Path = root_dir.resolve()
-        self.logger = logging.getLogger(__name__)
-
-    def build_tree_structure(self, files: List[Path]) -> Dict[str, Any]:
-        """
-        Builds a hierarchical tree structure from the list of files.
-
-        Args:
-            files (List[Path]): List of file paths relative to root_dir.
-
-        Returns:
-            Dict[str, Any]: Nested dictionary representing the directory structure.
-        """
-        tree: Dict[str, Any] = {}
-        self.logger.debug("Building tree structure.")
-        for relative_path in files:
-            parts = relative_path.parts
-            current_level = tree
-            for part in parts[:-1]:
-                current_level = current_level.setdefault(part, {})
-            current_level[parts[-1]] = None  # Indicate a file node
-        self.logger.debug(f"Tree structure built: {tree}")
-        return tree

reposnap/core/git_repo.py

@@ -1,33 +0,0 @@
-# src/reposnap/core/git_repo.py
-
-import logging
-from pathlib import Path
-from git import Repo, InvalidGitRepositoryError
-from typing import List
-
-
-class GitRepo:
-    def __init__(self, repo_path: Path):
-        self.repo_path: Path = repo_path.resolve()
-        self.logger = logging.getLogger(__name__)
-
-    def get_git_files(self) -> List[Path]:
-        try:
-            repo: Repo = Repo(self.repo_path, search_parent_directories=True)
-            repo_root: Path = Path(repo.working_tree_dir).resolve()
-            git_files: List[str] = repo.git.ls_files().splitlines()
-            self.logger.debug(f"Git files from {repo_root}: {git_files}")
-            git_files_relative: List[Path] = []
-            for f in git_files:
-                absolute_path: Path = (repo_root / f).resolve()
-                try:
-                    relative_path: Path = absolute_path.relative_to(self.repo_path)
-                    git_files_relative.append(relative_path)
-                except ValueError:
-                    # Skip files not under root_dir
-                    continue
-            return git_files_relative
-        except InvalidGitRepositoryError:
-            self.logger.error(f"Invalid Git repository at: {self.repo_path}")
-            return []
-

reposnap/core/markdown_generator.py

@@ -1,79 +0,0 @@
-# src/reposnap/core/markdown_generator.py
-
-import logging
-from pathlib import Path
-from reposnap.utils.path_utils import format_tree
-from typing import List, Dict, Any
-
-
-class MarkdownGenerator:
-    def __init__(self, root_dir: Path, output_file: Path, structure_only: bool = False, hide_untoggled: bool = False):
-        self.root_dir: Path = root_dir.resolve()
-        self.output_file: Path = output_file.resolve()
-        self.structure_only: bool = structure_only
-        self.hide_untoggled: bool = hide_untoggled
-        self.logger = logging.getLogger(__name__)
-
-    def generate_markdown(self, tree_structure: Dict[str, Any], files: List[Path]) -> None:
-        """
-        Generates the Markdown file based on the provided tree structure and files.
-
-        Args:
-            tree_structure (Dict[str, Any]): The hierarchical structure of the project files.
-            files (List[Path]): List of file paths to include in the markdown.
-        """
-        self._write_header(tree_structure)
-        if not self.structure_only:
-            self._write_file_contents(files)
-
-    def _write_header(self, tree_structure: Dict[str, Any]) -> None:
-        """
-        Writes the header and project structure to the Markdown file.
-        """
-        self.logger.debug("Writing Markdown header and project structure.")
-        try:
-            with self.output_file.open('w', encoding='utf-8') as f:
-                f.write("# Project Structure\n\n")
-                f.write("```\n")
-                for line in format_tree(tree_structure, hide_untoggled=self.hide_untoggled):
-                    f.write(line)
-                f.write("```\n\n")
-            self.logger.debug("Header and project structure written successfully.")
-        except IOError as e:
-            self.logger.error(f"Failed to write header to {self.output_file}: {e}")
-            raise
-
-    def _write_file_contents(self, files: List[Path]) -> None:
-        """
-        Writes the contents of each file to the Markdown file.
-
-        Args:
-            files (List[Path]): List of file paths relative to root_dir.
-        """
-        self.logger.debug("Writing file contents to Markdown.")
-        for relative_path in files:
-            file_path: Path = self.root_dir / relative_path
-
-            if not file_path.exists():
-                self.logger.debug(f"File not found: {file_path}. Skipping.")
-                continue
-
-            try:
-                self._write_file_content(file_path, relative_path.as_posix())
-            except UnicodeDecodeError as e:
-                self.logger.error(f"UnicodeDecodeError for file {file_path}: {e}")
-
-
-    def _write_file_content(self, file_path: Path, relative_path: str) -> None:
-        """
-        Writes the content of a single file to the Markdown file with syntax highlighting.
-        """
-        try:
-            with file_path.open('r', encoding='utf-8') as f:
-                content: str = f.read()
-            with self.output_file.open('a', encoding='utf-8') as f:
-                f.write(f"## {relative_path}\n\n")
-                f.write("```python\n" if file_path.suffix == '.py' else "```\n")
-                f.write(f"{content}\n```\n\n")
-        except IOError as e:
-            self.logger.error(f"Error reading or writing file {file_path}: {e}")

reposnap/interfaces/cli.py

@@ -1,37 +0,0 @@
-# src/reposnap/interfaces/cli.py
-
-import argparse
-import logging
-from reposnap.controllers.project_controller import ProjectController
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Generate a Markdown representation of a Git repository.'
-    )
-    # Changed positional argument to allow one or more paths.
-    parser.add_argument(
-        'paths',
-        nargs='+',
-        help='One or more paths (files or directories) to include in the Markdown output.'
-    )
-    parser.add_argument('-o', '--output', help='Output Markdown file', default='output.md')
-    parser.add_argument('--structure-only', action='store_true',
-                        help='Only include the file structure without content.')
-    parser.add_argument('--debug', action='store_true', help='Enable debug-level logging.')
-    parser.add_argument('-i', '--include', nargs='*', default=[],
-                        help='File/folder patterns to include.')
-    parser.add_argument('-e', '--exclude', nargs='*', default=[],
-                        help='File/folder patterns to exclude.')
-
-    args = parser.parse_args()
-
-    log_level = logging.DEBUG if args.debug else logging.INFO
-    logging.basicConfig(level=log_level, format='%(asctime)s - %(levelname)s - %(message)s')
-
-    controller = ProjectController(args)
-    controller.run()
-
-
-if __name__ == "__main__":
-    main()

reposnap/interfaces/gui.py

@@ -1,155 +0,0 @@
-# src/reposnap/interfaces/gui.py
-
-import urwid
-from pathlib import Path
-from reposnap.controllers.project_controller import ProjectController
-
-
-class MyCheckBox(urwid.CheckBox):
-    def __init__(self, label, user_data=None, **kwargs):
-        super().__init__(label, **kwargs)
-        self.user_data = user_data
-
-
-class RepoSnapGUI:
-    def __init__(self):
-        self.controller = ProjectController()
-        self.root_dir = Path('.').resolve()
-        self.file_tree = None
-        self.selected_files = set()
-
-        self.main_loop = None
-        self.build_main_menu()
-
-    def build_main_menu(self):
-        self.root_dir_edit = urwid.Edit(('bold', "Root Directory: "), str(self.root_dir))
-        scan_button = urwid.Button("Scan", on_press=self.on_scan)
-
-        main_menu = urwid.Frame(
-            header=urwid.Text(('bold', "RepoSnap - Main Menu")),
-            body=urwid.Padding(
-                urwid.LineBox(
-                    urwid.ListBox(
-                        urwid.SimpleFocusListWalker([
-                            self.root_dir_edit
-                        ])
-                    ),
-                    title="Enter Root Directory"
-                ),
-                left=2, right=2
-            ),
-            footer=urwid.Padding(scan_button, align='center')
-        )
-
-        self.main_widget = main_menu
-
-    def on_scan(self, button):
-        self.root_dir = Path(self.root_dir_edit.edit_text).resolve()
-        self.controller.set_root_dir(self.root_dir)
-        self.controller.collect_file_tree()
-        self.file_tree = self.controller.get_file_tree()
-        self.build_file_tree_menu()
-
-    def build_file_tree_menu(self):
-        tree_widgets = self.build_tree_widget(self.file_tree.structure)
-        tree_listbox = urwid.ListBox(urwid.SimpleFocusListWalker(tree_widgets))
-        render_button = urwid.Button("Render", on_press=self.on_render)
-
-        tree_menu = urwid.Frame(
-            header=urwid.Text(('bold', f"File Tree of {self.root_dir}")),
-            body=urwid.LineBox(tree_listbox),
-            footer=urwid.Padding(render_button, align='center')
-        )
-
-        self.main_widget = tree_menu
-        self.refresh()
-
-    def build_tree_widget(self, tree_structure, parent_path="", level=0):
-        widgets = []
-        for key, value in sorted(tree_structure.items()):
-            node_path = f"{parent_path}/{key}".lstrip('/')
-            checkbox = MyCheckBox(
-                key,
-                user_data={'path': node_path, 'level': level},
-                state=False,
-                on_state_change=self.on_checkbox_change
-            )
-            indented_checkbox = urwid.Padding(checkbox, left=4*level)
-            widgets.append(indented_checkbox)
-            if isinstance(value, dict):
-                widgets.extend(self.build_tree_widget(value, node_path, level=level+1))
-        return widgets
-
-    def on_checkbox_change(self, checkbox, state):
-        user_data = checkbox.user_data
-        node_path = user_data['path']
-        level = user_data['level']
-        if state:
-            self.selected_files.add(node_path)
-        else:
-            self.selected_files.discard(node_path)
-        # Handle toggling all children
-        self.toggle_children(checkbox, state, level)
-
-    def toggle_children(self, checkbox, state, level):
-        listbox = self.main_widget.body.original_widget.body
-        walker = listbox
-        # Find the index of the Padding widget that contains the checkbox
-        idx = None
-        for i, widget in enumerate(walker):
-            if isinstance(widget, urwid.Padding) and widget.original_widget == checkbox:
-                idx = i
-                break
-        if idx is None:
-            return
-        idx += 1
-        while idx < len(walker):
-            widget = walker[idx]
-            if isinstance(widget, urwid.Padding):
-                checkbox_widget = widget.original_widget
-                widget_user_data = checkbox_widget.user_data
-                widget_level = widget_user_data['level']
-                if widget_level > level:
-                    checkbox_widget.set_state(state, do_callback=False)
-                    node_path = widget_user_data['path']
-                    if state:
-                        self.selected_files.add(node_path)
-                    else:
-                        self.selected_files.discard(node_path)
-                    idx += 1
-                else:
-                    break
-            else:
-                idx += 1
-
-    def on_render(self, button):
-        self.controller.generate_output_from_selected(self.selected_files)
-        message = urwid.Text(('bold', f"Markdown generated at {self.controller.output_file}"))
-        exit_button = urwid.Button("Exit", on_press=self.exit_program)
-        result_menu = urwid.Frame(
-            header=urwid.Text(('bold', "Success")),
-            body=urwid.Filler(message, valign='middle'),
-            footer=urwid.Padding(exit_button, align='center')
-        )
-        self.main_widget = result_menu
-        self.refresh()
-
-    def refresh(self):
-        if self.main_loop:
-            self.main_loop.widget = self.main_widget
-
-    def exit_program(self, button):
-        raise urwid.ExitMainLoop()
-
-    def run(self):
-        self.main_loop = urwid.MainLoop(self.main_widget)
-        self.main_loop.run()
-
-
-def main():
-    app = RepoSnapGUI()
-    app.run()
-
-
-if __name__ == "__main__":
-    main()

reposnap/models/file_tree.py

@@ -1,79 +0,0 @@
-# src/reposnap/models/file_tree.py
-
-import logging
-from pathlib import Path
-from typing import Dict, List, Any
-import pathspec
-
-
-class FileTree:
-    def __init__(self, structure: Dict[str, Any]):
-        self.structure: Dict[str, Any] = structure
-        self.logger = logging.getLogger(__name__)
-
-    def get_all_files(self) -> List[Path]:
-        """
-        Recursively retrieve all file paths from the tree.
-        Returns:
-            List[Path]: List of file paths relative to root_dir.
-        """
-        return self._extract_files(self.structure)
-
-    def _extract_files(self, subtree: Dict[str, Any], path_prefix: str = '') -> List[Path]:
-        files: List[Path] = []
-        for key, value in subtree.items():
-            current_path: str = f"{path_prefix}/{key}".lstrip('/')
-            if isinstance(value, dict):
-                files.extend(self._extract_files(value, current_path))
-            else:
-                files.append(Path(current_path))
-        return files
-
-    def filter_files(self, spec: pathspec.PathSpec) -> None:
-        """
-        Filters files in the tree structure based on the provided pathspec.
-
-        Args:
-            spec (pathspec.PathSpec): The pathspec for filtering files.
-        """
-        self.logger.debug("Filtering files in the file tree.")
-        self.structure = self._filter_tree(self.structure, spec)
-
-    def _filter_tree(self, subtree: Dict[str, Any], spec: pathspec.PathSpec, path_prefix: str = '') -> Dict[str, Any]:
-        filtered_subtree: Dict[str, Any] = {}
-        for key, value in subtree.items():
-            current_path: str = f"{path_prefix}/{key}".lstrip('/')
-            if isinstance(value, dict):
-                filtered_value: Dict[str, Any] = self._filter_tree(value, spec, current_path)
-                if filtered_value:
-                    filtered_subtree[key] = filtered_value
-            else:
-                # Exclude the file if either the full path OR its basename matches a .gitignore pattern.
-                if not spec.match_file(current_path) and not spec.match_file(Path(current_path).name):
-                    filtered_subtree[key] = value
-        return filtered_subtree
-
-    def prune_tree(self, selected_files: set) -> Dict[str, Any]:
-        """
-        Prunes the tree to include only the selected files and their directories.
-
-        Args:
-            selected_files (set): Set of selected file paths.
-
-        Returns:
-            Dict[str, Any]: Pruned tree structure.
-        """
-        return self._prune_tree(self.structure, selected_files)
-
-    def _prune_tree(self, subtree: Dict[str, Any], selected_files: set, path_prefix: str = '') -> Dict[str, Any]:
-        pruned_subtree: Dict[str, Any] = {}
-        for key, value in subtree.items():
-            current_path: str = f"{path_prefix}/{key}".lstrip('/')
-            if isinstance(value, dict):
-                pruned_value: Dict[str, Any] = self._prune_tree(value, selected_files, current_path)
-                if pruned_value:
-                    pruned_subtree[key] = pruned_value
-            else:
-                if current_path in selected_files:
-                    pruned_subtree[key] = value
-        return pruned_subtree

reposnap/utils/path_utils.py

@@ -1,13 +0,0 @@
-# src/reposnap/utils/path_utils.py
-from typing import Dict, Generator, Any
-
-
-def format_tree(tree: Dict[str, Any], indent: str = '', hide_untoggled: bool = False) -> Generator[str, None, None]:
-    for key, value in tree.items():
-        if value == '<hidden>':
-            yield f"{indent}<...>\n"
-        elif isinstance(value, dict):
-            yield f"{indent}{key}/\n"
-            yield from format_tree(value, indent + '    ', hide_untoggled)
-        else:
-            yield f"{indent}{key}\n"

reposnap-0.6.3.dist-info/RECORD

@@ -1,19 +0,0 @@
-reposnap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/controllers/project_controller.py,sha256=u3agILanSms5Gx4D5e6EWhHrb6B08saz5udct8yVS-s,9353
-reposnap/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/core/file_system.py,sha256=82gwvmgrsWf63paMrIz-Z0eqIjbqt9_-vujdXlJJoFE,1074
-reposnap/core/git_repo.py,sha256=2u_ILkV-Ur7qr1WHmHM2yg44Ggft61RsdbZLsZaQ5NU,1256
-reposnap/core/markdown_generator.py,sha256=Ld6ix4gzkLJJyeUoWHwhpbAf3DvEC5E0S1DykYnLGnQ,3297
-reposnap/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/interfaces/cli.py,sha256=JzTNDibzuRRmnWg-gBfKJ2tSlh-NYSL_3q6J-Erjrr8,1374
-reposnap/interfaces/gui.py,sha256=pzWQbW55gBNZu4tXRdBFic39upGtYxew91FSiEvalj0,5421
-reposnap/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/models/file_tree.py,sha256=0WcSDbFH5pSZHyWxWtmz-FF4_ELnZ3Byz2iXN4Tpijw,3206
-reposnap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/utils/path_utils.py,sha256=7072816LCP8Q8XBydn0iknmfrObPO_-2rFqpbAvPrjY,501
-reposnap-0.6.3.dist-info/METADATA,sha256=wPRE4NKJuzwMKTyYD8e2nPUYUNjwM81kCEsVz18yWTY,5348
-reposnap-0.6.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-reposnap-0.6.3.dist-info/entry_points.txt,sha256=o3GyO7bpR0dujPCjsvvZMPv4pXNJlFwD49_pA1r5FOA,102
-reposnap-0.6.3.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
-reposnap-0.6.3.dist-info/RECORD,,