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

reposnap/controllers/project_controller.py

@@ -5,6 +5,7 @@ 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__)
@@ -13,27 +14,43 @@ class ProjectController:
         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])]
+            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('.'):
+                        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.")
+                        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 []
+                    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.output_file = self.root_dir / "output.md"
             self.structure_only = False
             self.include_patterns = []
             self.exclude_patterns = []
@@ -48,11 +65,14 @@ class ProjectController:
         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.")
+            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:
@@ -64,21 +84,27 @@ class ProjectController:
 
     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 ['*', '?', '[']):
+                if any(ch in p for ch in ["*", "?", "["]):
                     adjusted.append(p)
                 else:
-                    adjusted.append(f'*{p}*')
+                    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)
+            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)
+            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
 
@@ -86,6 +112,7 @@ class ProjectController:
         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}")
@@ -96,7 +123,9 @@ class ProjectController:
         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.")
+                self.logger.info(
+                    "Git tracked files empty, using filesystem scan fallback."
+                )
                 all_files = []
                 for path in file_list:
                     try:
@@ -109,7 +138,12 @@ class ProjectController:
         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)]
+                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)
@@ -145,32 +179,40 @@ class ProjectController:
 
     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)
+        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
+            structure_only=self.structure_only,
+        )
+        markdown_generator.generate_markdown(
+            self.file_tree.structure, self.file_tree.get_all_files()
         )
-        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
+            hide_untoggled=True,
+        )
+        markdown_generator.generate_markdown(
+            pruned_tree, [Path(f) for f in selected_files]
         )
-        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:
@@ -180,19 +222,25 @@ class ProjectController:
         self.generate_output()
 
     def _load_gitignore_patterns(self) -> List[str]:
-        gitignore_path = self.root_dir / '.gitignore'
+        gitignore_path = self.root_dir / ".gitignore"
         if not gitignore_path.exists():
             for parent in self.root_dir.parents:
-                candidate = parent / '.gitignore'
+                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}")
+            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}.")

reposnap/core/git_repo.py

@@ -30,4 +30,3 @@ class GitRepo:
         except InvalidGitRepositoryError:
             self.logger.error(f"Invalid Git repository at: {self.repo_path}")
             return []
-

reposnap/core/markdown_generator.py

@@ -1,79 +1,91 @@
-# src/reposnap/core/markdown_generator.py
-
+# src/reposnap/core/markdown_generator.py           ★ fully-rewritten file
 import logging
 from pathlib import Path
+from typing import Dict, List, Any
+
 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__)
+    """Render the collected file-tree into a single Markdown document."""
 
-    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.
+    def __init__(
+        self,
+        root_dir: Path,
+        output_file: Path,
+        structure_only: bool = False,
+        hide_untoggled: bool = False,
+    ):
+        self.root_dir = root_dir.resolve()
+        self.output_file = output_file.resolve()
+        self.structure_only = structure_only
+        self.hide_untoggled = hide_untoggled
+        self.logger = logging.getLogger(__name__)
 
-        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.
-        """
+    # --------------------------------------------------------------
+    # public API
+    # --------------------------------------------------------------
+    def generate_markdown(
+        self, tree_structure: Dict[str, Any], files: List[Path]
+    ) -> None:
+        """Write header (tree) and, unless *structure_only*, every file body."""
         self._write_header(tree_structure)
         if not self.structure_only:
             self._write_file_contents(files)
 
+    # --------------------------------------------------------------
+    # helpers
+    # --------------------------------------------------------------
     def _write_header(self, tree_structure: Dict[str, Any]) -> None:
-        """
-        Writes the header and project structure to the Markdown file.
-        """
+        """Emit the *Project Structure* section."""
         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}")
+            with self.output_file.open(mode="w", encoding="utf-8") as fh:
+                fh.write("# Project Structure\n\n```\n")
+                for line in format_tree(
+                    tree_structure, hide_untoggled=self.hide_untoggled
+                ):
+                    fh.write(line)
+                fh.write("```\n\n")
+        except OSError as exc:
+            self.logger.error("Failed to write header: %s", exc)
             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.
-        """
+        """Append every file in *files* under its own fenced section."""
         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.")
+        for rel_path in files:
+            abs_path = self.root_dir / rel_path
+            if not abs_path.exists():  # git had stale entry
+                self.logger.debug("File not found: %s -- skipping.", abs_path)
                 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}")
-
+                self._write_single_file(abs_path, rel_path.as_posix())
+            except UnicodeDecodeError as exc:
+                self.logger.error("Unicode error for %s: %s", abs_path, exc)
 
-    def _write_file_content(self, file_path: Path, relative_path: str) -> None:
+    # --------------------------------------------------------------
+    # single-file writer
+    # --------------------------------------------------------------
+    def _write_single_file(self, file_path: Path, rel_str: str) -> None:
         """
-        Writes the content of a single file to the Markdown file with syntax highlighting.
+        Append one file.
+
+        We guarantee **one and only one** newline between the last character
+        of *content* and the closing code-fence so the output is stable and
+        deterministic (important for tests and downstream diff-tools).
         """
         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}")
+            with file_path.open(encoding="utf-8") as src:
+                content = src.read()
+
+            with self.output_file.open(mode="a", encoding="utf-8") as dst:
+                dst.write(f"## {rel_str}\n\n")
+                dst.write("```python\n" if file_path.suffix == ".py" else "```\n")
+
+                # normalise trailing EOL → exactly one '\n'
+                dst.write(content if content.endswith("\n") else f"{content}\n")
+
+                dst.write("```\n\n")
+        except OSError as exc:
+            self.logger.error("Error processing %s: %s", file_path, exc)

reposnap/interfaces/cli.py

@@ -7,27 +7,46 @@ from reposnap.controllers.project_controller import ProjectController
 
 def main():
     parser = argparse.ArgumentParser(
-        description='Generate a Markdown representation of a Git repository.'
+        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.')
+        "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')
+    logging.basicConfig(
+        level=log_level, format="%(asctime)s - %(levelname)s - %(message)s"
+    )
 
     controller = ProjectController(args)
     controller.run()

reposnap/interfaces/gui.py

@@ -14,7 +14,7 @@ class MyCheckBox(urwid.CheckBox):
 class RepoSnapGUI:
     def __init__(self):
         self.controller = ProjectController()
-        self.root_dir = Path('.').resolve()
+        self.root_dir = Path(".").resolve()
         self.file_tree = None
         self.selected_files = set()
 
@@ -22,23 +22,22 @@ class RepoSnapGUI:
         self.build_main_menu()
 
     def build_main_menu(self):
-        self.root_dir_edit = urwid.Edit(('bold', "Root Directory: "), str(self.root_dir))
+        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")),
+            header=urwid.Text(("bold", "RepoSnap - Main Menu")),
             body=urwid.Padding(
                 urwid.LineBox(
-                    urwid.ListBox(
-                        urwid.SimpleFocusListWalker([
-                            self.root_dir_edit
-                        ])
-                    ),
-                    title="Enter Root Directory"
+                    urwid.ListBox(urwid.SimpleFocusListWalker([self.root_dir_edit])),
+                    title="Enter Root Directory",
                 ),
-                left=2, right=2
+                left=2,
+                right=2,
             ),
-            footer=urwid.Padding(scan_button, align='center')
+            footer=urwid.Padding(scan_button, align="center"),
         )
 
         self.main_widget = main_menu
@@ -56,9 +55,9 @@ class RepoSnapGUI:
         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}")),
+            header=urwid.Text(("bold", f"File Tree of {self.root_dir}")),
             body=urwid.LineBox(tree_listbox),
-            footer=urwid.Padding(render_button, align='center')
+            footer=urwid.Padding(render_button, align="center"),
         )
 
         self.main_widget = tree_menu
@@ -67,23 +66,25 @@ class RepoSnapGUI:
     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('/')
+            node_path = f"{parent_path}/{key}".lstrip("/")
             checkbox = MyCheckBox(
                 key,
-                user_data={'path': node_path, 'level': level},
+                user_data={"path": node_path, "level": level},
                 state=False,
-                on_state_change=self.on_checkbox_change
+                on_state_change=self.on_checkbox_change,
             )
-            indented_checkbox = urwid.Padding(checkbox, left=4*level)
+            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))
+                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']
+        node_path = user_data["path"]
+        level = user_data["level"]
         if state:
             self.selected_files.add(node_path)
         else:
@@ -108,10 +109,10 @@ class RepoSnapGUI:
             if isinstance(widget, urwid.Padding):
                 checkbox_widget = widget.original_widget
                 widget_user_data = checkbox_widget.user_data
-                widget_level = widget_user_data['level']
+                widget_level = widget_user_data["level"]
                 if widget_level > level:
                     checkbox_widget.set_state(state, do_callback=False)
-                    node_path = widget_user_data['path']
+                    node_path = widget_user_data["path"]
                     if state:
                         self.selected_files.add(node_path)
                     else:
@@ -124,12 +125,14 @@ class RepoSnapGUI:
 
     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}"))
+        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')
+            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()

reposnap/models/file_tree.py

@@ -19,10 +19,12 @@ class FileTree:
         """
         return self._extract_files(self.structure)
 
-    def _extract_files(self, subtree: Dict[str, Any], path_prefix: str = '') -> List[Path]:
+    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('/')
+            current_path: str = f"{path_prefix}/{key}".lstrip("/")
             if isinstance(value, dict):
                 files.extend(self._extract_files(value, current_path))
             else:
@@ -39,17 +41,23 @@ class FileTree:
         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]:
+    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('/')
+            current_path: str = f"{path_prefix}/{key}".lstrip("/")
             if isinstance(value, dict):
-                filtered_value: Dict[str, Any] = self._filter_tree(value, spec, current_path)
+                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):
+                if not spec.match_file(current_path) and not spec.match_file(
+                    Path(current_path).name
+                ):
                     filtered_subtree[key] = value
         return filtered_subtree
 
@@ -65,12 +73,16 @@ class FileTree:
         """
         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]:
+    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('/')
+            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)
+                pruned_value: Dict[str, Any] = self._prune_tree(
+                    value, selected_files, current_path
+                )
                 if pruned_value:
                     pruned_subtree[key] = pruned_value
             else:

reposnap/utils/path_utils.py

@@ -2,12 +2,14 @@
 from typing import Dict, Generator, Any
 
 
-def format_tree(tree: Dict[str, Any], indent: str = '', hide_untoggled: bool = False) -> Generator[str, None, None]:
+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>':
+        if value == "<hidden>":
             yield f"{indent}<...>\n"
         elif isinstance(value, dict):
             yield f"{indent}{key}/\n"
-            yield from format_tree(value, indent + '    ', hide_untoggled)
+            yield from format_tree(value, indent + "    ", hide_untoggled)
         else:
             yield f"{indent}{key}\n"

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

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

reposnap-0.6.5.dist-info/RECORD

@@ -0,0 +1,19 @@
+reposnap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/controllers/project_controller.py,sha256=XranKRoWd1cRZ4cEXmN_YddO-GHREz9t2J0TUJ4mtgs,10053
+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=I0AhB6XbABJ-oVGOSkVhSjFjSFfcm6f1VFHGTeuM4gE,1255
+reposnap/core/markdown_generator.py,sha256=V6uEbxVSbCbxKN9ysTDKsIDvEGBxFutpOpyaZRXZUGw,3747
+reposnap/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/interfaces/cli.py,sha256=qkbYAlgZzlxgW8ePIUwd8JSbvnBVSvde-VlVqzMDh7g,1470
+reposnap/interfaces/gui.py,sha256=sTuQxjD1nPa9FpgfzOwi6VDO5QMMtDX-5CiEhbJJcs4,5429
+reposnap/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/models/file_tree.py,sha256=jGo_SizdFcOiDC1OOMz-tiijRN3iSD7ENh6Xw8S6OL0,3362
+reposnap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/utils/path_utils.py,sha256=UrMe5cjspTf-4gjg2lzv6BgLwZ7S_1lLECQvDMDZO9Y,507
+reposnap-0.6.5.dist-info/METADATA,sha256=V85e8nN5tNH_U-W_tludr_nG8CNvhGEDAX34Tz1r8JM,5348
+reposnap-0.6.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+reposnap-0.6.5.dist-info/entry_points.txt,sha256=o3GyO7bpR0dujPCjsvvZMPv4pXNJlFwD49_pA1r5FOA,102
+reposnap-0.6.5.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
+reposnap-0.6.5.dist-info/RECORD,,

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,,