expops 0.1.3__py3-none-any.whl

mlops/core/workspace.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional
+
+ENV_WORKSPACE_DIR = "MLOPS_WORKSPACE_DIR"
+
+
+def get_workspace_root() -> Path:
+    """Return the workspace root directory.
+
+    The workspace is where `projects/` lives. Resolution order:
+    1) `MLOPS_WORKSPACE_DIR`
+    2) current working directory
+    """
+    raw = os.environ.get(ENV_WORKSPACE_DIR)
+    if raw:
+        try:
+            return Path(raw).expanduser().resolve()
+        except Exception:
+            return Path(raw)
+    return Path.cwd()
+
+
+def get_projects_root(workspace_root: Optional[Path] = None) -> Path:
+    root = workspace_root or get_workspace_root()
+    return root / "projects"
+
+
+def resolve_relative_path(
+    p: str | Path,
+    *,
+    project_root: Optional[Path] = None,
+    workspace_root: Optional[Path] = None,
+) -> Path:
+    """Resolve a user-provided path against likely bases.
+
+    - Absolute paths are returned as-is.
+    - Relative paths are tried against:
+      1) current working directory
+      2) `project_root` (if provided)
+      3) `workspace_root` / `MLOPS_WORKSPACE_DIR` (if provided/available)
+
+    Returns a Path even if it does not exist (best-effort).
+    """
+    path = Path(p)
+    if path.is_absolute():
+        return path
+
+    # 1) As given relative to CWD
+    try:
+        if path.exists():
+            return path
+    except Exception:
+        pass
+
+    # 2) Relative to project root
+    if project_root is not None:
+        try:
+            cand = (project_root / path)
+            if cand.exists():
+                return cand
+        except Exception:
+            pass
+
+    # 3) Relative to workspace root
+    wr = workspace_root or get_workspace_root()
+    try:
+        cand = (wr / path)
+        if cand.exists():
+            return cand
+    except Exception:
+        pass
+
+    # Fall back to the most likely base for debugging
+    if project_root is not None:
+        return project_root / path
+    return (wr / path)
+
+
+def infer_source_root() -> Optional[Path]:
+    """Best-effort: detect a source checkout root (repo root) when running from source.
+
+    This is used only for backwards-compatible PYTHONPATH/editable-install fallbacks.
+    """
+    try:
+        # workspace.py lives at <root>/src/mlops/core/workspace.py in source checkouts
+        mlops_pkg_dir = Path(__file__).resolve().parents[1]  # .../mlops
+        src_dir = mlops_pkg_dir.parent  # .../src (source) or .../site-packages (installed)
+        root = src_dir.parent
+        if (root / "pyproject.toml").exists() or (root / "setup.py").exists():
+            # Heuristic: source checkout root should contain packaging metadata.
+            return root
+    except Exception:
+        pass
+    return None
+
+

mlops/environment/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from .base import EnvironmentManager
+from .factory import EnvironmentManagerFactory, create_environment_manager
+
+__all__ = [
+    "EnvironmentManager",
+    "EnvironmentManagerFactory",
+    "create_environment_manager",
+]

mlops/environment/base.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class EnvironmentManager(ABC):
+    """Abstract base class for environment managers (venv/conda/pyenv/system)."""
+
+    def __init__(self, config: dict[str, Any]):
+        self.config = config
+        self.environment_name: str | None = None
+        self.python_interpreter: str | None = None
+
+    @abstractmethod
+    def setup_environment(self) -> None:
+        """Set up the environment based on configuration."""
+        raise NotImplementedError
+    
+    @abstractmethod
+    def verify_environment(self) -> bool:
+        """Verify that the environment is properly configured."""
+        raise NotImplementedError
+    
+    @abstractmethod
+    def get_python_interpreter(self) -> str:
+        """Get the path to the Python interpreter for this environment."""
+        raise NotImplementedError
+    
+    @abstractmethod
+    def get_environment_name(self) -> str:
+        """Get the name of the environment."""
+        raise NotImplementedError
+    
+    @abstractmethod
+    def environment_exists(self) -> bool:
+        """Check if the environment already exists."""
+        raise NotImplementedError
+    
+    @abstractmethod
+    def get_environment_type(self) -> str:
+        """Return the type of environment manager (conda, pyenv, etc.)."""
+        raise NotImplementedError

mlops/environment/conda_manager.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from .base import EnvironmentManager
+from .utils import verify_pip_requirements
+
+
+class CondaEnvironmentManager(EnvironmentManager):
+    """Conda-based environment management."""
+    
+    def __init__(self, config: dict[str, Any]):
+        super().__init__(config)
+        self.dependencies = self._load_dependencies(config)
+        
+        env_name = config.get("name")
+        if not env_name:
+            raise ValueError(
+                "Conda environment name must be explicitly specified in the configuration. "
+                "Please add 'name' field under 'environment.conda' in your config file."
+            )
+        self.environment_name = env_name
+
+    def _load_dependencies(self, config: dict[str, Any]) -> list[Any]:
+        """Load dependencies from inline config or environment.yml file."""
+        # Option 1: Inline dependencies
+        if "dependencies" in config:
+            print("[CondaEnvironmentManager] Using inline dependencies from config.")
+            return config["dependencies"]
+        
+        # Option 2: From conda environment.yml file
+        if "environment_file" in config:
+            env_file_path = Path(config["environment_file"])
+            if not env_file_path.exists():
+                raise FileNotFoundError(f"Environment file not found: {env_file_path}")
+            
+            print(f"[CondaEnvironmentManager] Loading dependencies from environment file: {env_file_path}")
+            with open(env_file_path, 'r') as f:
+                env_data = yaml.safe_load(f)
+            
+            if "dependencies" not in env_data:
+                raise ValueError(f"No 'dependencies' section found in {env_file_path}")
+            
+            return env_data["dependencies"]
+        
+        print("[CondaEnvironmentManager] No dependencies specified.")
+        return []
+
+    def get_environment_type(self) -> str:
+        return "conda"
+
+    def get_environment_name(self) -> str:
+        return self.environment_name
+
+    def get_python_interpreter(self) -> str:
+        if not self.python_interpreter:
+            raise RuntimeError("Environment not set up yet. Call setup_environment() first.")
+        return self.python_interpreter
+
+    def _get_conda_base_prefix(self) -> str | None:
+        """Attempts to find the Conda base prefix."""
+        try:
+            result = subprocess.run(["conda", "info", "--json"], capture_output=True, text=True, check=True)
+            conda_info = json.loads(result.stdout)
+            return conda_info.get("root_prefix") or conda_info.get("conda_prefix")
+        except (subprocess.CalledProcessError, FileNotFoundError, json.JSONDecodeError) as e:
+            print(f"[CondaEnvironmentManager] Could not get conda info: {e}")
+            conda_exe_path = os.environ.get("CONDA_EXE")
+            if conda_exe_path:
+                return str(Path(conda_exe_path).parent.parent)
+        return None
+
+    def _get_conda_executable(self) -> str:
+        """Determines the path to the conda executable."""
+        conda_exe = "conda"
+        conda_base = self._get_conda_base_prefix()
+        if conda_base:
+            specific_conda_exe = Path(conda_base) / "bin" / "conda"
+            if specific_conda_exe.exists():
+                conda_exe = str(specific_conda_exe)
+            else: # Try Scripts for Windows
+                specific_conda_exe_win = Path(conda_base) / "Scripts" / "conda.exe"
+                if specific_conda_exe_win.exists():
+                    conda_exe = str(specific_conda_exe_win)
+        
+        try:
+            subprocess.run([conda_exe, "--version"], capture_output=True, check=True, text=True)
+        except (FileNotFoundError, subprocess.CalledProcessError) as e:
+            raise RuntimeError(
+                f"Conda executable ('{conda_exe}') not found or not runnable. "
+                "Please ensure Conda is installed and configured correctly in your PATH. "
+                f"Error: {e}"
+            )
+        return conda_exe
+
+    def environment_exists(self) -> bool:
+        """Check if the conda environment already exists."""
+        try:
+            conda_exe = self._get_conda_executable()
+            result = subprocess.run([conda_exe, "env", "list", "--json"], capture_output=True, text=True, check=True)
+            env_list = json.loads(result.stdout).get("envs", [])
+            return any(Path(env_path).name == self.environment_name for env_path in env_list)
+        except (subprocess.CalledProcessError, json.JSONDecodeError, FileNotFoundError) as e:
+            print(f"[CondaEnvironmentManager] Failed to list Conda environments: {e}")
+            return False
+
+    @staticmethod
+    def _python_path(env_path: Path) -> Path:
+        if os.name == "nt":
+            return env_path / "python.exe"
+        return env_path / "bin" / "python"
+
+    def setup_environment(self) -> None:
+        """Set up the conda environment based on configuration."""
+        print(f"[CondaEnvironmentManager] Starting Conda environment setup for '{self.environment_name}'...")
+        
+        if not self.dependencies:
+            print("[CondaEnvironmentManager] No dependencies specified. Using current environment.")
+            self.python_interpreter = sys.executable
+            return
+
+        conda_exe = self._get_conda_executable()
+
+        if not self.environment_exists():
+            print(f"[CondaEnvironmentManager] Environment '{self.environment_name}' not found. Creating it...")
+            
+            env_yaml_content = {"name": self.environment_name, "dependencies": self.dependencies}
+            
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as tmp_env_file:
+                yaml.dump(env_yaml_content, tmp_env_file)
+                tmp_env_file_path = tmp_env_file.name
+            
+            try:
+                print(f"[CondaEnvironmentManager] Creating environment from temporary file: {tmp_env_file_path}")
+                cmd_libmamba = [conda_exe, "env", "create", "-f", tmp_env_file_path, "-q", "--solver=libmamba"]
+                res = subprocess.run(cmd_libmamba, capture_output=True, text=True)
+
+                cmd_used = cmd_libmamba
+                if res.returncode != 0:
+                    stderr_lower = (res.stderr or "").lower()
+                    if "libmamba" in stderr_lower or "invalid choice" in stderr_lower:
+                        print("[CondaEnvironmentManager] libmamba solver not available, falling back to classic solver...")
+                        cmd_classic = [conda_exe, "env", "create", "-f", tmp_env_file_path, "-q"]
+                        res = subprocess.run(cmd_classic, capture_output=True, text=True)
+                        cmd_used = cmd_classic
+
+                if res.returncode != 0:
+                    error_message = (
+                        f"Failed to create Conda environment '{self.environment_name}'. Return code: {res.returncode}\n"
+                        f"Command: {' '.join(cmd_used)}\n"
+                        f"Stdout:\n{res.stdout}\n"
+                        f"Stderr:\n{res.stderr}"
+                    )
+                    raise RuntimeError(error_message)
+                
+                print(f"[CondaEnvironmentManager] Environment '{self.environment_name}' created successfully.")
+            finally:
+                try:
+                    os.remove(tmp_env_file_path)
+                except OSError:
+                    print(f"[CondaEnvironmentManager] Warning: Could not remove temporary env file {tmp_env_file_path}")
+        else:
+            print(f"[CondaEnvironmentManager] Using existing environment: '{self.environment_name}'")
+
+        # Set up Python interpreter path
+        try:
+            info_result = subprocess.run([conda_exe, "info", "--envs", "--json"], capture_output=True, text=True, check=True)
+            envs_info = json.loads(info_result.stdout).get("envs", [])
+            env_path_str = next((p for p in envs_info if Path(p).name == self.environment_name), None)
+
+            if not env_path_str: 
+                conda_base = self._get_conda_base_prefix()
+                if conda_base:
+                    env_path_str = str(Path(conda_base) / "envs" / self.environment_name)
+                else: 
+                    env_path_str = self.environment_name
+
+            env_path = Path(env_path_str)
+            if not env_path.exists():
+                raise RuntimeError(
+                    f"Could not determine path for environment '{self.environment_name}'. "
+                    f"Path '{env_path_str}' does not exist."
+                )
+
+            self.python_interpreter = str(self._python_path(env_path))
+            
+            if not Path(self.python_interpreter).exists():
+                raise FileNotFoundError(f"Python interpreter not found in environment '{self.environment_name}' at expected path: {self.python_interpreter}")
+
+        except (subprocess.CalledProcessError, json.JSONDecodeError, StopIteration, FileNotFoundError) as e:
+            raise RuntimeError(f"Failed to determine Python interpreter for environment '{self.environment_name}': {e}")
+
+        print(f"[CondaEnvironmentManager] Python interpreter: {self.python_interpreter}")
+        print(f"[CondaEnvironmentManager] Environment setup completed for '{self.environment_name}'.")
+
+    def verify_environment(self) -> bool:
+        """Verify that the environment is properly configured."""
+        if not self.python_interpreter:
+            print("[CondaEnvironmentManager] Python interpreter not set. Cannot verify environment.")
+            return False
+
+        print(f"[CondaEnvironmentManager] Verifying environment '{self.environment_name}'...")
+
+        if not self.dependencies:
+            print("[CondaEnvironmentManager] No dependencies to verify. Skipping verification.")
+            return True
+
+        # Verify that the Python interpreter exists and works
+        try:
+            python_version_output = subprocess.check_output([self.python_interpreter, '--version'], text=True, stderr=subprocess.STDOUT).strip()
+            print(f"[CondaEnvironmentManager] Python interpreter is working: {python_version_output}")
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            print(f"[CondaEnvironmentManager] Python interpreter '{self.python_interpreter}' is not working: {e}")
+            return False
+
+        # Verify Python version if specified
+        python_version_config = next(
+            (d for d in (self.dependencies or []) if isinstance(d, str) and d.startswith("python=")),
+            None,
+        )
+        if isinstance(python_version_config, str) and python_version_config.startswith("python="):
+            expected_py_ver = python_version_config.split("=")[1]
+            try:
+                current_py_ver_full = subprocess.check_output([self.python_interpreter, '--version'], text=True, stderr=subprocess.STDOUT).strip()
+                current_py_ver_parts = current_py_ver_full.split()
+                current_py_ver = current_py_ver_parts[-1] if current_py_ver_parts else ""
+                
+                if '.' in expected_py_ver:
+                    expected_parts = expected_py_ver.split('.')
+                    current_parts = current_py_ver.split('.')
+                    if len(expected_parts) <= len(current_parts):
+                        match = all(expected_parts[i] == current_parts[i] for i in range(len(expected_parts)))
+                        if not match:
+                            print(f"[CondaEnvironmentManager] Python version mismatch. Expected prefix: {expected_py_ver}, Found: {current_py_ver}")
+                            return False
+                    else: 
+                        print(f"[CondaEnvironmentManager] Python version precision mismatch. Expected: {expected_py_ver}, Found: {current_py_ver}")
+                        return False
+                elif current_py_ver != expected_py_ver:
+                    print(f"[CondaEnvironmentManager] Python version mismatch. Expected: {expected_py_ver}, Found: {current_py_ver}")
+                    return False
+                print(f"[CondaEnvironmentManager] Python version OK: {current_py_ver} (matches expected: {expected_py_ver})")
+
+            except subprocess.CalledProcessError as e:
+                print(f"[CondaEnvironmentManager] Could not verify Python version: {e.output if hasattr(e, 'output') else e}")
+                return False
+        
+        # Basic package verification (simplified for now)
+        verification_failed = False
+        
+        for package_entry in self.dependencies:
+            if isinstance(package_entry, dict) and "pip" in package_entry:
+                pip_specs = package_entry.get("pip") or []
+                if isinstance(pip_specs, list):
+                    ok, missing = verify_pip_requirements(self.python_interpreter, [str(x) for x in pip_specs])
+                    if not ok:
+                        print(f"[CondaEnvironmentManager] Missing pip packages: {', '.join(missing)}")
+                        verification_failed = True
+            elif isinstance(package_entry, str) and ("==" in package_entry or "=" in package_entry):
+                try:
+                    # Support both conda-style `pkg=1.2` and pip-style `pkg==1.2`
+                    if "==" in package_entry:
+                        name, version = package_entry.split("==", 1)
+                    else:
+                        name, version = package_entry.split("=", 1)
+                    name = name.split("::")[-1].strip()
+                    if name == "python":
+                        continue
+                    
+                    conda_exe = self._get_conda_executable()
+                    conda_list_cmd = [conda_exe, "list", "-n", self.environment_name, name, "--json"]
+                    result = subprocess.run(conda_list_cmd, capture_output=True, text=True)
+                    
+                    if result.returncode == 0:
+                        package_info_list = json.loads(result.stdout)
+                        if package_info_list:
+                            installed_version = package_info_list[0].get("version", "")
+                            if installed_version == version:
+                                print(f"[CondaEnvironmentManager] Package {name} (conda) found with correct version {version}.")
+                            else:
+                                print(f"[CondaEnvironmentManager] Package {name} (conda) version mismatch. Expected: {version}, Found: {installed_version}.")
+                                verification_failed = True
+                        else:
+                            print(f"[CondaEnvironmentManager] Package {name} (conda) not found.")
+                            verification_failed = True
+                    else:
+                        print(f"[CondaEnvironmentManager] Package {name} verification failed.")
+                        verification_failed = True
+                
+                except Exception as e:
+                    print(f"[CondaEnvironmentManager] Error verifying package {name}: {e}")
+                    verification_failed = True
+        
+        if verification_failed:
+            print(f"[CondaEnvironmentManager] Environment verification failed for '{self.environment_name}'.")
+            return False
+        
+        print(f"[CondaEnvironmentManager] Environment verification successful for '{self.environment_name}'.")
+        return True 

mlops/environment/factory.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .base import EnvironmentManager
+from .conda_manager import CondaEnvironmentManager
+from .venv_manager import VenvEnvironmentManager
+from .system_manager import SystemEnvironmentManager
+from .pyenv_manager import PyenvEnvironmentManager
+
+
+class EnvironmentManagerFactory:
+    """Factory for creating environment managers based on configuration."""
+    
+    _managers: dict[str, type[EnvironmentManager]] = {
+        "conda": CondaEnvironmentManager,
+        "venv": VenvEnvironmentManager,
+        "virtualenv": VenvEnvironmentManager,
+        "pyenv": PyenvEnvironmentManager,
+        "system": SystemEnvironmentManager,
+    }
+    
+    @classmethod
+    def create_environment_manager(cls, platform_config: dict[str, Any]) -> EnvironmentManager:
+        """Create an environment manager based on the platform configuration."""
+        env_config = platform_config.get("environment")
+        if not isinstance(env_config, dict) or not env_config:
+            return SystemEnvironmentManager({})
+
+        env_type, env_specific_config = cls._select_manager(env_config)
+        manager_class = cls._managers.get(env_type)
+        if manager_class is None:
+            raise ValueError(
+                f"Unsupported environment type: {env_type}. Supported types: {sorted(cls._managers.keys())}"
+            )
+        return manager_class(env_specific_config)
+
+    @classmethod
+    def _select_manager(cls, env_config: dict[str, Any]) -> tuple[str, dict[str, Any]]:
+        # Primary form:
+        #   environment: { venv: {...} } or { conda: {...} } etc.
+        for supported_type in cls._managers:
+            if supported_type in env_config:
+                raw = env_config.get(supported_type)
+                return supported_type, raw if isinstance(raw, dict) else {}
+
+        # Legacy fallbacks where `environment:` contains the manager's config directly.
+        if any(k in env_config for k in ("dependencies", "environment_file")):
+            return "conda", env_config
+        if any(k in env_config for k in ("requirements", "requirements_file")):
+            return "venv", env_config
+
+        return "system", env_config
+    
+    @classmethod
+    def list_supported_types(cls) -> list[str]:
+        """List all supported environment types."""
+        return list(cls._managers.keys())
+    
+    @classmethod
+    def register_manager(cls, env_type: str, manager_class: type[EnvironmentManager]) -> None:
+        """Register a new environment manager type."""
+        if not issubclass(manager_class, EnvironmentManager):
+            raise ValueError(f"Manager class must inherit from EnvironmentManager")
+        cls._managers[env_type] = manager_class
+
+
+def create_environment_manager(platform_config: dict[str, Any]) -> EnvironmentManager:
+    """Convenience function to create an environment manager."""
+    return EnvironmentManagerFactory.create_environment_manager(platform_config) 

mlops/environment/pyenv_manager.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from .base import EnvironmentManager
+from .utils import load_requirements, verify_pip_requirements
+
+
+class PyenvEnvironmentManager(EnvironmentManager):
+    """Pyenv-based environment management."""
+    
+    def __init__(self, config: dict[str, Any]):
+        super().__init__(config)
+        self.requirements = load_requirements(config)
+        self.python_version = config.get("python_version", "3.9.0")
+        
+        env_name = config.get("name")
+        if not env_name:
+            raise ValueError(
+                "Pyenv environment name must be explicitly specified in the configuration. "
+                "Please add 'name' field under 'environment.pyenv' in your config file."
+            )
+        self.environment_name = env_name
+
+    def get_environment_type(self) -> str:
+        return "pyenv"
+
+    def get_environment_name(self) -> str:
+        return self.environment_name
+
+    def get_python_interpreter(self) -> str:
+        if not self.python_interpreter:
+            raise RuntimeError("Environment not set up yet. Call setup_environment() first.")
+        return self.python_interpreter
+
+    def _get_pyenv_executable(self) -> str:
+        """Get the pyenv executable path."""
+        try:
+            subprocess.run(["pyenv", "--version"], capture_output=True, check=True, text=True)
+            return "pyenv"
+        except (FileNotFoundError, subprocess.CalledProcessError) as e:
+            raise RuntimeError(
+                "pyenv executable not found or not runnable. "
+                "Please ensure pyenv is installed and configured correctly in your PATH. "
+                f"Error: {e}"
+            )
+
+    def environment_exists(self) -> bool:
+        """Check if the pyenv virtual environment already exists."""
+        try:
+            pyenv_exe = self._get_pyenv_executable()
+            result = subprocess.run([pyenv_exe, "versions"], capture_output=True, text=True, check=True)
+            return self.environment_name in result.stdout
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            print(f"[PyenvEnvironmentManager] Failed to list pyenv versions: {e}")
+            return False
+
+    def setup_environment(self) -> None:
+        """Set up the pyenv environment based on configuration."""
+        print(f"[PyenvEnvironmentManager] Starting pyenv environment setup for '{self.environment_name}'...")
+        
+        pyenv_exe = self._get_pyenv_executable()
+
+        try:
+            result = subprocess.run([pyenv_exe, "versions"], capture_output=True, text=True, check=True)
+            if self.python_version not in result.stdout:
+                print(f"[PyenvEnvironmentManager] Python version {self.python_version} not found. Installing it...")
+                subprocess.run([pyenv_exe, "install", self.python_version], check=True)
+                print(f"[PyenvEnvironmentManager] Python version {self.python_version} installed successfully.")
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to install Python version {self.python_version}: {e}")
+
+        if not self.environment_exists():
+            print(f"[PyenvEnvironmentManager] Environment '{self.environment_name}' not found. Creating it...")
+            
+            # Create virtual environment
+            try:
+                subprocess.run([pyenv_exe, "virtualenv", self.python_version, self.environment_name], check=True)
+                print(f"[PyenvEnvironmentManager] Environment '{self.environment_name}' created successfully.")
+            except subprocess.CalledProcessError as e:
+                raise RuntimeError(f"Failed to create pyenv virtual environment '{self.environment_name}': {e}")
+        else:
+            print(f"[PyenvEnvironmentManager] Using existing environment: '{self.environment_name}'")
+
+        try:
+            pyenv_root_result = subprocess.run([pyenv_exe, "root"], capture_output=True, text=True, check=True)
+            pyenv_root = Path(pyenv_root_result.stdout.strip())
+            
+            self.python_interpreter = str(pyenv_root / "versions" / self.environment_name / "bin" / "python")
+            
+            if not Path(self.python_interpreter).exists():
+                raise FileNotFoundError(f"Python interpreter not found at expected path: {self.python_interpreter}")
+
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            raise RuntimeError(f"Failed to determine Python interpreter for pyenv environment '{self.environment_name}': {e}")
+
+        if self.requirements:
+            print(f"[PyenvEnvironmentManager] Installing requirements...")
+            try:
+                pip_install_cmd = [self.python_interpreter, "-m", "pip", "install"] + self.requirements
+                subprocess.run(pip_install_cmd, check=True)
+                print(f"[PyenvEnvironmentManager] Requirements installed successfully.")
+            except subprocess.CalledProcessError as e:
+                raise RuntimeError(f"Failed to install requirements: {e}")
+
+        print(f"[PyenvEnvironmentManager] Python interpreter: {self.python_interpreter}")
+        print(f"[PyenvEnvironmentManager] Environment setup completed for '{self.environment_name}'.")
+
+    def verify_environment(self) -> bool:
+        """Verify that the environment is properly configured."""
+        if not self.python_interpreter:
+            print("[PyenvEnvironmentManager] Python interpreter not set. Cannot verify environment.")
+            return False
+
+        print(f"[PyenvEnvironmentManager] Verifying environment '{self.environment_name}'...")
+
+        try:
+            python_version_output = subprocess.check_output([self.python_interpreter, '--version'], text=True, stderr=subprocess.STDOUT).strip()
+            print(f"[PyenvEnvironmentManager] Python interpreter is working: {python_version_output}")
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            print(f"[PyenvEnvironmentManager] Python interpreter '{self.python_interpreter}' is not working: {e}")
+            return False
+
+        try:
+            current_py_ver_full = subprocess.check_output([self.python_interpreter, '--version'], text=True, stderr=subprocess.STDOUT).strip()
+            current_py_ver = current_py_ver_full.split()[-1] if current_py_ver_full.split() else ""
+            
+            if not current_py_ver.startswith(self.python_version.split('.')[0]):  # Check major version
+                print(f"[PyenvEnvironmentManager] Python version mismatch. Expected: {self.python_version}, Found: {current_py_ver}")
+                return False
+            print(f"[PyenvEnvironmentManager] Python version OK: {current_py_ver}")
+        except subprocess.CalledProcessError as e:
+            print(f"[PyenvEnvironmentManager] Could not verify Python version: {e}")
+            return False
+
+        if self.requirements:
+            ok, missing = verify_pip_requirements(self.python_interpreter, self.requirements)
+            if not ok:
+                print(f"[PyenvEnvironmentManager] Missing packages: {', '.join(missing)}")
+                print(f"[PyenvEnvironmentManager] Environment verification failed for '{self.environment_name}'.")
+                return False
+        
+        print(f"[PyenvEnvironmentManager] Environment verification successful for '{self.environment_name}'.")
+        return True