git-recap 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

git_recap/providers/azure_fetcher.py

@@ -1,7 +1,7 @@
 from azure.devops.connection import Connection
 from msrest.authentication import BasicAuthentication
 from datetime import datetime
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 from git_recap.providers.base_fetcher import BaseFetcher
 
 class AzureFetcher(BaseFetcher):
@@ -236,4 +236,81 @@ class AzureFetcher(BaseFetcher):
             NotImplementedError: Always, since release fetching is not supported for AzureFetcher.
         """
         # If Azure DevOps release fetching is supported in the future, implement logic here.
-        raise NotImplementedError("Release fetching is not supported for Azure DevOps (AzureFetcher).")
+        raise NotImplementedError("Release fetching is not supported for Azure DevOps (AzureFetcher).")
+
+    def get_branches(self) -> List[str]:
+        """
+        Get all branches in the repository.
+        
+        Returns:
+            List[str]: List of branch names.
+        
+        Raises:
+            NotImplementedError: Always, since branch listing is not yet implemented for AzureFetcher.
+        """
+        # TODO: Implement get_branches() for Azure DevOps support
+        # This would use: git_client.get_branches(repository_id, project)
+        # and extract branch names from the returned objects
+        raise NotImplementedError("Branch listing is not yet implemented for Azure DevOps (AzureFetcher).")
+
+    def get_valid_target_branches(self, source_branch: str) -> List[str]:
+        """
+        Get branches that can receive a pull request from the source branch.
+        
+        Validates that the source branch exists, filters out branches with existing
+        open PRs from source, excludes the source branch itself, and optionally
+        checks if source is ahead of target.
+        
+        Args:
+            source_branch (str): The source branch name.
+        
+        Returns:
+            List[str]: List of valid target branch names.
+        
+        Raises:
+            NotImplementedError: Always, since PR target validation is not yet implemented for AzureFetcher.
+        """
+        # TODO: Implement get_valid_target_branches() for Azure DevOps support
+        # This would require:
+        # 1. Verify source_branch exists using git_client.get_branch()
+        # 2. Get all branches using get_branches()
+        # 3. Filter out source branch
+        # 4. Check for existing pull requests using git_client.get_pull_requests()
+        # 5. Filter out branches with existing open PRs from source
+        # 6. Optionally check branch policies and protection rules
+        raise NotImplementedError("Pull request target branch validation is not yet implemented for Azure DevOps (AzureFetcher).")
+
+    def create_pull_request(
+        self,
+        head_branch: str,
+        base_branch: str,
+        title: str,
+        body: str,
+        draft: bool = False,
+        reviewers: Optional[List[str]] = None,
+        assignees: Optional[List[str]] = None,
+        labels: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Create a pull request between two branches with optional metadata.
+        
+        Args:
+            head_branch: Source branch for the PR.
+            base_branch: Target branch for the PR.
+            title: PR title.
+            body: PR description.
+            draft: Whether to create as draft PR (default: False).
+            reviewers: List of reviewer usernames (optional).
+            assignees: List of assignee usernames (optional).
+            labels: List of label names (optional).
+        
+        Returns:
+            Dict[str, Any]: Dictionary containing PR metadata (url, number, state, success) or error information.
+        
+        Raises:
+            NotImplementedError: Always, since PR creation is not yet implemented for AzureFetcher.
+        """
+        # TODO: Implement create_pull_request() for Azure DevOps support
+        # This would use: git_client.create_pull_request() with appropriate parameters
+        # Would need to handle reviewers, work item links (assignees), labels, and draft status
+        raise NotImplementedError("Pull request creation is not yet implemented for Azure DevOps (AzureFetcher).")

git_recap/providers/base_fetcher.py

@@ -90,6 +90,72 @@ class BaseFetcher(ABC):
         """
         raise NotImplementedError("Release fetching is not implemented for this provider.")
 
+    @abstractmethod
+    def get_branches(self) -> List[str]:
+        """
+        Get all branches in the repository.
+        
+        Returns:
+            List[str]: List of branch names.
+        
+        Raises:
+            NotImplementedError: Subclasses must implement this method.
+        """
+        raise NotImplementedError("Subclasses must implement get_branches() to return all repository branches")
+
+    @abstractmethod
+    def get_valid_target_branches(self, source_branch: str) -> List[str]:
+        """
+        Get branches that can receive a pull request from the source branch.
+        
+        Validates that the source branch exists, filters out branches with existing
+        open PRs from source, excludes the source branch itself, and optionally
+        checks if source is ahead of target.
+        
+        Args:
+            source_branch (str): The source branch name.
+        
+        Returns:
+            List[str]: List of valid target branch names.
+        
+        Raises:
+            NotImplementedError: Subclasses must implement this method.
+        """
+        raise NotImplementedError("Subclasses must implement get_valid_target_branches() to return valid PR target branches for the given source branch")
+
+    @abstractmethod
+    def create_pull_request(
+        self,
+        head_branch: str,
+        base_branch: str,
+        title: str,
+        body: str,
+        draft: bool = False,
+        reviewers: Optional[List[str]] = None,
+        assignees: Optional[List[str]] = None,
+        labels: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Create a pull request between two branches with optional metadata.
+        
+        Args:
+            head_branch: Source branch for the PR.
+            base_branch: Target branch for the PR.
+            title: PR title.
+            body: PR description.
+            draft: Whether to create as draft PR (default: False).
+            reviewers: List of reviewer usernames (optional).
+            assignees: List of assignee usernames (optional).
+            labels: List of label names (optional).
+        
+        Returns:
+            Dict[str, Any]: Dictionary containing PR metadata (url, number, state, success) or error information.
+        
+        Raises:
+            NotImplementedError: Subclasses must implement this method.
+        """
+        raise NotImplementedError("Subclasses must implement create_pull_request() to create a pull request with the specified parameters")
+
     def get_authored_messages(self) -> List[Dict[str, Any]]:
         """
         Aggregates all commit, pull request, and issue entries into a single list,

git_recap/providers/github_fetcher.py

@@ -1,7 +1,12 @@
 from github import Github
+from github import GithubException
 from datetime import datetime
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 from git_recap.providers.base_fetcher import BaseFetcher
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 class GitHubFetcher(BaseFetcher):
     """
@@ -59,6 +64,32 @@ class GitHubFetcher(BaseFetcher):
                         break
         return entries
 
+    def fetch_branch_diff_commits(self, source_branch: str, target_branch: str) -> List[Dict[str, Any]]:
+        entries = []
+        processed_commits = set()
+        for repo in self.repos:
+            if self.repo_filter and repo.name not in self.repo_filter:
+                continue
+            try:
+                comparison = repo.compare(target_branch, source_branch)
+                for commit in comparison.commits:
+                    commit_date = commit.commit.author.date
+                    sha = commit.sha
+                    if sha not in processed_commits:
+                        entry = {
+                            "type": "commit",
+                            "repo": repo.name,
+                            "message": commit.commit.message.strip(),
+                            "timestamp": commit_date,
+                            "sha": sha,
+                        }
+                        entries.append(entry)
+                        processed_commits.add(sha)
+            except GithubException as e:
+                logger.error(f"Failed to compare branches in {repo.name}: {str(e)}")
+                continue
+        return entries
+
     def fetch_pull_requests(self) -> List[Dict[str, Any]]:
         entries = []
         # Maintain a local set to skip duplicate commits already captured in a PR.
@@ -174,4 +205,204 @@ class GitHubFetcher(BaseFetcher):
             except Exception:
                 # If fetching releases fails for a repo, skip it (could be permissions or no releases)
                 continue
-        return releases
+        return releases
+
+    def get_branches(self) -> List[str]:
+        """
+        Get all branches in the repository.
+        Returns:
+            List[str]: List of branch names.
+        Raises:
+            Exception: If API rate limits are exceeded or authentication fails.
+        """
+        logger.debug("Fetching branches from all accessible repositories")
+        try:
+            branches = []
+            for repo in self.repos:
+                if self.repo_filter and repo.name not in self.repo_filter:
+                    continue
+                logger.debug(f"Fetching branches for repository: {repo.name}")
+                repo_branches = repo.get_branches()
+                for branch in repo_branches:
+                    branches.append(branch.name)
+            logger.debug(f"Successfully fetched {len(branches)} branches")
+            return branches
+        except GithubException as e:
+            if e.status == 403:
+                logger.error(f"Rate limit exceeded or authentication failed: {str(e)}")
+                raise Exception(f"Failed to fetch branches: Rate limit exceeded or authentication failed - {str(e)}")
+            elif e.status == 401:
+                logger.error(f"Authentication failed: {str(e)}")
+                raise Exception(f"Failed to fetch branches: Authentication failed - {str(e)}")
+            else:
+                logger.error(f"GitHub API error while fetching branches: {str(e)}")
+                raise Exception(f"Failed to fetch branches: {str(e)}")
+        except Exception as e:
+            logger.error(f"Unexpected error while fetching branches: {str(e)}")
+            raise Exception(f"Failed to fetch branches: {str(e)}")
+
+    def get_valid_target_branches(self, source_branch: str) -> List[str]:
+        """
+        Get branches that can receive a pull request from the source branch.
+        Validates that the source branch exists, filters out branches with existing
+        open PRs from source, excludes the source branch itself, and optionally
+        checks if source is ahead of target.
+        Args:
+            source_branch (str): The source branch name.
+        Returns:
+            List[str]: List of valid target branch names.
+        Raises:
+            ValueError: If source branch does not exist.
+            Exception: If API errors occur during validation.
+        """
+        logger.debug(f"Validating target branches for source branch: {source_branch}")
+        try:
+            all_branches = self.get_branches()
+            if source_branch not in all_branches:
+                logger.error(f"Source branch '{source_branch}' does not exist")
+                raise ValueError(f"Source branch '{source_branch}' does not exist")
+            valid_targets = []
+            for repo in self.repos:
+                if self.repo_filter and repo.name not in self.repo_filter:
+                    continue
+                logger.debug(f"Processing repository: {repo.name}")
+                repo_branches = [branch.name for branch in repo.get_branches()]
+                # Get existing open PRs from source branch
+                try:
+                    open_prs = repo.get_pulls(state='open', head=source_branch)
+                except GithubException as e:
+                    logger.error(f"GitHub API error while getting PRs: {str(e)}")
+                    raise Exception(f"Failed to validate target branches: {str(e)}")
+                existing_pr_targets = set()
+                for pr in open_prs:
+                    existing_pr_targets.add(pr.base.ref)
+                    logger.debug(f"Found existing PR from {source_branch} to {pr.base.ref}")
+                for branch_name in repo_branches:
+                    if branch_name == source_branch:
+                        logger.debug(f"Excluding source branch: {branch_name}")
+                        continue
+                    if branch_name in existing_pr_targets:
+                        logger.debug(f"Excluding branch with existing PR: {branch_name}")
+                        continue
+                    # Optionally check if source is ahead of target (performance cost)
+                    valid_targets.append(branch_name)
+                    logger.debug(f"Valid target branch: {branch_name}")
+            logger.debug(f"Found {len(valid_targets)} valid target branches")
+            return valid_targets
+        except ValueError:
+            raise
+        except GithubException as e:
+            logger.error(f"GitHub API error while validating target branches: {str(e)}")
+            raise Exception(f"Failed to validate target branches: {str(e)}")
+        except Exception as e:
+            logger.error(f"Unexpected error while validating target branches: {str(e)}")
+            raise Exception(f"Failed to validate target branches: {str(e)}")
+
+    def create_pull_request(
+        self,
+        head_branch: str,
+        base_branch: str,
+        title: str,
+        body: str,
+        draft: bool = False,
+        reviewers: Optional[List[str]] = None,
+        assignees: Optional[List[str]] = None,
+        labels: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Create a pull request between two branches with optional metadata.
+        Args:
+            head_branch: Source branch for the PR.
+            base_branch: Target branch for the PR.
+            title: PR title.
+            body: PR description.
+            draft: Whether to create as draft PR (default: False).
+            reviewers: List of reviewer usernames (optional).
+            assignees: List of assignee usernames (optional).
+            labels: List of label names (optional).
+        Returns:
+            Dict[str, Any]: Dictionary containing PR metadata or error information.
+        Raises:
+            ValueError: If branches don't exist or PR already exists.
+        """
+        logger.info(f"Creating pull request from {head_branch} to {base_branch}")
+        try:
+            all_branches = self.get_branches()
+            if head_branch not in all_branches:
+                logger.error(f"Head branch '{head_branch}' does not exist")
+                raise ValueError(f"Head branch '{head_branch}' does not exist")
+            if base_branch not in all_branches:
+                logger.error(f"Base branch '{base_branch}' does not exist")
+                raise ValueError(f"Base branch '{base_branch}' does not exist")
+            for repo in self.repos:
+                if self.repo_filter and repo.name not in self.repo_filter:
+                    continue
+                logger.debug(f"Checking for existing PRs in repository: {repo.name}")
+                try:
+                    existing_prs = repo.get_pulls(state='open', head=head_branch, base=base_branch)
+                except GithubException as e:
+                    logger.error(f"GitHub API error while getting PRs: {str(e)}")
+                    raise
+                if hasattr(existing_prs, "totalCount") and existing_prs.totalCount > 0:
+                    logger.error(f"Pull request already exists from {head_branch} to {base_branch}")
+                    raise ValueError(f"Pull request already exists from {head_branch} to {base_branch}")
+                elif isinstance(existing_prs, list) and len(existing_prs) > 0:
+                    logger.error(f"Pull request already exists from {head_branch} to {base_branch}")
+                    raise ValueError(f"Pull request already exists from {head_branch} to {base_branch}")
+                logger.info(f"Creating pull request in repository: {repo.name}")
+                try:
+                    pr = repo.create_pull(
+                        title=title,
+                        body=body,
+                        head=head_branch,
+                        base=base_branch,
+                        draft=draft
+                    )
+                    logger.info(f"Pull request created successfully: {pr.html_url}")
+                    if reviewers and len(reviewers) > 0:
+                        try:
+                            logger.debug(f"Adding reviewers: {reviewers}")
+                            pr.create_review_request(reviewers=reviewers)
+                            logger.info(f"Successfully added reviewers: {reviewers}")
+                        except GithubException as e:
+                            logger.warning(f"Failed to add reviewers: {str(e)}")
+                    if assignees and len(assignees) > 0:
+                        try:
+                            logger.debug(f"Adding assignees: {assignees}")
+                            pr.add_to_assignees(*assignees)
+                            logger.info(f"Successfully added assignees: {assignees}")
+                        except GithubException as e:
+                            logger.warning(f"Failed to add assignees: {str(e)}")
+                    if labels and len(labels) > 0:
+                        try:
+                            logger.debug(f"Adding labels: {labels}")
+                            pr.add_to_labels(*labels)
+                            logger.info(f"Successfully added labels: {labels}")
+                        except GithubException as e:
+                            logger.warning(f"Failed to add labels: {str(e)}")
+                    return {
+                        "url": pr.html_url,
+                        "number": pr.number,
+                        "state": pr.state,
+                        "success": True
+                    }
+                except GithubException as e:
+                    if e.status == 404:
+                        logger.error(f"Branch not found: {str(e)}")
+                        raise ValueError(f"Branch not found: {str(e)}")
+                    elif e.status == 403:
+                        logger.error(f"Permission denied: {str(e)}")
+                        raise GithubException(e.status, f"Permission denied: {str(e)}", e.headers)
+                    elif e.status == 422:
+                        logger.error(f"Merge conflict or validation error: {str(e)}")
+                        raise ValueError(f"Merge conflict or validation error: {str(e)}")
+                    else:
+                        logger.error(f"GitHub API error: {str(e)}")
+                        raise
+            logger.error("No repository found to create pull request")
+            raise ValueError("No repository found to create pull request")
+        except (ValueError, GithubException):
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error while creating pull request: {str(e)}")
+            raise Exception(f"Failed to create pull request: {str(e)}")

git_recap/providers/gitlab_fetcher.py

@@ -1,6 +1,6 @@
 import gitlab
 from datetime import datetime
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 from git_recap.providers.base_fetcher import BaseFetcher
 
 class GitLabFetcher(BaseFetcher):
@@ -183,5 +183,67 @@ class GitLabFetcher(BaseFetcher):
         Raises:
             NotImplementedError: Always, since release fetching is not supported for GitLabFetcher.
         """
-        # If GitLab release fetching is supported in the future, implement logic here.
-        raise NotImplementedError("Release fetching is not supported for GitLab (GitLabFetcher).")
+        raise NotImplementedError("Release fetching is not supported for GitLab (GitLabFetcher).")
+
+    def get_branches(self) -> List[str]:
+        """
+        Get all branches in the repository.
+        
+        Returns:
+            List[str]: List of branch names.
+        
+        Raises:
+            NotImplementedError: Always, since branch listing is not yet implemented for GitLabFetcher.
+        """
+        raise NotImplementedError("Branch listing is not yet implemented for GitLab (GitLabFetcher).")
+
+    def get_valid_target_branches(self, source_branch: str) -> List[str]:
+        """
+        Get branches that can receive a pull request from the source branch.
+        
+        Validates that the source branch exists, filters out branches with existing
+        open PRs from source, excludes the source branch itself, and optionally
+        checks if source is ahead of target.
+        
+        Args:
+            source_branch (str): The source branch name.
+        
+        Returns:
+            List[str]: List of valid target branch names.
+        
+        Raises:
+            NotImplementedError: Always, since PR target validation is not yet implemented for GitLabFetcher.
+        """
+        raise NotImplementedError("Pull request target branch validation is not yet implemented for GitLab (GitLabFetcher).")
+
+    def create_pull_request(
+        self,
+        head_branch: str,
+        base_branch: str,
+        title: str,
+        body: str,
+        draft: bool = False,
+        reviewers: Optional[List[str]] = None,
+        assignees: Optional[List[str]] = None,
+        labels: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Create a pull request (merge request) between two branches with optional metadata.
+        
+        Args:
+            head_branch: Source branch for the PR.
+            base_branch: Target branch for the PR.
+            title: PR title.
+            body: PR description.
+            draft: Whether to create as draft PR (default: False).
+            reviewers: List of reviewer usernames (optional).
+            assignees: List of assignee usernames (optional).
+            labels: List of label names (optional).
+        
+        Returns:
+            Dict[str, Any]: Dictionary containing PR metadata (url, number, state, success) or error information.
+        
+        Raises:
+            NotImplementedError: Always, since PR creation is not yet implemented for GitLabFetcher.
+        """
+        raise NotImplementedError("Pull request (merge request) creation is not yet implemented for GitLab (GitLabFetcher).")

git_recap/providers/url_fetcher.py

@@ -229,10 +229,67 @@ class URLFetcher(BaseFetcher):
         Raises:
             NotImplementedError: Always, since release fetching is not supported for URLFetcher.
         """
-        # If in the future, support for fetching releases from generic git repos is added,
-        # implement logic here (e.g., parse tags and annotate with metadata).
         raise NotImplementedError("Release fetching is not supported for generic Git URLs (URLFetcher).")
 
+    def get_branches(self) -> List[str]:
+        """
+        Get all branches in the repository.
+        
+        Returns:
+            List[str]: List of branch names.
+        
+        Raises:
+            NotImplementedError: Always, since branch listing is not yet implemented for URLFetcher.
+        """
+        raise NotImplementedError("Branch listing is not yet implemented for generic Git URLs (URLFetcher).")
+
+    def get_valid_target_branches(self, source_branch: str) -> List[str]:
+        """
+        Get branches that can receive a pull request from the source branch.
+        
+        Args:
+            source_branch (str): The source branch name.
+        
+        Returns:
+            List[str]: List of valid target branch names.
+        
+        Raises:
+            NotImplementedError: Always, since PR target validation is not supported for URLFetcher.
+        """
+        raise NotImplementedError("Pull request target branch validation is not supported for generic Git URLs (URLFetcher).")
+
+    def create_pull_request(
+        self,
+        head_branch: str,
+        base_branch: str,
+        title: str,
+        body: str,
+        draft: bool = False,
+        reviewers: Optional[List[str]] = None,
+        assignees: Optional[List[str]] = None,
+        labels: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Create a pull request between two branches.
+        
+        Args:
+            head_branch: Source branch for the PR.
+            base_branch: Target branch for the PR.
+            title: PR title.
+            body: PR description.
+            draft: Whether to create as draft PR (default: False).
+            reviewers: List of reviewer usernames (optional).
+            assignees: List of assignee usernames (optional).
+            labels: List of label names (optional).
+        
+        Returns:
+            Dict[str, Any]: Dictionary containing PR metadata or error information.
+        
+        Raises:
+            NotImplementedError: Always, since PR creation is not supported for URLFetcher.
+        """
+        raise NotImplementedError("Pull request creation is not supported for generic Git URLs (URLFetcher).")
+
     def clear(self) -> None:
         """Clean up temporary directory."""
         if self.temp_dir and os.path.exists(self.temp_dir):

{git_recap-0.1.4.dist-info → git_recap-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-recap
-Version: 0.1.4
+Version: 0.1.5
 Summary: A modular Python tool that aggregates and formats user-authored messages from repositories.
 Author: Bruno V.
 Author-email: bruno.vitorino@tecnico.ulisboa.pt

git_recap-0.1.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+git_recap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_recap/fetcher.py,sha256=oRlenzd9OsiBkCtpUgSZGlUoUnVpdkolUZhFOF1USBs,2677
+git_recap/utils.py,sha256=NAG0cvm1sYKEQD5E9PueduB3CZQRTahrioxZNgwwmi4,5481
+git_recap/providers/__init__.py,sha256=njrsu58KB60-wN78P0egm1lkQLIRq_PHLKM4WBt39Os,330
+git_recap/providers/azure_fetcher.py,sha256=ex1XX1SZ5xgWDSEQdsAtaKGaOK21pem_sWdoPZe2DNE,13152
+git_recap/providers/base_fetcher.py,sha256=yqVHTVAPlsDPD85SESx1u6SHeT_I9XLv41SnFo_ESPQ,7472
+git_recap/providers/github_fetcher.py,sha256=pSvpaAoE2-lK-rEwvpliOZh-oIiI0SulHMuiYaqiEts,19239
+git_recap/providers/gitlab_fetcher.py,sha256=i9W00H-DLyc-R--KxWbVy4CSDbORf_BmWcKveWulyzs,9752
+git_recap/providers/url_fetcher.py,sha256=hwASWC8j17P37qLoQxO6WeT1EZ2AqwtYc9kiXKHLBhQ,10753
+git_recap-0.1.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+git_recap-0.1.5.dist-info/METADATA,sha256=CbKCAeuSX9PBSxb8HpYea_OZi8dlzgIpB44Vgur9aNY,4946
+git_recap-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+git_recap-0.1.5.dist-info/top_level.txt,sha256=1JUKd3WPB8c3LcD1deIW-1UTmYzA0zJqwugAz72YZ_o,10
+git_recap-0.1.5.dist-info/RECORD,,

git_recap-0.1.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-git_recap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-git_recap/fetcher.py,sha256=oRlenzd9OsiBkCtpUgSZGlUoUnVpdkolUZhFOF1USBs,2677
-git_recap/utils.py,sha256=NAG0cvm1sYKEQD5E9PueduB3CZQRTahrioxZNgwwmi4,5481
-git_recap/providers/__init__.py,sha256=njrsu58KB60-wN78P0egm1lkQLIRq_PHLKM4WBt39Os,330
-git_recap/providers/azure_fetcher.py,sha256=nVJr77EYcuVDEAdY1B4UJCfHQTz8rE7s0Bmz3To1XVU,9722
-git_recap/providers/base_fetcher.py,sha256=EIkaqHBl5xyvNigK9jojlVxxbJrWXg0cNnRkmOLoPWk,4980
-git_recap/providers/github_fetcher.py,sha256=k9akil096PO29SNk2xaZPjRipnxS_sAO0GukWjMdSf4,7375
-git_recap/providers/gitlab_fetcher.py,sha256=apfaRrP7Dat0OKjo3InmNFwNEOiJShA8mSHPyW-9yKg,7333
-git_recap/providers/url_fetcher.py,sha256=oQqewY6uo-OgsCvZuodj6vWonHfeANrE-KSiCVH7il8,8741
-git_recap-0.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-git_recap-0.1.4.dist-info/METADATA,sha256=zC2u1gX9G2_VDmdFrJzE2nJykYfuztkHt9DxCgW6v9Q,4946
-git_recap-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-git_recap-0.1.4.dist-info/top_level.txt,sha256=1JUKd3WPB8c3LcD1deIW-1UTmYzA0zJqwugAz72YZ_o,10
-git_recap-0.1.4.dist-info/RECORD,,