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

git_recap/providers/local_fetcher.py

@@ -0,0 +1,390 @@
+import os
+import subprocess
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+from git_recap.providers.base_fetcher import BaseFetcher
+
+
+class LocalFetcher(BaseFetcher):
+    """
+    Fetcher implementation for local Git repositories.
+    
+    Works directly on a local git repository path without cloning.
+    Supports fetching commits, authors, and branch information.
+    """
+
+    def __init__(
+        self,
+        repo_path: str,
+        authors: Optional[List[str]] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        repo_filter: Optional[List[str]] = None,
+        validate_repo: bool = True
+    ):
+        """
+        Initialize the LocalFetcher.
+        
+        Args:
+            repo_path: Path to the local git repository
+            authors: List of author names to filter by (optional)
+            start_date: Start date for filtering commits (optional)
+            end_date: End date for filtering commits (optional)
+            repo_filter: List of repository names to filter (optional)
+            validate_repo: Whether to validate the repository path (default: True)
+        """
+        super().__init__(pat=None, start_date=start_date, end_date=end_date, repo_filter=repo_filter, authors=authors)
+        self.repo_path = repo_path
+        if validate_repo:
+            self._validate_repo()
+
+    def _validate_repo(self) -> None:
+        """
+        Validate that the provided path is a valid git repository.
+        
+        Raises:
+            ValueError: If the path is not a valid git repository.
+        """
+        if not os.path.exists(self.repo_path):
+            raise ValueError(f"Path does not exist: {self.repo_path}")
+        
+        if not os.path.isdir(self.repo_path):
+            raise ValueError(f"Path is not a directory: {self.repo_path}")
+        
+        git_dir = os.path.join(self.repo_path, '.git')
+        if not os.path.exists(git_dir):
+            raise ValueError(f"Not a git repository: {self.repo_path}")
+        
+        # Verify it's a valid git repo by running a simple command
+        try:
+            _result = subprocess.run(
+                ["git", "-C", self.repo_path, "rev-parse", "--git-dir"],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=10
+            )
+        except subprocess.TimeoutExpired:
+            raise ValueError(f"Timeout while validating git repository: {self.repo_path}")
+        except subprocess.CalledProcessError as e:
+            raise ValueError(f"Invalid git repository: {self.repo_path}. Error: {e.stderr}")
+
+    @property
+    def repos_names(self) -> List[str]:
+        """
+        Return the repository name.
+
+        Returns:
+            List[str]: List containing the repository name (single item).
+        """
+        repo_name = os.path.basename(self.repo_path)
+        return [repo_name]
+
+    def _run_git_log(self, extra_args: List[str] = None) -> List[Dict[str, Any]]:
+        """
+        Run git log command with common arguments and parse output.
+
+        Args:
+            extra_args (List[str], optional): Additional git log arguments.
+
+        Returns:
+            List[Dict[str, Any]]: Parsed commit entries.
+        """
+        args = [
+            "git",
+            "-C", self.repo_path,
+            "log",
+            "--pretty=format:%H|%an|%ad|%s",
+            "--date=iso",
+            "--all"
+        ]
+
+        if self.start_date:
+            args.extend(["--since", self.start_date.isoformat()])
+        if self.end_date:
+            args.extend(["--until", self.end_date.isoformat()])
+        if self.authors:
+            authors_filter = "|".join(self.authors)
+            args.extend(["--author", authors_filter])
+        if extra_args:
+            args.extend(extra_args)
+
+        try:
+            result = subprocess.run(
+                args,
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=120
+            )
+            return self._parse_git_log(result.stdout)
+        except subprocess.TimeoutExpired:
+            return []
+        except subprocess.CalledProcessError:
+            return []
+
+    def _parse_git_log(self, log_output: str) -> List[Dict[str, Any]]:
+        """
+        Parse git log output into structured data.
+
+        Args:
+            log_output (str): Raw git log output.
+
+        Returns:
+            List[Dict[str, Any]]: Parsed commit entries.
+        """
+        entries = []
+        for line in log_output.splitlines():
+            if not line.strip():
+                continue
+
+            try:
+                sha, author, date_str, message = line.split("|", 3)
+                timestamp = datetime.fromisoformat(date_str)
+
+                if self.start_date and timestamp < self.start_date:
+                    continue
+                if self.end_date and timestamp > self.end_date:
+                    continue
+
+                entries.append({
+                    "type": "commit",
+                    "repo": self.repos_names[0],
+                    "message": message,
+                    "sha": sha,
+                    "author": author,
+                    "timestamp": timestamp
+                })
+            except ValueError:
+                continue
+
+        return entries
+
+    def fetch_commits(self) -> List[Dict[str, Any]]:
+        """
+        Fetch commits from the local repository.
+
+        Returns:
+            List[Dict[str, Any]]: List of commit entries.
+        """
+        return self._run_git_log()
+
+    def fetch_pull_requests(self) -> List[Dict[str, Any]]:
+        """
+        Fetch pull requests (not applicable for local repositories).
+
+        Returns:
+            List[Dict[str, Any]]: Empty list (PRs are platform-specific).
+        """
+        return []
+
+    def fetch_issues(self) -> List[Dict[str, Any]]:
+        """
+        Fetch issues (not applicable for local repositories).
+
+        Returns:
+            List[Dict[str, Any]]: Empty list (issues are platform-specific).
+        """
+        return []
+
+    def fetch_releases(self) -> List[Dict[str, Any]]:
+        """
+        Fetch releases for the repository.
+        Not applicable for local repositories.
+
+        Raises:
+            NotImplementedError: Always, since release fetching is not supported for LocalFetcher.
+        """
+        raise NotImplementedError(
+            "Release fetching is not supported for local repositories (LocalFetcher)."
+        )
+
+    def get_branches(self) -> List[str]:
+        """
+        Get all branches in the local repository.
+
+        Returns:
+            List[str]: List of branch names (both local and remote).
+        """
+        try:
+            # Get local branches
+            result = subprocess.run(
+                ["git", "-C", self.repo_path, "branch", "--format=%(refname:short)"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            branches = [b.strip() for b in result.stdout.splitlines() if b.strip()]
+
+            # Get remote branches
+            result_remote = subprocess.run(
+                ["git", "-C", self.repo_path, "branch", "-r", "--format=%(refname:short)"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            remote_branches = [
+                b.strip() for b in result_remote.stdout.splitlines() 
+                if b.strip() and not b.endswith('/HEAD')
+            ]
+
+            return branches + remote_branches
+        except subprocess.CalledProcessError:
+            return []
+
+    def get_valid_target_branches(self, source_branch: str) -> List[str]:
+        """
+        Get branches that can receive a pull request from the source branch.
+        Not applicable for local repositories.
+
+        Args:
+            source_branch (str): The source branch name.
+
+        Returns:
+            List[str]: Empty list (PRs are platform-specific).
+
+        Raises:
+            NotImplementedError: Always, since PR validation is not supported for LocalFetcher.
+        """
+        raise NotImplementedError(
+            "Pull request target branch validation is not supported for local repositories (LocalFetcher)."
+        )
+
+    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.
+        Not applicable for local repositories.
+
+        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]: Empty dict (PRs are platform-specific).
+
+        Raises:
+            NotImplementedError: Always, since PR creation is not supported for LocalFetcher.
+        """
+        raise NotImplementedError(
+            "Pull request creation is not supported for local repositories (LocalFetcher)."
+        )
+
+    def get_authors(self, repo_names: List[str]) -> List[Dict[str, str]]:
+        """
+        Retrieve unique authors from the local repository using git log.
+
+        Args:
+            repo_names: Not used for local fetcher (single repo only).
+
+        Returns:
+            List[Dict[str, str]]: List of unique author dictionaries with name and email.
+        """
+        authors_set = set()
+
+        try:
+            # Get authors from commit history
+            cmd = [
+                'git', '-C', self.repo_path, 'log',
+                '--all',
+                '--format=%an|%ae'
+            ]
+
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+
+            for line in result.stdout.strip().split('\n'):
+                if '|' in line:
+                    name, email = line.split('|', 1)
+                    authors_set.add((name.strip(), email.strip()))
+
+            # Also get committers
+            cmd_committer = [
+                'git', '-C', self.repo_path, 'log',
+                '--all',
+                '--format=%cn|%ce'
+            ]
+
+            result_committer = subprocess.run(
+                cmd_committer,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+
+            for line in result_committer.stdout.strip().split('\n'):
+                if '|' in line:
+                    name, email = line.split('|', 1)
+                    authors_set.add((name.strip(), email.strip()))
+
+            authors_list = [
+                {"name": name, "email": email}
+                for name, email in sorted(authors_set)
+            ]
+
+            return authors_list
+
+        except subprocess.CalledProcessError as e:
+            print(f"Git command failed: {e}")
+            return []
+        except Exception as e:
+            print(f"Error in get_authors: {e}")
+            return []
+
+    def get_current_author(self) -> Optional[Dict[str, str]]:
+        """
+        Retrieve the current git user's information from local configuration.
+
+        Returns:
+            Optional[Dict[str, str]]: Dictionary with 'name' and 'email' keys,
+                                     or None if not configured.
+        """
+        try:
+            # Get user name
+            result_name = subprocess.run(
+                ["git", "-C", self.repo_path, "config", "user.name"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            user_name = result_name.stdout.strip()
+
+            # Get user email
+            result_email = subprocess.run(
+                ["git", "-C", self.repo_path, "config", "user.email"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            user_email = result_email.stdout.strip()
+
+            if user_name and user_email:
+                return {
+                    "name": user_name,
+                    "email": user_email
+                }
+            return None
+        except subprocess.CalledProcessError:
+            return None
+        except Exception as e:
+            print(f"Error retrieving current author: {e}")
+            return None

git_recap/providers/url_fetcher.py

@@ -2,7 +2,6 @@ import os
 import re
 import shutil
 import subprocess
-from pathlib import Path
 import tempfile
 from typing import List, Dict, Any, Optional
 from datetime import datetime
@@ -36,7 +35,7 @@ class URLFetcher(BaseFetcher):
         )
         self.url = self._normalize_url(url)
         self.temp_dir = None
-        # self._validate_url()
+        self.repo_path = None
         self._clone_repo()
 
     def _normalize_url(self, url: str) -> str:
@@ -59,7 +58,7 @@ class URLFetcher(BaseFetcher):
                 capture_output=True,
                 text=True,
                 check=True,
-                timeout=10  # Add timeout to prevent hanging
+                timeout=10
             )
             if not result.stdout.strip():
                 raise ValueError(f"URL {self.url} points to an empty repository")
@@ -71,8 +70,8 @@ class URLFetcher(BaseFetcher):
     def _clone_repo(self) -> None:
         """Clone the repository to a temporary directory with all branches."""
         self.temp_dir = tempfile.mkdtemp(prefix="gitrecap_")
+        self.repo_path = self.temp_dir
         try:
-            # First clone with --no-checkout to save bandwidth
             subprocess.run(
                 ["git", "clone", "--no-checkout", self.url, self.temp_dir],
                 check=True,
@@ -81,7 +80,6 @@ class URLFetcher(BaseFetcher):
                 timeout=300
             )
 
-            # Fetch all branches
             subprocess.run(
                 ["git", "-C", self.temp_dir, "fetch", "--all"],
                 check=True,
@@ -90,7 +88,6 @@ class URLFetcher(BaseFetcher):
                 timeout=300
             )
 
-            # Verify the cloned repository has at least one commit
             verify_result = subprocess.run(
                 ["git", "-C", self.temp_dir, "rev-list", "--count", "--all"],
                 capture_output=True,
@@ -138,7 +135,6 @@ class URLFetcher(BaseFetcher):
                 check=True
             )
             branches = [b.strip() for b in result.stdout.splitlines() if b.strip()]
-            # Filter out HEAD reference if present
             return [b for b in branches if not b.endswith('/HEAD')]
         except subprocess.CalledProcessError:
             return []
@@ -154,7 +150,7 @@ class URLFetcher(BaseFetcher):
             "log",
             "--pretty=format:%H|%an|%ad|%s",
             "--date=iso",
-            "--all"  # Include all branches and tags
+            "--all"
         ]
 
         if self.start_date:
@@ -173,7 +169,7 @@ class URLFetcher(BaseFetcher):
                 capture_output=True,
                 text=True,
                 check=True,
-                timeout=120  # Increased timeout for large repositories
+                timeout=120
             )
             return self._parse_git_log(result.stdout)
         except subprocess.TimeoutExpired:
@@ -206,7 +202,7 @@ class URLFetcher(BaseFetcher):
                     "timestamp": timestamp
                 })
             except ValueError:
-                continue  # Skip malformed log entries
+                continue
 
         return entries
 
@@ -229,16 +225,153 @@ 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 get_authors(self, repo_names: List[str]) -> List[Dict[str, str]]:
+        """
+        Retrieve unique authors from cloned repository using git log.
+        
+        Args:
+            repo_names: Not used for URL fetcher (single repo only).
+        
+        Returns:
+            List of unique author dictionaries with name and email.
+        """
+        authors_set = set()
+        
+        try:
+            if not hasattr(self, 'repo_path') or not os.path.exists(self.repo_path):
+                print("Repository not cloned yet")
+                return []
+            
+            cmd = [
+                'git', '-C', self.repo_path, 'log',
+                '--all',
+                '--format=%an|%ae'
+            ]
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            
+            for line in result.stdout.strip().split('\n'):
+                if '|' in line:
+                    name, email = line.split('|', 1)
+                    authors_set.add((name.strip(), email.strip()))
+            
+            cmd_committer = [
+                'git', '-C', self.repo_path, 'log',
+                '--all',
+                '--format=%cn|%ce'
+            ]
+            
+            result_committer = subprocess.run(
+                cmd_committer,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            
+            for line in result_committer.stdout.strip().split('\n'):
+                if '|' in line:
+                    name, email = line.split('|', 1)
+                    authors_set.add((name.strip(), email.strip()))
+            
+            authors_list = [
+                {"name": name, "email": email}
+                for name, email in sorted(authors_set)
+            ]
+            
+            return authors_list
+        
+        except subprocess.CalledProcessError as e:
+            print(f"Git command failed: {e}")
+            return []
+        except Exception as e:
+            print(f"Error in get_authors: {e}")
+            return []
+
+    def get_current_author(self) -> Optional[Dict[str, str]]:
+        """
+        Retrieve the current authenticated user's information.
+        
+        For URL-based cloning, there is no authenticated user context,
+        so this method always returns None.
+        
+        Returns:
+            None: URL fetcher has no default author.
+        """
+        return None
+
     def clear(self) -> None:
         """Clean up temporary directory."""
         if self.temp_dir and os.path.exists(self.temp_dir):
             try:
                 shutil.rmtree(self.temp_dir, ignore_errors=True)
             except Exception:
-                pass  # Ensure we don't raise during cleanup
+                pass
             finally:
-                self.temp_dir = None
+                self.temp_dir = None
+                self.repo_path = None

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

@@ -1,25 +1,30 @@
 Metadata-Version: 2.4
 Name: git-recap
-Version: 0.1.4
+Version: 0.1.6
 Summary: A modular Python tool that aggregates and formats user-authored messages from repositories.
-Author: Bruno V.
-Author-email: bruno.vitorino@tecnico.ulisboa.pt
+Author-email: "Bruno V." <bruno.vitorino@tecnico.ulisboa.pt>
+License: MIT
+Project-URL: Homepage, https://github.com/BrunoV21/GitRecap
+Project-URL: Documentation, https://github.com/BrunoV21/GitRecap#readme
+Project-URL: Repository, https://github.com/BrunoV21/GitRecap.git
+Project-URL: Issues, https://github.com/BrunoV21/GitRecap/issues
+Keywords: git,github,gitlab,azure-devops,version-control,repository
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyGithub==2.6.1
 Requires-Dist: azure-devops==7.1.0b4
 Requires-Dist: python-gitlab==5.6.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=0.990; extra == "dev"
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: summary
 
 <a href="https://www.uneed.best/tool/gitrecap">
   <img src="https://www.uneed.best/POTD2A.png" style="width: 250px;" alt="Uneed POTD2 Badge" />

git_recap-0.1.6.dist-info/RECORD

@@ -0,0 +1,17 @@
+git_recap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_recap/cli.py,sha256=oWSHWiIW1I6XyxyzDRVyMukCKs467KaIgDJzg40IsAg,8530
+git_recap/fetcher.py,sha256=7_EZ3Af5jP_dldPbGrgpT-Gzmc1gg1NDxY2TfRuAnyc,3552
+git_recap/utils.py,sha256=NAG0cvm1sYKEQD5E9PueduB3CZQRTahrioxZNgwwmi4,5481
+git_recap/providers/__init__.py,sha256=pGAdkLeklLMD8feL7gZvEeHvsSvZlGpezbPOPKsqH3o,409
+git_recap/providers/azure_fetcher.py,sha256=_hAgt1Za-uGkRuve7-FKq_bQ9-nAlLexD0GsgTBl_1k,14675
+git_recap/providers/base_fetcher.py,sha256=ZANa-vdSpI_wDQ2U0QillSx6V4ljqxuFBn9bjSqq9bg,8633
+git_recap/providers/github_fetcher.py,sha256=n87yYlYmsUyi3O0usqXyYP4ZJ-x3FFE-o9e_tLjDGv0,21638
+git_recap/providers/gitlab_fetcher.py,sha256=IHC4CE3E_0ri2AhS7a5DPesOrSl5YNcP_hYBHzbIZGo,12376
+git_recap/providers/local_fetcher.py,sha256=oCeddwzE7cJzMLCPWCOFRkNqvH45EM2KxxsOg3W5LME,12781
+git_recap/providers/url_fetcher.py,sha256=pSd2PSeYpPsHdws6LsQ3ruZdDd9rz5LN6U7dxF_eHLU,12939
+git_recap-0.1.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+git_recap-0.1.6.dist-info/METADATA,sha256=jXU579yPa9QJHb0s0dII9P35FxYI7tkgmUetuGkAZF8,5404
+git_recap-0.1.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+git_recap-0.1.6.dist-info/entry_points.txt,sha256=28MZTffgA2q41JRbRHe1TQ-u1XtsyJK021ThKbp0bSU,49
+git_recap-0.1.6.dist-info/top_level.txt,sha256=1JUKd3WPB8c3LcD1deIW-1UTmYzA0zJqwugAz72YZ_o,10
+git_recap-0.1.6.dist-info/RECORD,,

{git_recap-0.1.4.dist-info → git_recap-0.1.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any