yanex 0.1.0__py3-none-any.whl

yanex/core/environment.py

@@ -0,0 +1,146 @@
+"""
+Environment capture utilities.
+"""
+
+import platform
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import git
+
+from ..utils.exceptions import GitError
+from .git_utils import get_current_commit_info, get_git_repo, get_repository_info
+
+
+def capture_python_environment() -> Dict[str, Any]:
+    """
+    Capture Python environment information.
+
+    Returns:
+        Dictionary with Python environment details
+    """
+    return {
+        "python_version": sys.version,
+        "python_version_info": {
+            "major": sys.version_info.major,
+            "minor": sys.version_info.minor,
+            "micro": sys.version_info.micro,
+        },
+        "python_executable": sys.executable,
+        "python_path": sys.path.copy(),
+        "platform": platform.platform(),
+    }
+
+
+def capture_system_environment() -> Dict[str, Any]:
+    """
+    Capture system environment information.
+
+    Returns:
+        Dictionary with system details
+    """
+    return {
+        "platform": {
+            "system": platform.system(),
+            "release": platform.release(),
+            "version": platform.version(),
+            "machine": platform.machine(),
+            "processor": platform.processor(),
+            "architecture": platform.architecture(),
+        },
+        "hostname": platform.node(),
+        "working_directory": str(Path.cwd()),
+    }
+
+
+def capture_git_environment(repo_path: Optional[Path] = None) -> Dict[str, Any]:
+    """
+    Capture git environment information.
+
+    Args:
+        repo_path: Path to git repository, defaults to current directory
+
+    Returns:
+        Dictionary with git environment details
+    """
+    try:
+        repo = get_git_repo(repo_path)
+
+        git_info = {
+            "repository": get_repository_info(repo),
+            "commit": get_current_commit_info(repo),
+            "git_version": git.Git().version(),
+        }
+
+        return git_info
+
+    except GitError:
+        # If we can't get git info, return minimal info
+        return {
+            "repository": None,
+            "commit": None,
+            "git_version": None,
+            "error": "Git repository not found or not accessible",
+        }
+
+
+def capture_dependencies() -> Dict[str, Any]:
+    """
+    Capture dependency information.
+
+    Returns:
+        Dictionary with dependency details
+    """
+    deps_info = {
+        "requirements_txt": None,
+        "environment_yml": None,
+        "pyproject_toml": None,
+    }
+
+    cwd = Path.cwd()
+
+    # Check for requirements.txt
+    requirements_path = cwd / "requirements.txt"
+    if requirements_path.exists():
+        try:
+            deps_info["requirements_txt"] = requirements_path.read_text().strip()
+        except Exception:
+            deps_info["requirements_txt"] = "Error reading requirements.txt"
+
+    # Check for environment.yml (conda)
+    env_yml_path = cwd / "environment.yml"
+    if env_yml_path.exists():
+        try:
+            deps_info["environment_yml"] = env_yml_path.read_text().strip()
+        except Exception:
+            deps_info["environment_yml"] = "Error reading environment.yml"
+
+    # Check for pyproject.toml
+    pyproject_path = cwd / "pyproject.toml"
+    if pyproject_path.exists():
+        try:
+            deps_info["pyproject_toml"] = pyproject_path.read_text().strip()
+        except Exception:
+            deps_info["pyproject_toml"] = "Error reading pyproject.toml"
+
+    return deps_info
+
+
+def capture_full_environment(repo_path: Optional[Path] = None) -> Dict[str, Any]:
+    """
+    Capture complete environment information.
+
+    Args:
+        repo_path: Path to git repository, defaults to current directory
+
+    Returns:
+        Dictionary with complete environment details
+    """
+    return {
+        "python": capture_python_environment(),
+        "system": capture_system_environment(),
+        "git": capture_git_environment(repo_path),
+        "dependencies": capture_dependencies(),
+        "capture_timestamp": None,  # Will be set by storage layer
+    }

yanex/core/git_utils.py

@@ -0,0 +1,153 @@
+"""
+Git integration utilities.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import git
+from git import Repo
+
+from ..utils.exceptions import DirtyWorkingDirectoryError, GitError
+
+
+def get_git_repo(path: Optional[Path] = None) -> Repo:
+    """
+    Get git repository instance.
+
+    Args:
+        path: Path to search for git repo, defaults to current directory
+
+    Returns:
+        Git repository instance
+
+    Raises:
+        GitError: If no git repository found
+    """
+    if path is None:
+        path = Path.cwd()
+
+    try:
+        return Repo(path, search_parent_directories=True)
+    except git.InvalidGitRepositoryError as e:
+        raise GitError(f"No git repository found at {path}") from e
+
+
+def validate_clean_working_directory(repo: Optional[Repo] = None) -> None:
+    """
+    Validate that git working directory is clean.
+
+    Args:
+        repo: Git repository instance, defaults to current directory
+
+    Raises:
+        DirtyWorkingDirectoryError: If working directory has uncommitted changes
+        GitError: If git operations fail
+    """
+    if repo is None:
+        repo = get_git_repo()
+
+    try:
+        if repo.is_dirty():
+            # Get list of changed files
+            changes = []
+
+            # Modified files
+            for item in repo.index.diff(None):
+                changes.append(f"Modified: {item.a_path}")
+
+            # Staged files
+            for item in repo.index.diff("HEAD"):
+                changes.append(f"Staged: {item.a_path}")
+
+            # Untracked files
+            for file_path in repo.untracked_files:
+                changes.append(f"Untracked: {file_path}")
+
+            raise DirtyWorkingDirectoryError(changes)
+
+    except git.GitError as e:
+        raise GitError(f"Git operation failed: {e}") from e
+
+
+def get_current_commit_info(repo: Optional[Repo] = None) -> dict[str, str]:
+    """
+    Get current git commit information.
+
+    Args:
+        repo: Git repository instance, defaults to current directory
+
+    Returns:
+        Dictionary with commit information
+
+    Raises:
+        GitError: If git operations fail
+    """
+    if repo is None:
+        repo = get_git_repo()
+
+    try:
+        commit = repo.head.commit
+
+        return {
+            "commit_hash": commit.hexsha,
+            "commit_hash_short": commit.hexsha[:8],
+            "branch": repo.active_branch.name,
+            "author": str(commit.author),
+            "message": commit.message.strip(),
+            "committed_date": commit.committed_datetime.isoformat(),
+        }
+
+    except git.GitError as e:
+        raise GitError(f"Failed to get commit info: {e}") from e
+
+
+def get_repository_info(repo: Optional[Repo] = None) -> dict[str, str]:
+    """
+    Get git repository information.
+
+    Args:
+        repo: Git repository instance, defaults to current directory
+
+    Returns:
+        Dictionary with repository information
+
+    Raises:
+        GitError: If git operations fail
+    """
+    if repo is None:
+        repo = get_git_repo()
+
+    try:
+        info = {
+            "repo_path": str(repo.working_dir),
+            "git_dir": str(repo.git_dir),
+        }
+
+        # Get remote URL if available
+        try:
+            if repo.remotes:
+                origin = repo.remotes.origin
+                info["remote_url"] = origin.url
+            else:
+                info["remote_url"] = None
+        except (AttributeError, IndexError):
+            info["remote_url"] = None
+
+        return info
+
+    except git.GitError as e:
+        raise GitError(f"Failed to get repository info: {e}") from e
+
+
+def ensure_git_available() -> None:
+    """
+    Ensure git is available in the system.
+
+    Raises:
+        GitError: If git command is not available
+    """
+    try:
+        git.Git().version()
+    except git.GitCommandError as e:
+        raise GitError("Git command not found. Please install Git.") from e