comfy-env 0.0.40__py3-none-any.whl → 0.0.42__py3-none-any.whl

comfy_env/__init__.py

@@ -1,4 +1,9 @@
-__version__ = "0.0.14"
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("comfy-env")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"  # Fallback for editable installs
 
 from .env.config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, CondaConfig
 from .env.config_file import (
@@ -31,8 +36,8 @@ from .ipc.worker import BaseWorker, register
 from .decorator import isolated, shutdown_all_processes
 
 # New in-place installation API
-from .install import install, verify_installation, setup
-from .resolver import RuntimeEnv, WheelResolver
+from .install import install, verify_installation
+from .resolver import RuntimeEnv
 
 # Pixi integration (for conda packages)
 from .pixi import (
@@ -82,7 +87,6 @@ __all__ = [
     "install",
     "verify_installation",
     "RuntimeEnv",
-    "WheelResolver",
     # Pixi integration (for conda packages)
     "ensure_pixi",
     "get_pixi_path",

comfy_env/cli.py

@@ -10,7 +10,6 @@ Provides the `comfy-env` command with subcommands:
 
 Usage:
     comfy-env install
-    comfy-env install --isolated
     comfy-env install --dry-run
 
     comfy-env info
@@ -54,21 +53,11 @@ def main(args: Optional[List[str]] = None) -> int:
         type=str,
         help="Path to config file (default: auto-discover)",
     )
-    install_parser.add_argument(
-        "--isolated",
-        action="store_true",
-        help="Create isolated venv instead of installing in-place",
-    )
     install_parser.add_argument(
         "--dry-run",
         action="store_true",
         help="Show what would be installed without installing",
     )
-    install_parser.add_argument(
-        "--verify",
-        action="store_true",
-        help="Verify wheel URLs exist before installing",
-    )
     install_parser.add_argument(
         "--dir", "-d",
         type=str,
@@ -108,11 +97,6 @@ def main(args: Optional[List[str]] = None) -> int:
         type=str,
         help="Path to config file",
     )
-    resolve_parser.add_argument(
-        "--verify",
-        action="store_true",
-        help="Verify URLs exist (HTTP HEAD check)",
-    )
 
     # doctor command
     doctor_parser = subparsers.add_parser(
@@ -175,16 +159,13 @@ def cmd_install(args) -> int:
     """Handle install command."""
     from .install import install
 
-    mode = "isolated" if args.isolated else "inplace"
     node_dir = Path(args.dir) if args.dir else Path.cwd()
 
     try:
         install(
             config=args.config,
-            mode=mode,
             node_dir=node_dir,
             dry_run=args.dry_run,
-            verify_wheels=args.verify,
         )
         return 0
     except FileNotFoundError as e:
@@ -233,18 +214,15 @@ def cmd_info(args) -> int:
 
 def cmd_resolve(args) -> int:
     """Handle resolve command."""
-    from .resolver import RuntimeEnv, WheelResolver, parse_wheel_requirement
-    from .registry import PACKAGE_REGISTRY
+    from .resolver import RuntimeEnv, parse_wheel_requirement
+    from .registry import PACKAGE_REGISTRY, get_cuda_short2
     from .env.config_file import discover_env_config, load_env_from_file
 
     env = RuntimeEnv.detect()
-    resolver = WheelResolver()
-
     packages = []
 
     # Get packages from args or config
     if args.all or (not args.packages and args.config):
-        # Load from config
         if args.config:
             config = load_env_from_file(Path(args.config))
         else:
@@ -264,52 +242,57 @@ def cmd_resolve(args) -> int:
     print(f"Resolving wheels for: {env}")
     print("=" * 60)
 
+    # Build template variables
+    vars_dict = env.as_dict()
+    if env.cuda_version:
+        vars_dict["cuda_short2"] = get_cuda_short2(env.cuda_version)
+
     all_ok = True
     for pkg_spec in packages:
         package, version = parse_wheel_requirement(pkg_spec)
-        if version is None:
-            print(f"  {package}: No version specified, skipping")
-            continue
-
         pkg_lower = package.lower()
+
         try:
-            # Check if package is in registry with github_release method
             if pkg_lower in PACKAGE_REGISTRY:
-                registry_config = PACKAGE_REGISTRY[pkg_lower]
-                method = registry_config.get("method")
-
-                if method == "github_release":
-                    # Resolve URL from registry sources
-                    url = _resolve_github_release_url(package, version, env, registry_config)
-                    status = "OK" if args.verify else "resolved"
-                    print(f"  {package}=={version}: {status}")
+                config = PACKAGE_REGISTRY[pkg_lower]
+
+                if "wheel_template" in config:
+                    # Direct wheel URL template
+                    effective_version = version or config.get("default_version")
+                    if not effective_version:
+                        print(f"  {package}: No version specified (no default in registry)")
+                        all_ok = False
+                        continue
+
+                    vars_dict["version"] = effective_version
+                    url = _substitute_template(config["wheel_template"], vars_dict)
+                    print(f"  {package}=={effective_version}: resolved")
                     print(f"    {url}")
+
+                elif "package_name" in config:
+                    # PyPI variant (e.g., spconv-cu124)
+                    pkg_name = _substitute_template(config["package_name"], vars_dict)
+                    pkg_spec = f"{pkg_name}=={version}" if version else pkg_name
+                    print(f"  {package}: installs as {pkg_spec} from PyPI")
+
                 else:
-                    # For other methods, just show what method will be used
-                    print(f"  {package}=={version}: uses {method} method")
-                    if "index_url" in registry_config:
-                        index_url = _substitute_template(registry_config["index_url"], env)
-                        print(f"    index: {index_url}")
-                    elif "package_template" in registry_config:
-                        pkg_name = _substitute_template(registry_config["package_template"], env)
-                        print(f"    installs as: {pkg_name}")
+                    print(f"  {package}: no wheel_template or package_name in registry")
+                    all_ok = False
             else:
-                # Fall back to WheelResolver
-                url = resolver.resolve(package, version, env, verify=args.verify)
-                status = "OK" if args.verify else "resolved"
-                print(f"  {package}=={version}: {status}")
-                print(f"    {url}")
+                print(f"  {package}: NOT in registry")
+                print(f"    Add to [wheel_sources] in comfy-env.toml:")
+                print(f'    {package} = "https://example.com/{package}-{{version}}+cu{{cuda_short}}-{{py_tag}}-{{platform}}.whl"')
+                all_ok = False
+
         except Exception as e:
-            print(f"  {package}=={version}: FAILED")
-            _print_wheel_not_found_error(package, version, env, e)
+            print(f"  {package}: FAILED - {e}")
             all_ok = False
 
     return 0 if all_ok else 1
 
 
-def _substitute_template(template: str, env) -> str:
-    """Substitute environment variables into a URL template."""
-    vars_dict = env.as_dict()
+def _substitute_template(template: str, vars_dict: dict) -> str:
+    """Substitute {var} placeholders in template."""
     result = template
     for key, value in vars_dict.items():
         if value is not None:
@@ -317,70 +300,6 @@ def _substitute_template(template: str, env) -> str:
     return result
 
 
-def _resolve_github_release_url(package: str, version: str, env, config: dict) -> str:
-    """Resolve URL for github_release method packages."""
-    sources = config.get("sources", [])
-    if not sources:
-        raise ValueError(f"No sources configured for {package}")
-
-    # Build template variables
-    vars_dict = env.as_dict()
-    vars_dict["version"] = version
-    vars_dict["py_tag"] = f"cp{env.python_short}"
-    if env.cuda_version:
-        vars_dict["cuda_major"] = env.cuda_version.split(".")[0]
-
-    # Filter sources by platform
-    current_platform = env.platform_tag
-    compatible_sources = [
-        s for s in sources
-        if current_platform in s.get("platforms", [])
-    ]
-
-    if not compatible_sources:
-        available = set()
-        for s in sources:
-            available.update(s.get("platforms", []))
-        raise ValueError(
-            f"No {package} wheels for platform {current_platform}. "
-            f"Available: {', '.join(sorted(available))}"
-        )
-
-    # Return URL from first compatible source
-    source = compatible_sources[0]
-    url_template = source.get("url_template", "")
-    url = url_template
-    for key, value in vars_dict.items():
-        if value is not None:
-            url = url.replace(f"{{{key}}}", str(value))
-
-    return url
-
-
-def _print_wheel_not_found_error(package: str, version: str, env, error: Exception) -> None:
-    """Print a formatted error message for wheel not found."""
-    from .errors import WheelNotFoundError
-
-    if isinstance(error, WheelNotFoundError):
-        print(f"    CUDA wheel not found: {package}=={version}")
-        print()
-        print("+------------------------------------------------------------------+")
-        print("|  CUDA Wheel Not Found                                            |")
-        print("+------------------------------------------------------------------+")
-        print(f"|  Package:   {package}=={version:<46} |")
-        print(f"|  Requested: cu{env.cuda_short}-torch{env.torch_mm}-{env.python_short}-{env.platform_tag:<17} |")
-        print("|                                                                  |")
-        print(f"|  Reason: {error.reason:<54} |")
-        print("|                                                                  |")
-        print("|  Suggestions:                                                    |")
-        print(f"|    1. Check if wheel exists: comfy-env resolve {package:<15} |")
-        print(f"|    2. Build wheel locally: comfy-env build {package:<18} |")
-        print("|                                                                  |")
-        print("+------------------------------------------------------------------+")
-    else:
-        print(f"    {error}")
-
-
 def cmd_doctor(args) -> int:
     """Handle doctor command."""
     from .install import verify_installation
@@ -409,7 +328,6 @@ def cmd_doctor(args) -> int:
             packages = (config.requirements or []) + (config.no_deps_requirements or [])
 
     if packages:
-        # Extract package names from specs
         pkg_names = []
         for pkg in packages:
             name = pkg.split("==")[0].split(">=")[0].split("[")[0]
@@ -429,55 +347,67 @@ def cmd_doctor(args) -> int:
 
 def cmd_list_packages(args) -> int:
     """Handle list-packages command."""
-    from .registry import PACKAGE_REGISTRY, list_packages
+    from .registry import PACKAGE_REGISTRY
 
     if args.json:
         import json
         result = {}
         for name, config in PACKAGE_REGISTRY.items():
             result[name] = {
-                "method": config["method"],
                 "description": config.get("description", ""),
             }
-            if "index_url" in config:
-                result[name]["index_url"] = config["index_url"]
-            if "package_template" in config:
-                result[name]["package_template"] = config["package_template"]
+            if "wheel_template" in config:
+                result[name]["wheel_template"] = config["wheel_template"]
+            if "package_name" in config:
+                result[name]["package_name"] = config["package_name"]
+            if "default_version" in config:
+                result[name]["default_version"] = config["default_version"]
         print(json.dumps(result, indent=2))
         return 0
 
     print("Built-in CUDA Package Registry")
     print("=" * 60)
     print()
-    print("These packages can be installed without specifying wheel_sources.")
-    print("Just add them to your comfy-env.toml:")
+    print("These packages can be installed by adding them to comfy-env.toml:")
     print()
     print("  [cuda]")
-    print("  torch-scatter = \"2.1.2\"")
-    print("  torch-cluster = \"1.6.3\"")
+    print('  nvdiffrast = "0.4.0"')
+    print('  torch-scatter = "2.1.2"')
+    print()
+    print("Or override with custom wheel source:")
+    print()
+    print("  [wheel_sources]")
+    print('  nvdiffrast = "https://my-mirror.com/nvdiffrast-{version}+cu{cuda_short}-{py_tag}-{platform}.whl"')
     print()
     print("-" * 60)
 
-    # Group packages by method
-    by_method = {}
+    # Group by type
+    wheel_template_packages = []
+    package_name_packages = []
+
     for name, config in PACKAGE_REGISTRY.items():
-        method = config["method"]
-        if method not in by_method:
-            by_method[method] = []
-        by_method[method].append((name, config))
-
-    method_labels = {
-        "index": "PEP 503 Index (pip --extra-index-url)",
-        "github_index": "GitHub Pages (pip --find-links)",
-        "pypi_variant": "PyPI with CUDA variant names",
-    }
-
-    for method, packages in by_method.items():
-        print(f"\n{method_labels.get(method, method)}:")
-        for name, config in sorted(packages):
-            desc = config.get("description", "")
+        desc = config.get("description", "")
+        default = config.get("default_version", "")
+        if "wheel_template" in config:
+            wheel_template_packages.append((name, desc, default))
+        elif "package_name" in config:
+            package_name_packages.append((name, desc, config["package_name"]))
+
+    if wheel_template_packages:
+        print("\nDirect wheel URL packages:")
+        for name, desc, default in sorted(wheel_template_packages):
+            version_info = f" (default: {default})" if default else ""
+            print(f"  {name:20} - {desc}{version_info}")
+
+    if package_name_packages:
+        print("\nPyPI variant packages:")
+        for name, desc, pkg_template in sorted(package_name_packages):
             print(f"  {name:20} - {desc}")
+            print(f"                       installs as: {pkg_template}")
 
+    print()
+    print("Template variables: {version}, {cuda_short}, {torch_mm}, {py_tag}, {platform}")
+    print("See README for full documentation on writing wheel templates.")
     print()
     return 0
 

comfy_env/env/config.py

@@ -68,12 +68,14 @@ class EnvManagerConfig:
         [envname.packages]  - Regular packages for isolated env
         [node_reqs]         - Node dependencies
         [tools]             - External tools (e.g., blender = "4.2")
+        [wheel_sources]     - Custom wheel URL templates (override registry)
     """
     system: SystemConfig = field(default_factory=SystemConfig)
     local: LocalConfig = field(default_factory=LocalConfig)
     envs: Dict[str, "IsolatedEnv"] = field(default_factory=dict)
     node_reqs: List[NodeReq] = field(default_factory=list)
     tools: Dict[str, ToolConfig] = field(default_factory=dict)
+    wheel_sources: Dict[str, str] = field(default_factory=dict)  # package -> wheel_template URL
 
     @property
     def has_system(self) -> bool:

comfy_env/env/config_file.py

@@ -219,7 +219,7 @@ def _parse_config(data: Dict[str, Any], base_dir: Path) -> IsolatedEnv:
 
     # Handle pytorch version - auto-derive if "auto" or not specified
     pytorch_version = env_section.get("pytorch_version") or env_section.get("pytorch")
-    if pytorch_version == "auto" or (pytorch_version is None and cuda):
+    if pytorch_version == "auto" or pytorch_version is None:
         pytorch_version = _get_default_pytorch_version(cuda)
 
     if pytorch_version:
@@ -332,7 +332,7 @@ def _substitute_vars(s: str, variables: Dict[str, str]) -> str:
 # =============================================================================
 
 # Reserved table names that are NOT isolated environments
-RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "tools", "system"}
+RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "tools", "system", "wheel_sources"}
 
 
 def load_config(
@@ -415,6 +415,7 @@ def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig
         [envname.cuda]      - CUDA packages for env
         [envname.packages]  - Packages for env
         [node_reqs]         - Node dependencies
+        [wheel_sources]     - Custom wheel URL templates
 
     Also supports simple format ([env] + [packages]) for backward compatibility.
     """
@@ -431,6 +432,7 @@ def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig
     envs = _parse_env_sections(data, base_dir)
     node_reqs = _parse_node_reqs(data.get("node_reqs", {}))
     tools = _parse_tools_section(data.get("tools", {}))
+    wheel_sources = _parse_wheel_sources_section(data.get("wheel_sources", {}))
 
     return EnvManagerConfig(
         system=system,
@@ -438,6 +440,7 @@ def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig
         envs=envs,
         node_reqs=node_reqs,
         tools=tools,
+        wheel_sources=wheel_sources,
     )
 
 
@@ -656,6 +659,24 @@ def _parse_system_section(system_data: Dict[str, Any]) -> SystemConfig:
     )
 
 
+def _parse_wheel_sources_section(wheel_sources_data: Dict[str, Any]) -> Dict[str, str]:
+    """Parse [wheel_sources] section.
+
+    Supports:
+        [wheel_sources]
+        nvdiffrast = "https://example.com/nvdiffrast-{version}+cu{cuda_short}-{py_tag}-{platform}.whl"
+        my-package = "https://my-server.com/my-package-{version}.whl"
+
+    Returns:
+        Dict mapping package name (lowercase) to wheel URL template
+    """
+    wheel_sources = {}
+    for name, url_template in wheel_sources_data.items():
+        if isinstance(url_template, str):
+            wheel_sources[name.lower()] = url_template
+    return wheel_sources
+
+
 def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
     """Convert simple config format to full EnvManagerConfig.
 
@@ -665,9 +686,10 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
     # Parse using simple parser to get IsolatedEnv
     simple_env = _parse_config(data, base_dir)
 
-    # Parse tools and system sections (shared between simple and full format)
+    # Parse tools, system, and wheel_sources sections (shared between simple and full format)
     tools = _parse_tools_section(data.get("tools", {}))
     system = _parse_system_section(data.get("system", {}))
+    wheel_sources = _parse_wheel_sources_section(data.get("wheel_sources", {}))
 
     # Check if this has explicit env settings (isolated venv) vs just CUDA packages (local install)
     env_section = data.get("env", {})
@@ -681,6 +703,7 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
             envs={simple_env.name: simple_env},
             node_reqs=[],
             tools=tools,
+            wheel_sources=wheel_sources,
         )
     else:
         # Local CUDA packages only (no isolated venv)
@@ -701,4 +724,5 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
             envs={},
             node_reqs=[],
             tools=tools,
+            wheel_sources=wheel_sources,
         )

comfy_env/env/manager.py

@@ -22,7 +22,6 @@ from .security import (
 )
 from ..registry import PACKAGE_REGISTRY, is_registered, get_cuda_short2
 from ..resolver import RuntimeEnv, parse_wheel_requirement
-from ..index_resolver import resolve_wheel_from_index
 
 
 class IsolatedEnvManager:
@@ -373,7 +372,6 @@ class IsolatedEnvManager:
         vars_dict = runtime_env.as_dict()
         if env.cuda:
             vars_dict["cuda_short2"] = get_cuda_short2(env.cuda)
-        # Add py_tag for wheel filename templates (e.g., cp310)
         vars_dict["py_tag"] = f"cp{env.python.replace('.', '')}"
 
         for req in env.no_deps_requirements:
@@ -382,142 +380,45 @@ class IsolatedEnvManager:
 
             if pkg_lower in PACKAGE_REGISTRY:
                 config = PACKAGE_REGISTRY[pkg_lower]
-                method = config["method"]
-                self.log(f"  Installing {package} ({method})...")
-
-                if method == "index":
-                    # PEP 503 index - try to resolve exact wheel URL first
-                    index_url = self._substitute_template(config["index_url"], vars_dict)
-                    pkg_spec = f"{package}=={version}" if version else package
-                    # Try to resolve exact wheel URL from index
-                    wheel_url = resolve_wheel_from_index(index_url, package, vars_dict, version)
-                    if wheel_url:
-                        # Install from resolved URL directly (guarantees we get what we resolved)
-                        self.log(f"    Wheel: {wheel_url}")
-                        result = subprocess.run(
-                            pip_args + ["--no-deps", wheel_url],
-                            capture_output=True, text=True,
-                        )
-                    else:
-                        # Fallback to index-based resolution
-                        self.log(f"    Index: {index_url}")
-                        self.log(f"    Package: {pkg_spec}")
-                        result = subprocess.run(
-                            pip_args + ["--extra-index-url", index_url, "--no-deps", pkg_spec],
-                            capture_output=True, text=True,
-                        )
-
-                elif method in ("github_index", "find_links"):
-                    # GitHub Pages or generic find-links
-                    index_url = self._substitute_template(config["index_url"], vars_dict)
-                    pkg_spec = f"{package}=={version}" if version else package
-                    # Try to resolve exact wheel URL from find-links page
-                    wheel_url = resolve_wheel_from_index(index_url, package, vars_dict, version)
-                    if wheel_url:
-                        # Install from resolved URL directly (guarantees we get what we resolved)
-                        self.log(f"    Wheel: {wheel_url}")
-                        result = subprocess.run(
-                            pip_args + ["--no-deps", wheel_url],
-                            capture_output=True, text=True,
-                        )
-                    else:
-                        # Fallback to find-links based resolution
-                        self.log(f"    Find-links: {index_url}")
-                        self.log(f"    Package: {pkg_spec}")
-                        result = subprocess.run(
-                            pip_args + ["--find-links", index_url, "--no-deps", pkg_spec],
-                            capture_output=True, text=True,
-                        )
-
-                elif method == "pypi_variant":
-                    # Transform package name based on CUDA version
-                    actual_package = self._substitute_template(config["package_template"], vars_dict)
-                    pkg_spec = f"{actual_package}=={version}" if version else actual_package
-                    self.log(f"    PyPI variant: {pkg_spec}")
+
+                if "wheel_template" in config:
+                    # Direct wheel URL from template
+                    effective_version = version or config.get("default_version")
+                    if not effective_version:
+                        raise RuntimeError(f"Package {package} requires version (no default in registry)")
+
+                    vars_dict["version"] = effective_version
+                    wheel_url = self._substitute_template(config["wheel_template"], vars_dict)
+                    self.log(f"  Installing {package}=={effective_version}...")
+                    self.log(f"    URL: {wheel_url}")
                     result = subprocess.run(
-                        pip_args + ["--no-deps", pkg_spec],
+                        pip_args + ["--no-deps", wheel_url],
                         capture_output=True, text=True,
                     )
-
-                elif method == "github_release":
-                    # Direct wheel URL from GitHub releases
-                    release_vars = vars_dict.copy()
-                    release_vars["version"] = version or ""
-                    self._install_from_github_release(
-                        package, version, release_vars, config, pip_args
-                    )
-                    continue  # Already handled
-
-                else:
-                    # Unknown method - try regular install
-                    self.log(f"    Unknown method '{method}', trying regular install")
-                    pkg_spec = f"{package}=={version}" if version else package
+                    if result.returncode != 0:
+                        raise RuntimeError(f"Failed to install {package}: {result.stderr}")
+
+                elif "package_name" in config:
+                    # PyPI variant (e.g., spconv-cu124)
+                    pkg_name = self._substitute_template(config["package_name"], vars_dict)
+                    pkg_spec = f"{pkg_name}=={version}" if version else pkg_name
+                    self.log(f"  Installing {package} as {pkg_spec}...")
                     result = subprocess.run(
-                        pip_args + ["--no-deps", pkg_spec],
+                        pip_args + [pkg_spec],
                         capture_output=True, text=True,
                     )
+                    if result.returncode != 0:
+                        raise RuntimeError(f"Failed to install {package}: {result.stderr}")
+
+                else:
+                    raise RuntimeError(f"Package {package} in registry but missing wheel_template or package_name")
 
-                if result.returncode != 0:
-                    raise RuntimeError(f"Failed to install {package}: {result.stderr}")
             else:
-                # Not in registry - try regular pip install (e.g., spconv-cu126)
-                self.log(f"  Installing {package} (PyPI)...")
-                pkg_spec = f"{package}=={version}" if version else package
-                result = subprocess.run(
-                    pip_args + ["--no-deps", pkg_spec],
-                    capture_output=True, text=True,
+                # Not in registry - error
+                raise RuntimeError(
+                    f"Package {package} not found in registry. "
+                    f"Add wheel_template to [wheel_sources] in comfy-env.toml"
                 )
-                if result.returncode != 0:
-                    raise RuntimeError(f"Failed to install {package}: {result.stderr}")
-
-    def _install_from_github_release(
-        self,
-        package: str,
-        version: str,
-        vars_dict: dict,
-        config: dict,
-        pip_args: list,
-    ) -> None:
-        """Install package from GitHub release wheels with fallback sources."""
-        import platform as plat
-        import sys
-        # Use consistent platform tags (win_amd64, linux_x86_64, etc.)
-        if sys.platform == 'win32':
-            machine = plat.machine().lower()
-            current_platform = 'win_amd64' if machine in ('amd64', 'x86_64') else f'win_{machine}'
-        elif sys.platform == 'darwin':
-            current_platform = f"macosx_{plat.machine()}"
-        else:
-            current_platform = f"linux_{plat.machine()}"
-
-        sources = config.get("sources", [])
-        errors = []
-
-        for source in sources:
-            # Check platform compatibility
-            platforms = source.get("platforms", [])
-            if platforms and not any(p in current_platform for p in platforms):
-                continue
-
-            url_template = source["url_template"]
-            url = self._substitute_template(url_template, vars_dict)
-
-            self.log(f"    Trying {source.get('name', 'unknown')}: {url}")
-            result = subprocess.run(
-                pip_args + ["--no-deps", url],
-                capture_output=True, text=True,
-            )
-
-            if result.returncode == 0:
-                return  # Success!
-
-            errors.append(f"{source.get('name', 'unknown')}: {result.stderr.strip()}")
-
-        # All sources failed
-        raise RuntimeError(
-            f"Failed to install {package}=={version} from any source:\n"
-            + "\n".join(errors)
-        )
 
     def _substitute_template(self, template: str, vars_dict: dict) -> str:
         """Substitute template variables with environment values."""