repo-parser 0.0.3__py3-none-any.whl

repo_parser/__init__.py

@@ -0,0 +1,16 @@
+"""
+A library for extracting metadata out of a source repository.
+"""
+
+__version__ = "0.0.3"
+
+from .filesystem import scan
+from .processor import Processor
+from .resource import Resource, get_resources
+
+__all__ = [
+    "Processor",
+    "Resource",
+    "get_resources",
+    "scan",
+]

repo_parser/cli.py

@@ -0,0 +1,163 @@
+"""
+Command-line interface for repo-parser.
+"""
+
+import os
+import pathlib
+import re
+from datetime import UTC, datetime
+from importlib import resources
+
+import git
+import jinja2
+import typer
+from slugify import slugify
+
+app = typer.Typer(help="repo-parser CLI tools")
+idr_app = typer.Typer(help="IDR (Implementation Decision Record) commands")
+app.add_typer(idr_app, name="idr")
+
+
+def _get_git_author() -> str:
+    """
+    Get the author name and email from git config.
+
+    Returns:
+        Author in format "Name <email>", or "Unknown" if not set.
+    """
+    try:
+        # Read from global git config (doesn't require being in a repo)
+        config = git.GitConfigParser(
+            [git.config.get_config_path("global")], read_only=True
+        )
+        name = config.get_value("user", "name")
+        email = config.get_value("user", "email")
+    except (KeyError, ValueError, OSError, git.GitCommandNotFound):
+        # Config file doesn't exist, user.name/email not set, or git not installed
+        typer.echo(
+            "Warning: Could not read git config user.name/email, using 'Unknown' as author",
+            err=True,
+        )
+        return "Unknown"
+    else:
+        return f"{name} <{email}>"
+
+
+def _get_repo_root() -> pathlib.Path:
+    """
+    Get the root directory of the git repository.
+
+    Returns:
+        Path to repository root.
+
+    Raises:
+        typer.Exit: If not in a git repository.
+    """
+    try:
+        repo = git.Repo(search_parent_directories=True)
+        return pathlib.Path(repo.working_dir)
+    except git.InvalidGitRepositoryError as e:
+        typer.echo("Error: Not in a git repository", err=True)
+        raise typer.Exit(1) from e
+
+
+def _load_template() -> str:
+    """
+    Load the IDR template from package resources.
+
+    Returns:
+        Template content as string.
+    """
+    # Python 3.11+ uses importlib.resources.files
+    template_path = resources.files("repo_parser").joinpath("templates/idr.md")
+    return template_path.read_text()
+
+
+def _strip_html_comments(text: str) -> str:
+    """
+    Strip HTML comments from text.
+
+    Args:
+        text: Text containing HTML comments.
+
+    Returns:
+        Text with HTML comments removed and extra blank lines cleaned up.
+    """
+    # Remove HTML comments (including multiline)
+    # Note: This doesn't handle edge cases like --> within comment text,
+    # but that's unlikely in our IDR templates
+    text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
+    # Clean up any blank lines left by removing comments
+    # First normalize all whitespace-only lines to actual blank lines
+    text = re.sub(r"^\s+$", "", text, flags=re.MULTILINE)
+    # Then collapse multiple consecutive blank lines (3+) to exactly 2 newlines
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    # Finally, strip any leading/trailing whitespace from the entire document
+    return text.strip()
+
+
+@idr_app.command("new")
+def idr_new(
+    title: str,
+    no_comments: bool = typer.Option(
+        False,
+        "--no-comments",
+        help="Create IDR without explanatory comments in the template",
+    ),
+):
+    """
+    Create a new IDR (Implementation Decision Record).
+
+    Creates a new IDR file in the idrs/ directory with a timestamp and slugified title.
+    Example: rp idr new "Add last modified metadata"
+    """
+    repo_root = _get_repo_root()
+
+    # Create idrs directory if it doesn't exist
+    idrs_dir = repo_root / "idrs"
+    idrs_dir.mkdir(exist_ok=True)
+
+    # Generate timestamp in UTC
+    timestamp = datetime.now(UTC).strftime("%Y%m%d%H%M")
+
+    # Slugify the title
+    slug = slugify(title)
+
+    # Create filename
+    filename = f"{timestamp}-{slug}.md"
+    filepath = idrs_dir / filename
+
+    # Check if file already exists (realistically should not happen)
+    if filepath.exists():
+        typer.echo(f"Error: File already exists: {filepath}", err=True)
+        raise typer.Exit(1)
+
+    # Get author from git config
+    author = _get_git_author()
+
+    # Load and render template
+    template_content = _load_template()
+
+    # Check if we should strip comments (from flag or environment variable)
+    strip_comments = no_comments or os.environ.get(
+        "RP_IDR_NO_COMMENTS", ""
+    ).lower() in (
+        "1",
+        "true",
+        "yes",
+    )
+
+    if strip_comments:
+        template_content = _strip_html_comments(template_content)
+
+    template = jinja2.Template(template_content)
+    rendered = template.render(title=title, author=author)
+
+    # Write file
+    filepath.write_text(rendered)
+
+    typer.echo(f"Created IDR: {filepath}")
+
+
+if __name__ == "__main__":
+    app()

repo_parser/filesystem.py

@@ -0,0 +1,120 @@
+import pathlib
+import re
+from dataclasses import dataclass
+from pathlib import PurePath
+
+import git
+
+from .processor import Processor
+
+
+@dataclass
+class File:
+    name: str
+    src_path: PurePath
+    content: str | None
+
+
+@dataclass
+class Dir:
+    path: pathlib.Path
+    files: list[File]
+    dirs: list["Dir"]
+
+
+def _scan(
+    path: pathlib.Path,
+    processors: list[Processor],
+    ignore_patterns: list[re.Pattern],
+    repo: git.Repo,
+    depth: int,
+    max_depth: int | None,
+) -> Dir:
+    dir = Dir(path=path, files=[], dirs=[])
+    entries = list(path.iterdir())
+    if not entries:
+        return dir
+    resolved_entries = {str(entry.resolve()) for entry in entries}
+
+    # remove any entries which match our ignore patterns (e.g. autogenerated files)
+    ignored = {
+        resolved_entry
+        for resolved_entry in resolved_entries
+        if any(
+            re.search(pattern, resolved_entry) is not None
+            for pattern in ignore_patterns
+        )
+    }
+    # also ignore anything .gitignored (doing this second because it's a likely a little
+    # more time consuming)
+    remaining_entries = resolved_entries - ignored
+    if remaining_entries:
+        ignored |= set(repo.ignored(*remaining_entries))
+
+    for entry in entries:
+        # FIXME: At some point we should only ignore .git in the root directory
+        if entry.name == ".git" or str(entry.resolve()) in ignored:
+            continue
+        if entry.is_file():
+            for processor in processors:
+                if processor.pattern.search(str(entry)):
+                    content = entry.read_text() if processor.read_content else None
+                    dir.files.append(
+                        File(
+                            name=entry.name,
+                            src_path=(path / entry.name),
+                            content=content,
+                        )
+                    )
+        elif entry.is_dir() and (max_depth is None or depth < max_depth):
+            dir.dirs.append(
+                _scan(
+                    path / entry.name,
+                    processors,
+                    ignore_patterns,
+                    repo,
+                    depth + 1,
+                    max_depth,
+                )
+            )
+
+    return dir
+
+
+def scan(
+    path: pathlib.Path,
+    processors: list[Processor],
+    ignore_patterns: list[re.Pattern] | None = None,
+    subdirs: list[pathlib.Path] | None = None,
+    max_depth: int | None = None,
+) -> tuple[Dir, git.Repo]:
+    """
+    Scans a GitHub repository for files and subdirectories, returning a data
+    structure representing the directory tree.
+
+    Takes in a list of processors to figure out which files should be included
+    in the returned tree.
+
+    Under the hood, this uses the `git` library to scan the repository, skipping
+    files in .gitignore.
+
+    This step does not do any post-processing of the files, though their
+    content is read in if one of their processors requires it.
+
+    Returns a tuple of (Dir, git.Repo) for further processing.
+    """
+    repo = git.Repo(path, search_parent_directories=True)
+
+    # if subdirs, just scan each one and return the results
+    if subdirs:
+        dir = Dir(path=path, files=[], dirs=[])
+        for subdir in subdirs:
+            dir.dirs.append(
+                _scan(
+                    path / subdir, processors, ignore_patterns or [], repo, 0, max_depth
+                )
+            )
+        return dir, repo
+
+    # otherwise read everything up to max_depth
+    return _scan(path, processors, ignore_patterns or [], repo, 0, max_depth), repo

repo_parser/processor.py

@@ -0,0 +1,14 @@
+import re
+from collections.abc import Callable
+from dataclasses import dataclass
+
+
+@dataclass
+class Processor:
+    """
+    Processor class to process files based on a pattern.
+    """
+
+    pattern: re.Pattern
+    process: Callable
+    read_content: bool

repo_parser/resource.py

@@ -0,0 +1,285 @@
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path, PurePath
+
+import git
+
+from .filesystem import Dir
+from .processor import Processor
+
+# Chunk size for batch git log queries to avoid command-line length limits
+LAST_MODIFIED_CHUNK_SIZE = 200
+
+
+@dataclass
+class Resource:
+    name: str
+    src_path: PurePath
+    path: PurePath
+    type: str
+    metadata: dict
+    content: str | None
+    children: list["Resource"]
+    last_modified: datetime
+
+
+def _get_last_modified(repo: git.Repo, file_path: PurePath) -> datetime:
+    """Get the last modification date from git as a datetime object"""
+    commits = list(repo.iter_commits(paths=str(file_path), max_count=1))
+    if commits:
+        return datetime.fromtimestamp(commits[0].committed_date)
+
+    return datetime.now()
+
+
+def _get_last_modified_batch(
+    repo: git.Repo, file_paths: list[PurePath], scan_root: Path | None = None
+) -> dict[PurePath, datetime]:
+    """
+    Get the last modification dates for multiple files in a single batched git call.
+
+    Args:
+        repo: The git repository
+        file_paths: List of file paths to query (can be absolute or relative)
+        scan_root: Optional root path for resolving relative file paths. If provided,
+            relative paths will be resolved against this root. If None, relative paths
+            are resolved against the current working directory or repo root.
+
+    Returns:
+        Dictionary mapping file paths to their last commit dates. Files with no
+        git history will have datetime.now() as their value.
+
+    Raises:
+        ValueError: If a file path cannot be converted to a relative path
+        git.GitCommandError: If git log command fails (may be raised by repo.git.log)
+    """
+    if not file_paths:
+        return {}
+
+    repo_root = Path(repo.working_dir)
+    result: dict[PurePath, datetime] = {}
+
+    # Convert all paths to relative paths and build a mapping
+    # We need to map relative paths back to original PurePath objects
+    rel_path_to_original: dict[str, PurePath] = {}
+    rel_paths: list[str] = []
+
+    for file_path in file_paths:
+        # Convert to Path and resolve to absolute path
+        path_obj = Path(file_path)
+        if path_obj.is_absolute():
+            abs_path = path_obj
+        else:
+            # Try resolving relative path against scan_root (if provided) or current working directory
+            if scan_root is not None:
+                abs_path = (scan_root / path_obj).resolve()
+            else:
+                abs_path = path_obj.resolve()
+
+            # If the resolved path is not within the repo root, try resolving against repo root
+            try:
+                abs_path.relative_to(repo_root)
+            except ValueError:
+                # Path is not within repo when resolved against scan_root/cwd, try repo root
+                abs_path = (repo_root / path_obj).resolve()
+
+        # Note: In normal operation, all paths come from scanning the repository,
+        # so they should always be within the repo root. This may raise ValueError
+        # if a path is outside the repo, but that shouldn't happen in practice.
+        rel_path = str(abs_path.relative_to(repo_root))
+
+        # Normalize path separators (git uses forward slashes)
+        rel_path = rel_path.replace("\\", "/")
+        rel_path_to_original[rel_path] = file_path
+        rel_paths.append(rel_path)
+
+    # Process in chunks to avoid command-line length limits
+    for i in range(0, len(rel_paths), LAST_MODIFIED_CHUNK_SIZE):
+        chunk = rel_paths[i : i + LAST_MODIFIED_CHUNK_SIZE]
+        chunk_set = set(chunk)  # For fast lookup
+
+        # Use git log to get commit timestamps and affected files
+        # Format: timestamp\n<blank>\nfile1\nfile2\n...\n<blank>\n
+        # Note: This may raise git.GitCommandError if git log fails
+        log_output = repo.git.log("--format=%ct", "--name-only", "--", *chunk)
+
+        # Parse the output
+        # Format is: timestamp\n<blank>\nfile1\nfile2\n...\n<blank>\n
+        lines = log_output.split("\n")
+        current_timestamp: int | None = None
+        file_timestamps: dict[str, int] = {}
+
+        for line in lines:
+            line = line.strip()
+            if not line:
+                # Blank line separates commits
+                continue
+
+            # Check if this is a timestamp (all digits)
+            if line.isdigit():
+                current_timestamp = int(line)
+            elif current_timestamp is not None:
+                # This is a file path, normalize it
+                file_path_normalized = line.replace("\\", "/")
+                if file_path_normalized in chunk_set:
+                    # Track the most recent (largest) timestamp for each file
+                    if (
+                        file_path_normalized not in file_timestamps
+                        or file_timestamps[file_path_normalized] < current_timestamp
+                    ):
+                        file_timestamps[file_path_normalized] = current_timestamp
+
+        # Convert timestamps to datetime and map back to original PurePath objects
+        for rel_path in chunk:
+            original_path = rel_path_to_original[rel_path]
+            if rel_path in file_timestamps:
+                result[original_path] = datetime.fromtimestamp(
+                    file_timestamps[rel_path]
+                )
+            else:
+                # File has no git history
+                result[original_path] = datetime.now()
+
+    return result
+
+
+def _apply_last_modified_map(
+    resource: Resource, last_modified_cache: dict[PurePath, datetime]
+) -> None:
+    """
+    Recursively apply last_modified dates from cache to a Resource tree.
+
+    Updates file resources with dates from the cache, then updates directory
+    resources to be the max of their children.
+    """
+    # Apply to children first (depth-first)
+    for child in resource.children:
+        _apply_last_modified_map(child, last_modified_cache)
+
+    # Apply to this resource if it's a file
+    if resource.type == "file" and resource.src_path in last_modified_cache:
+        resource.last_modified = last_modified_cache[resource.src_path]
+
+    # Update directory resources to be max of children
+    if resource.children:
+        resource.last_modified = max(child.last_modified for child in resource.children)
+
+
+def _get_resources(
+    dir: Dir,
+    parent_path: PurePath,
+    processors: list[Processor],
+    repo: git.Repo,
+    file_paths: list[PurePath] | None = None,
+) -> list[Resource]:
+    child_resources: list[Resource] = []
+    dir_resource: Resource | None = None
+
+    # do a first pass to see if we can find a "dir_resource"
+    for file in dir.files:
+        for processor in processors:
+            if processor.pattern.search(file.name):
+                filetype, metadata, _ = processor.process(file.content or "")
+                if filetype != "file":
+                    if dir_resource is None:
+                        dir_resource = Resource(
+                            name=dir.path.name,
+                            src_path=dir.path,
+                            path=PurePath(),
+                            type=filetype,
+                            metadata=metadata,
+                            content=None,
+                            children=[],
+                            last_modified=datetime.now(),
+                        )
+                        # parent path is now the dir_resource
+                        parent_path = dir_resource.path
+                    else:
+                        # a previous processor picked this up, augment the metadata
+                        # FIXME: I think we want to be able to override the name as well
+                        dir_resource.metadata.update(metadata)
+
+    # do a second pass to find all the child resources, placing
+    # their paths relative to the parent
+    for file in dir.files:
+        for processor in processors:
+            if processor.pattern.search(file.name):
+                _, metadata, _ = processor.process(file.content or "")
+                # Collect file path for batch querying
+                if file_paths is not None:
+                    file_paths.append(file.src_path)
+
+                child_resources.append(
+                    Resource(
+                        name=file.name,
+                        path=parent_path / file.name,
+                        src_path=file.src_path,
+                        type="file",
+                        metadata=metadata,
+                        content=file.content,
+                        children=[],
+                        last_modified=datetime.now(),
+                    )
+                )
+                # Will only match once!
+                break
+
+    for subdir in dir.dirs:
+        child_resources.extend(
+            _get_resources(
+                subdir,
+                parent_path / subdir.path.name,
+                processors,
+                repo,
+                file_paths,
+            )
+        )
+
+    # if this directory did not define a new resource, append any newly
+    # found resources to the parent
+    if dir_resource is None:
+        return child_resources
+
+    # otherwise, add the child resources to the dir_resource, and return that
+    dir_resource.children = child_resources
+
+    # Update dir_resource last_modified to be the most recent from all children
+    if child_resources:
+        dir_resource.last_modified = max(
+            child.last_modified for child in child_resources
+        )
+
+    return [dir_resource]
+
+
+def get_resources(repo: git.Repo, dir: Dir, processors: list[Processor]) -> Resource:
+    """
+    Gets a list of resources from a scanned filesystem.
+
+    Will process each file in the filesystem with the provided processors,
+    note that order matters: the first processor that matches a given file
+    will be used and no further processors will be applied after that.
+    """
+    # Collect file paths as we create resources (single pass)
+    file_paths: list[PurePath] = []
+    children = _get_resources(dir, PurePath(), processors, repo, file_paths)
+
+    # Batch query all commit dates at once
+    scan_root = dir.path
+    last_modified_map = _get_last_modified_batch(repo, file_paths, scan_root)
+
+    root_resource = Resource(
+        name=dir.path.name,
+        path=PurePath(),
+        src_path=dir.path,
+        type="repo",
+        metadata={},
+        children=children,
+        content=None,
+        last_modified=datetime.now(),
+    )
+
+    # Apply last_modified dates
+    _apply_last_modified_map(root_resource, last_modified_map)
+
+    return root_resource

repo_parser/templates/idr.md

@@ -0,0 +1,91 @@
+<!--
+Commented sections (like this) are meant to be explanatory. Feel free to delete them.
+
+To create IDRs without these comments:
+- Use the --no-comments flag: rp idr new "Title" --no-comments
+- Or set the environment variable: export RP_IDR_NO_COMMENTS=1
+-->
+
+# {{ title }}
+
+Owner: {{ author }}
+
+## Overview
+
+### Problem Statement
+
+<!--
+* 3-5 lines
+* Statement of the goal
+* Help people decide if they want to invest in reading this on a skim
+-->
+
+### Context (as needed)
+
+### Goals
+
+<!--
+* Describe major goals of this implementation
+* Does not need to be exhaustive, less is more
+-->
+
+### Non-Goals
+
+<!--
+* Describe non-goals of this implementation
+* Does not need to be exhaustive, less is more
+-->
+
+### Proposed Solution
+
+<!--
+Describe in relatively short form (ideally <200 words) the proposed solution
+-->
+
+## Detailed Design (as needed)
+
+<!--
+Go into more detail on the design if needed. Totally optional. Note there
+is a section below for describing the exact shape of the implementation.
+-->
+
+## Rollout plan (as needed)
+
+<!--
+Describe how this feature will be rolled out, especially if there are breaking
+changes required
+-->
+
+## Cross cutting concerns (as needed)
+
+<!--
+Describe the design from other angles: security, reliability, etc.
+-->
+
+## Alternatives considered (as needed)
+
+<!--
+Describe alternatives to this design that were considered. Doesn't need to
+be exhaustive, only add something here if you think someone is likely to ask
+about it.
+-->
+
+## Future plans (as needed)
+
+<!--
+Things that may be added in the future
+-->
+
+## Other reading (as needed)
+
+<!--
+Provide links to prior art
+-->
+
+## Implementation (ephemeral)
+
+<!--
+Details on the implementation of this design. Can include checklists,
+detailed descriptions of code changes, etc. Whatever is most helpful
+to the humans and/or computers responsible for implementation!
+-->

repo_parser-0.0.3.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: repo-parser
+Version: 0.0.3
+Summary: A library for extracting metadata out of a source repository.
+Author-email: William Lachance <wlach@protonmail.com>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+License-File: LICENSE
+Requires-Dist: GitPython
+Requires-Dist: jinja2
+Requires-Dist: python-slugify
+Requires-Dist: typer
+Project-URL: Home, https://github.com/wlach/repo-parser
+
+# repo-parser
+
+This is a set of python scripts and tools for extracting metadata and structure
+out of a monorepo, for the purposes of generating a service registry, unified documentation, or other types of data out of the contents. It also contains some
+tooling designed around a new concept called "Implementation Decision Records" (idrs), designed to aid both implementation (especially where assisted by LLMs) and later code archaeology efforts.
+
+It should be considered an experiment, rather than production software. It is inspired by my experiences in the software industry and being frustrated with current solutions being some combination of:
+
+- Time consuming to configure and maintain
+- Requiring the specification of redundant metadata (which is bound to get out of date)
+
+Current assumptions:
+
+- The files you want to process fit into memory
+- You don't care about history (repo-parser gives a snapshot in time)
+
+You can see a demo of a documentation site generated from this repo at:
+
+https://repo-parser-demo.netlify.app/
+
+> [!NOTE]
+> repo-parser is partly created with LLMs (specifically, Claude Code and ChatGPT),
+> with heavy human curation.
+
+## Usage
+
+### Creating IDRs (Implementation Decision Records)
+
+repo-parser includes a CLI tool (`rp`) for creating Implementation Decision Records (IDRs). IDRs are lightweight documents that capture both the intent and implementation details of code changes, designed to be committed alongside your code.
+
+They are intended to be useful for both humans and computational agents (LLMs).
+
+**Why IDRs?** Traditional design docs are too heavyweight for implementation. ADRs are great for decisions but lack implementation detail. IDRs bridge the gap—detailed enough to guide implementation, ephemeral enough to not become stale documentation.
+
+Create a new IDR:
+
+```bash
+rp idr new "Your Feature Title"
+```
+
+This will create a new markdown file in the `idrs/` directory with:
+
+- A UTC timestamp prefix (e.g., `202512301600`)
+- A slugified version of your title
+- Pre-filled template with your git author name
+
+Example:
+
+```bash
+rp idr new "Add last modified metadata"
+# Creates: idrs/202512301600-add-last-modified-metadata.md
+```
+
+The IDR template includes sections for:
+
+- Problem Statement
+- Context
+- Goals and Non-Goals
+- Proposed Solution
+- Detailed Design
+- Implementation notes (ephemeral)
+
+This feature was itself implemented using an IDR—see [idrs/202512301631-idrs.md](idrs/202512301631-idrs.md) for more about the IDR format and philosophy.
+
+### Using repo-parser as a Library
+
+For documentation generation and metadata extraction, see the example in `example/example_parser.py`.
+
+An early version of repo-parser is available on pypi as https://pypi.org/project/repo-parser. Use at your own risk!
+
+## Local development
+
+You can experiment with the local demo by running `make example`.
+It should live-reload as you make changes in the `example/repo` directory.
+
+For other tasks, look at the (very simple) `Makefile` in the root directory.
+

repo_parser-0.0.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+repo_parser/__init__.py,sha256=JRPNDVsbAMBf_yiRP6Xm13kpnJEvYhqMph-OFem67P8,283
+repo_parser/cli.py,sha256=ze4vBjiF8LriRS0qFSx1IN6iWyC4h50tZzrzE4jYgxg,4596
+repo_parser/filesystem.py,sha256=q8ZiTvp2y9lhJdbES6drMVQhORMd1j0AUEKMGnS3Sas,3602
+repo_parser/processor.py,sha256=O5AZisIY5GzX0SBCMuGeWiDtnNd5_nDHVmZuhwn-82Q,254
+repo_parser/resource.py,sha256=jmLFI1VPBnHHDxGp9gqe9niKr6h7eHM68cwiNhyya3M,10607
+repo_parser/templates/idr.md,sha256=fB7RbKwkZnu8BHJRYEoSejVYcpvDlGRBR5dJtmD3UGg,1854
+repo_parser-0.0.3.dist-info/entry_points.txt,sha256=jH0jHkd3zXSJPZObgmTp8sMplnqfd31VN2VnINnYsQE,42
+repo_parser-0.0.3.dist-info/licenses/LICENSE,sha256=HpJ9NsyYs74vwDiFpunj0wdxKEOS74VFNJb7E2SdZis,1088
+repo_parser-0.0.3.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+repo_parser-0.0.3.dist-info/METADATA,sha256=PeeQE6BzRcpVfweS9ilQMhlsUEJiEjkbFyw-JrUsxWg,3484
+repo_parser-0.0.3.dist-info/RECORD,,

repo_parser-0.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

repo_parser-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+rp=repo_parser.cli:app
+

repo_parser-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023-2024 William Lachance
+
+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.