reposnap 0.3.2__tar.gz → 0.5.0__tar.gz

reposnap-0.5.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.3
+Name: reposnap
+Version: 0.5.0
+Summary: Generate a Markdown file with all contents of your project
+Author: agoloborodko
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: gitpython>=3.1.43
+Requires-Dist: pathlib>=1.0.1
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: urwid>=2.6.15
+Description-Content-Type: text/markdown
+
+# RepoSnap
+
+## Overview
+
+`reposnap` is a Python tool designed to generate a Markdown file that documents the structure and contents of a Git project. It provides both a command-line interface (CLI) and a graphical user interface (GUI) for ease of use. This tool is particularly useful for creating a quick overview of a project's file hierarchy, including optional syntax-highlighted code snippets.
+
+## Features
+
+- **Command-Line Interface (CLI)**: Quickly generate documentation from the terminal.
+- **Graphical User Interface (GUI)**: A user-friendly GUI if you want to select files and directories interactively.
+- **Syntax Highlighting**: Includes syntax highlighting for known file types in the generated Markdown file.
+- **Structure Only Option**: The `--structure-only` flag can be used to generate the Markdown file with just the directory structure, omitting the contents of the files.
+- **Gitignore Support**: Automatically respects `.gitignore` patterns to exclude files and directories.
+- **Include and Exclude Patterns**: Use `--include` and `--exclude` to specify patterns for files and directories to include or exclude.
+
+## Installation
+
+You can install `reposnap` using pip:
+
+```bash
+pip install reposnap
+```
+
+Alternatively, you can clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/username/reposnap.git
+cd reposnap
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Command-Line Interface
+
+To use `reposnap` from the command line, run it with the following options:
+
+```bash
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] path
+```
+
+- `path`: Path to the Git repository or subdirectory.
+- `-h, --help`: Show help message and exit.
+- `-o, --output`: The name of the output Markdown file. Defaults to `output.md`.
+- `--structure-only`: Generate a Markdown file that includes only the project structure, without file contents.
+- `--debug`: Enable debug-level logging.
+- `-i, --include`: File/folder patterns to include. For example, `-i "*.py"` includes only Python files.
+- `-e, --exclude`: File/folder patterns to exclude. For example, `-e "*.md"` excludes all Markdown files.
+
+#### Pattern Matching
+
+- **Pattern Interpretation**: Patterns follow gitignore-style syntax but with a twist.
+  - **Patterns without Wildcards**: If a pattern does not contain any wildcard characters (`*`, `?`, or `[`), it is treated as `*pattern*`. This means it will match any file or directory containing `pattern` in its name.
+  - **Patterns with Wildcards**: If a pattern contains wildcard characters, it retains its original behavior.
+
+- **Examples**:
+  - `-e "gui"`: Excludes any files or directories containing `"gui"` in their names.
+  - `-i "*.py"`: Includes only files ending with `.py`.
+  - `-e "*.test.*"`: Excludes files with `.test.` in their names.
+
+#### Examples
+
+1. **Generate a full project structure with file contents**:
+
+    ```bash
+    reposnap .
+    ```
+
+2. **Generate a project structure only**:
+
+    ```bash
+    reposnap my_project/ --structure-only
+    ```
+
+3. **Generate a Markdown file including only Python files**:
+
+    ```bash
+    reposnap my_project/ -i "*.py"
+    ```
+
+4. **Generate a Markdown file excluding certain files and directories**:
+
+    ```bash
+    reposnap my_project/ -e "tests" -e "*.md"
+    ```
+
+5. **Exclude files and directories containing a substring**:
+
+    ```bash
+    reposnap my_project/ -e "gui"
+    ```
+
+### Graphical User Interface
+
+`reposnap` also provides a GUI for users who prefer an interactive interface.
+
+To launch the GUI, simply run:
+
+```bash
+reposnap-gui
+```
+
+#### Using the GUI
+
+1. **Select Root Directory**: When the GUI opens, you can specify the root directory of your Git project. By default, it uses the current directory.
+
+2. **Scan the Project**: Click the "Scan" button to analyze the project. The GUI will display the file tree of your project.
+
+3. **Select Files and Directories**: Use the checkboxes to select which files and directories you want to include in the Markdown documentation. Toggling a directory checkbox will toggle all its child files and directories.
+
+4. **Generate Markdown**: After selecting the desired files, click the "Render" button. The Markdown file will be generated and saved as `output.md` in the current directory.
+
+5. **Exit**: Click the "Exit" button to close the GUI.
+
+## Testing
+
+To run the tests, use the following command:
+
+```bash
+pytest tests/
+```
+
+Ensure that you have the `pytest` library installed:
+
+```bash
+pip install pytest
+```
+
+## License
+
+This project is licensed under the MIT License.
+
+## Acknowledgments
+
+- [GitPython](https://gitpython.readthedocs.io/) - Used for interacting with Git repositories.
+- [pathspec](https://pathspec.readthedocs.io/) - Used for pattern matching file paths.
+- [Urwid](https://urwid.org/) - Used for creating the GUI interface.

reposnap-0.5.0/README.md

@@ -0,0 +1,137 @@
+# RepoSnap
+
+## Overview
+
+`reposnap` is a Python tool designed to generate a Markdown file that documents the structure and contents of a Git project. It provides both a command-line interface (CLI) and a graphical user interface (GUI) for ease of use. This tool is particularly useful for creating a quick overview of a project's file hierarchy, including optional syntax-highlighted code snippets.
+
+## Features
+
+- **Command-Line Interface (CLI)**: Quickly generate documentation from the terminal.
+- **Graphical User Interface (GUI)**: A user-friendly GUI if you want to select files and directories interactively.
+- **Syntax Highlighting**: Includes syntax highlighting for known file types in the generated Markdown file.
+- **Structure Only Option**: The `--structure-only` flag can be used to generate the Markdown file with just the directory structure, omitting the contents of the files.
+- **Gitignore Support**: Automatically respects `.gitignore` patterns to exclude files and directories.
+- **Include and Exclude Patterns**: Use `--include` and `--exclude` to specify patterns for files and directories to include or exclude.
+
+## Installation
+
+You can install `reposnap` using pip:
+
+```bash
+pip install reposnap
+```
+
+Alternatively, you can clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/username/reposnap.git
+cd reposnap
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Command-Line Interface
+
+To use `reposnap` from the command line, run it with the following options:
+
+```bash
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] path
+```
+
+- `path`: Path to the Git repository or subdirectory.
+- `-h, --help`: Show help message and exit.
+- `-o, --output`: The name of the output Markdown file. Defaults to `output.md`.
+- `--structure-only`: Generate a Markdown file that includes only the project structure, without file contents.
+- `--debug`: Enable debug-level logging.
+- `-i, --include`: File/folder patterns to include. For example, `-i "*.py"` includes only Python files.
+- `-e, --exclude`: File/folder patterns to exclude. For example, `-e "*.md"` excludes all Markdown files.
+
+#### Pattern Matching
+
+- **Pattern Interpretation**: Patterns follow gitignore-style syntax but with a twist.
+  - **Patterns without Wildcards**: If a pattern does not contain any wildcard characters (`*`, `?`, or `[`), it is treated as `*pattern*`. This means it will match any file or directory containing `pattern` in its name.
+  - **Patterns with Wildcards**: If a pattern contains wildcard characters, it retains its original behavior.
+
+- **Examples**:
+  - `-e "gui"`: Excludes any files or directories containing `"gui"` in their names.
+  - `-i "*.py"`: Includes only files ending with `.py`.
+  - `-e "*.test.*"`: Excludes files with `.test.` in their names.
+
+#### Examples
+
+1. **Generate a full project structure with file contents**:
+
+    ```bash
+    reposnap .
+    ```
+
+2. **Generate a project structure only**:
+
+    ```bash
+    reposnap my_project/ --structure-only
+    ```
+
+3. **Generate a Markdown file including only Python files**:
+
+    ```bash
+    reposnap my_project/ -i "*.py"
+    ```
+
+4. **Generate a Markdown file excluding certain files and directories**:
+
+    ```bash
+    reposnap my_project/ -e "tests" -e "*.md"
+    ```
+
+5. **Exclude files and directories containing a substring**:
+
+    ```bash
+    reposnap my_project/ -e "gui"
+    ```
+
+### Graphical User Interface
+
+`reposnap` also provides a GUI for users who prefer an interactive interface.
+
+To launch the GUI, simply run:
+
+```bash
+reposnap-gui
+```
+
+#### Using the GUI
+
+1. **Select Root Directory**: When the GUI opens, you can specify the root directory of your Git project. By default, it uses the current directory.
+
+2. **Scan the Project**: Click the "Scan" button to analyze the project. The GUI will display the file tree of your project.
+
+3. **Select Files and Directories**: Use the checkboxes to select which files and directories you want to include in the Markdown documentation. Toggling a directory checkbox will toggle all its child files and directories.
+
+4. **Generate Markdown**: After selecting the desired files, click the "Render" button. The Markdown file will be generated and saved as `output.md` in the current directory.
+
+5. **Exit**: Click the "Exit" button to close the GUI.
+
+## Testing
+
+To run the tests, use the following command:
+
+```bash
+pytest tests/
+```
+
+Ensure that you have the `pytest` library installed:
+
+```bash
+pip install pytest
+```
+
+## License
+
+This project is licensed under the MIT License.
+
+## Acknowledgments
+
+- [GitPython](https://gitpython.readthedocs.io/) - Used for interacting with Git repositories.
+- [pathspec](https://pathspec.readthedocs.io/) - Used for pattern matching file paths.
+- [Urwid](https://urwid.org/) - Used for creating the GUI interface.

{reposnap-0.3.2 → reposnap-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reposnap"
-version = "0.3.2"
+version = "0.5.0"
 description = "Generate a Markdown file with all contents of your project"
 authors = [
     { name = "agoloborodko" }
@@ -9,6 +9,7 @@ dependencies = [
     "pathlib>=1.0.1",
     "pathspec>=0.12.1",
     "gitpython>=3.1.43",
+    "urwid>=2.6.15",
 ]
 readme = "README.md"
 requires-python = ">= 3.8"
@@ -30,4 +31,5 @@ allow-direct-references = true
 packages = ["src/reposnap"]
 
 [project.scripts]
-reposnap = "reposnap:main"
+reposnap = "reposnap.interfaces.cli:main"
+reposnap-gui = "reposnap.interfaces.gui:main"

{reposnap-0.3.2 → reposnap-0.5.0}/requirements-dev.lock

@@ -27,3 +27,9 @@ pluggy==1.5.0
 pytest==8.3.2
 smmap==5.0.1
     # via gitdb
+typing-extensions==4.12.2
+    # via urwid
+urwid==2.6.15
+    # via reposnap
+wcwidth==0.2.13
+    # via urwid

{reposnap-0.3.2 → reposnap-0.5.0}/requirements.lock

@@ -20,3 +20,9 @@ pathspec==0.12.1
     # via reposnap
 smmap==5.0.1
     # via gitdb
+typing-extensions==4.12.2
+    # via urwid
+urwid==2.6.15
+    # via reposnap
+wcwidth==0.2.13
+    # via urwid

reposnap-0.5.0/src/reposnap/controllers/project_controller.py

@@ -0,0 +1,122 @@
+# src/reposnap/controllers/project_controller.py
+
+import logging
+from pathlib import Path
+from reposnap.core.git_repo import GitRepo
+from reposnap.core.file_system import FileSystem
+from reposnap.core.markdown_generator import MarkdownGenerator
+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__)
+        self.root_dir: Path = Path(args.path).resolve() if args else Path('.').resolve()
+        self.output_file: Path = Path(args.output).resolve() if args else Path('output.md').resolve()
+        self.structure_only: bool = args.structure_only if args else False
+        self.args: object = args
+        self.file_tree: Optional[FileTree] = None
+        self.gitignore_patterns: List[str] = []
+        self.include_patterns: List[str] = args.include if args and hasattr(args, 'include') else []
+        self.exclude_patterns: List[str] = args.exclude if args and hasattr(args, 'exclude') else []
+        if self.root_dir:
+            self.gitignore_patterns = self._load_gitignore_patterns()
+
+    def set_root_dir(self, root_dir: Path) -> None:
+        self.root_dir = root_dir
+        self.gitignore_patterns = self._load_gitignore_patterns()
+
+    def get_file_tree(self) -> Optional[FileTree]:
+        return self.file_tree
+
+    def run(self) -> None:
+        self.collect_file_tree()
+        self.apply_filters()
+        self.generate_output()
+
+    def collect_file_tree(self) -> None:
+        self.logger.info("Collecting git files.")
+        git_repo: GitRepo = GitRepo(self.root_dir)
+        git_files: List[Path] = git_repo.get_git_files()
+        self.logger.debug(f"Git files before filtering: {git_files}")
+
+        # Adjust patterns
+        def adjust_patterns(patterns):
+            adjusted = []
+            for pattern in patterns:
+                if '*' in pattern or '?' in pattern or '[' in pattern:
+                    adjusted.append(pattern)
+                else:
+                    adjusted.append(f'*{pattern}*')
+            return adjusted
+
+        # Apply include patterns
+        if self.include_patterns:
+            adjusted_include_patterns = adjust_patterns(self.include_patterns)
+            include_spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, adjusted_include_patterns)
+            git_files = [f for f in git_files if include_spec.match_file(f.as_posix())]
+            self.logger.debug(f"Git files after include patterns: {git_files}")
+
+        # Apply exclude patterns
+        if self.exclude_patterns:
+            adjusted_exclude_patterns = adjust_patterns(self.exclude_patterns)
+            exclude_spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, adjusted_exclude_patterns)
+            git_files = [f for f in git_files if not exclude_spec.match_file(f.as_posix())]
+            self.logger.debug(f"Git files after exclude patterns: {git_files}")
+
+        self.logger.info("Building tree structure.")
+        file_system: FileSystem = FileSystem(self.root_dir)
+        tree_structure: dict = file_system.build_tree_structure(git_files)
+
+        self.file_tree = FileTree(tree_structure)
+        self.logger.debug(f"Tree structure: {self.file_tree.structure}")
+
+    def apply_filters(self) -> None:
+        self.logger.info("Applying filters to the file tree.")
+        spec: pathspec.PathSpec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, self.gitignore_patterns)
+        self.logger.debug(f"Filter patterns: {self.gitignore_patterns}")
+        self.file_tree.filter_files(spec)
+
+    def generate_output(self) -> None:
+        self.logger.info("Starting markdown generation.")
+        markdown_generator: MarkdownGenerator = 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.")
+        # Build a pruned tree structure based on selected files
+        pruned_tree = self.file_tree.prune_tree(selected_files)
+        markdown_generator: MarkdownGenerator = 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 _load_gitignore_patterns(self) -> List[str]:
+        gitignore_path: Path = self.root_dir / '.gitignore'
+        if not gitignore_path.exists():
+            for parent in self.root_dir.parents:
+                gitignore_path = parent / '.gitignore'
+                if gitignore_path.exists():
+                    break
+            else:
+                gitignore_path = None
+
+        if gitignore_path and gitignore_path.exists():
+            with gitignore_path.open('r') as gitignore:
+                patterns: List[str] = gitignore.readlines()
+            self.logger.debug(f"Patterns from .gitignore in {gitignore_path.parent}: {patterns}")
+            return patterns
+        else:
+            self.logger.debug(f"No .gitignore found starting from {self.root_dir}. Proceeding without patterns.")
+            return []

{reposnap-0.3.2 → reposnap-0.5.0}/src/reposnap/core/markdown_generator.py

@@ -7,10 +7,11 @@ from typing import List, Dict, Any
 
 
 class MarkdownGenerator:
-    def __init__(self, root_dir: Path, output_file: Path, structure_only: bool = False):
+    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:
@@ -34,7 +35,7 @@ class MarkdownGenerator:
             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):
+                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.")
@@ -72,4 +73,3 @@ class MarkdownGenerator:
                 f.write(f"{content}\n```\n\n")
         except IOError as e:
             self.logger.error(f"Error reading or writing file {file_path}: {e}")
-

{reposnap-0.3.2 → reposnap-0.5.0}/src/reposnap/interfaces/cli.py

@@ -7,12 +7,18 @@ from reposnap.controllers.project_controller import ProjectController
 
 def main():
     parser = argparse.ArgumentParser(description='Generate a Markdown representation of a Git repository.')
-    parser.add_argument('path', help='Path to the Git repository or subdirectory.')
+    parser.add_argument('path', nargs='?', default='.', help='Path to the Git repository or subdirectory.')
     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.')
 
+    # New arguments for include and exclude patterns
+    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
@@ -21,5 +27,6 @@ def main():
     controller = ProjectController(args)
     controller.run()
 
+
 if __name__ == "__main__":
     main()

reposnap-0.5.0/src/reposnap/interfaces/gui.py

@@ -0,0 +1,155 @@
+# 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()