comfy-env 0.0.8__py3-none-any.whl → 0.0.16__py3-none-any.whl

comfy_env/env/cuda_gpu_detection.py

@@ -0,0 +1,303 @@
+"""
+Robust CUDA/GPU detection with multiple fallback methods.
+
+Detection priority: NVML → PyTorch → nvidia-smi → sysfs → env vars
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import subprocess
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+CUDA_VERSION_ENV_VAR = "COMFY_ENV_CUDA_VERSION"
+
+_cache: tuple[float, "CUDAEnvironment | None"] = (0, None)
+CACHE_TTL = 60
+
+
+@dataclass
+class GPUInfo:
+    index: int
+    name: str
+    compute_capability: tuple[int, int]
+    architecture: str
+    vram_total_mb: int = 0
+    vram_free_mb: int = 0
+    uuid: str = ""
+    pci_bus_id: str = ""
+    driver_version: str = ""
+
+    def cc_str(self) -> str:
+        return f"{self.compute_capability[0]}.{self.compute_capability[1]}"
+
+    def sm_version(self) -> str:
+        return f"sm_{self.compute_capability[0]}{self.compute_capability[1]}"
+
+
+@dataclass
+class CUDAEnvironment:
+    gpus: list[GPUInfo] = field(default_factory=list)
+    driver_version: str = ""
+    cuda_runtime_version: str = ""
+    recommended_cuda: str = ""
+    detection_method: str = ""
+
+
+COMPUTE_TO_ARCH = {
+    (5, 0): "Maxwell", (5, 2): "Maxwell", (5, 3): "Maxwell",
+    (6, 0): "Pascal", (6, 1): "Pascal", (6, 2): "Pascal",
+    (7, 0): "Volta", (7, 2): "Volta", (7, 5): "Turing",
+    (8, 0): "Ampere", (8, 6): "Ampere", (8, 7): "Ampere", (8, 9): "Ada",
+    (9, 0): "Hopper",
+    (10, 0): "Blackwell", (10, 1): "Blackwell", (10, 2): "Blackwell",
+}
+
+
+def _cc_to_arch(major: int, minor: int) -> str:
+    if arch := COMPUTE_TO_ARCH.get((major, minor)):
+        return arch
+    if major >= 10: return "Blackwell"
+    if major == 9: return "Hopper"
+    if major == 8: return "Ada" if minor >= 9 else "Ampere"
+    if major == 7: return "Turing" if minor >= 5 else "Volta"
+    if major == 6: return "Pascal"
+    return "Maxwell" if major == 5 else "Unknown"
+
+
+def _parse_cc(s: str) -> tuple[int, int]:
+    try:
+        if "." in s:
+            p = s.split(".")
+            return (int(p[0]), int(p[1]))
+        if len(s) >= 2:
+            return (int(s[:-1]), int(s[-1]))
+    except (ValueError, IndexError):
+        pass
+    return (0, 0)
+
+
+def _detect_nvml() -> list[GPUInfo] | None:
+    try:
+        import pynvml
+        pynvml.nvmlInit()
+        try:
+            count = pynvml.nvmlDeviceGetCount()
+            if not count:
+                return None
+            gpus = []
+            for i in range(count):
+                h = pynvml.nvmlDeviceGetHandleByIndex(i)
+                name = pynvml.nvmlDeviceGetName(h)
+                if isinstance(name, bytes): name = name.decode()
+                cc = pynvml.nvmlDeviceGetCudaComputeCapability(h)
+                mem = pynvml.nvmlDeviceGetMemoryInfo(h)
+                gpus.append(GPUInfo(
+                    index=i, name=name, compute_capability=cc,
+                    architecture=_cc_to_arch(*cc),
+                    vram_total_mb=mem.total // (1024*1024),
+                    vram_free_mb=mem.free // (1024*1024),
+                ))
+            return gpus
+        finally:
+            pynvml.nvmlShutdown()
+    except Exception:
+        return None
+
+
+def _detect_torch() -> list[GPUInfo] | None:
+    try:
+        import torch
+        if not torch.cuda.is_available():
+            return None
+        gpus = []
+        for i in range(torch.cuda.device_count()):
+            p = torch.cuda.get_device_properties(i)
+            gpus.append(GPUInfo(
+                index=i, name=p.name,
+                compute_capability=(p.major, p.minor),
+                architecture=_cc_to_arch(p.major, p.minor),
+                vram_total_mb=p.total_memory // (1024*1024),
+            ))
+        return gpus if gpus else None
+    except Exception:
+        return None
+
+
+def _detect_smi() -> list[GPUInfo] | None:
+    try:
+        r = subprocess.run(
+            ["nvidia-smi", "--query-gpu=index,name,uuid,pci.bus_id,compute_cap,memory.total,memory.free,driver_version",
+             "--format=csv,noheader,nounits"],
+            capture_output=True, text=True, timeout=10
+        )
+        if r.returncode != 0:
+            return None
+        gpus = []
+        for line in r.stdout.strip().split("\n"):
+            if not line.strip():
+                continue
+            p = [x.strip() for x in line.split(",")]
+            if len(p) < 5:
+                continue
+            cc = _parse_cc(p[4])
+            gpus.append(GPUInfo(
+                index=int(p[0]) if p[0].isdigit() else len(gpus),
+                name=p[1], uuid=p[2] if len(p) > 2 else "",
+                pci_bus_id=p[3] if len(p) > 3 else "",
+                compute_capability=cc, architecture=_cc_to_arch(*cc),
+                vram_total_mb=int(p[5]) if len(p) > 5 and p[5].isdigit() else 0,
+                vram_free_mb=int(p[6]) if len(p) > 6 and p[6].isdigit() else 0,
+                driver_version=p[7] if len(p) > 7 else "",
+            ))
+        return gpus if gpus else None
+    except Exception:
+        return None
+
+
+def _detect_sysfs() -> list[GPUInfo] | None:
+    try:
+        pci_path = Path("/sys/bus/pci/devices")
+        if not pci_path.exists():
+            return None
+        gpus = []
+        for d in sorted(pci_path.iterdir()):
+            vendor = (d / "vendor").read_text().strip().lower() if (d / "vendor").exists() else ""
+            if "10de" not in vendor:
+                continue
+            cls = (d / "class").read_text().strip() if (d / "class").exists() else ""
+            if not (cls.startswith("0x0300") or cls.startswith("0x0302")):
+                continue
+            gpus.append(GPUInfo(
+                index=len(gpus), name=f"NVIDIA GPU", pci_bus_id=d.name,
+                compute_capability=(0, 0), architecture="Unknown"
+            ))
+        return gpus if gpus else None
+    except Exception:
+        return None
+
+
+def _get_driver_version() -> str:
+    try:
+        import pynvml
+        pynvml.nvmlInit()
+        v = pynvml.nvmlSystemGetDriverVersion()
+        pynvml.nvmlShutdown()
+        return v.decode() if isinstance(v, bytes) else v
+    except Exception:
+        pass
+    try:
+        r = subprocess.run(["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader"],
+                          capture_output=True, text=True, timeout=5)
+        if r.returncode == 0:
+            return r.stdout.strip().split("\n")[0]
+    except Exception:
+        pass
+    return ""
+
+
+def _get_cuda_version() -> str:
+    try:
+        import torch
+        if torch.cuda.is_available() and torch.version.cuda:
+            return torch.version.cuda
+    except Exception:
+        pass
+    try:
+        r = subprocess.run(["nvcc", "--version"], capture_output=True, text=True, timeout=5)
+        if m := re.search(r"release (\d+\.\d+)", r.stdout):
+            return m.group(1)
+    except Exception:
+        pass
+    return ""
+
+
+def _recommended_cuda(gpus: list[GPUInfo]) -> str:
+    if override := os.environ.get(CUDA_VERSION_ENV_VAR, "").strip():
+        if "." not in override and len(override) >= 2:
+            return f"{override[:-1]}.{override[-1]}"
+        return override
+    if not gpus:
+        return ""
+    for gpu in gpus:
+        if gpu.compute_capability[0] >= 10:
+            return "12.8"  # Blackwell requires 12.8
+    for gpu in gpus:
+        cc = gpu.compute_capability
+        if cc[0] < 7 or (cc[0] == 7 and cc[1] < 5):
+            return "12.4"  # Legacy (Pascal) uses 12.4
+    return "12.8"  # Modern GPUs use 12.8
+
+
+def detect_cuda_environment(force_refresh: bool = False) -> CUDAEnvironment:
+    global _cache
+    if not force_refresh and _cache[1] and time.time() - _cache[0] < CACHE_TTL:
+        return _cache[1]
+
+    gpus, method = None, "none"
+    for name, fn in [("nvml", _detect_nvml), ("torch", _detect_torch),
+                     ("smi", _detect_smi), ("sysfs", _detect_sysfs)]:
+        if gpus := fn():
+            method = name
+            break
+
+    env = CUDAEnvironment(
+        gpus=gpus or [],
+        driver_version=_get_driver_version(),
+        cuda_runtime_version=_get_cuda_version(),
+        recommended_cuda=_recommended_cuda(gpus or []),
+        detection_method=method,
+    )
+    _cache = (time.time(), env)
+    return env
+
+
+def get_recommended_cuda_version() -> str | None:
+    if override := os.environ.get(CUDA_VERSION_ENV_VAR, "").strip():
+        if "." not in override and len(override) >= 2:
+            return f"{override[:-1]}.{override[-1]}"
+        return override
+    env = detect_cuda_environment()
+    return env.recommended_cuda or None
+
+
+def detect_gpus() -> list[GPUInfo]:
+    return detect_cuda_environment().gpus
+
+
+def detect_gpu_info() -> list[dict]:
+    """Return GPU info as list of dicts."""
+    from dataclasses import asdict
+    return [asdict(gpu) for gpu in detect_gpus()]
+
+
+def get_gpu_summary() -> str:
+    """Human-readable GPU summary."""
+    env = detect_cuda_environment()
+    if not env.gpus:
+        override = os.environ.get(CUDA_VERSION_ENV_VAR)
+        if override:
+            return f"No NVIDIA GPU detected (using {CUDA_VERSION_ENV_VAR}={override})"
+        return f"No NVIDIA GPU detected (set {CUDA_VERSION_ENV_VAR} to override)"
+
+    lines = [f"Detection: {env.detection_method}"]
+    if env.driver_version:
+        lines.append(f"Driver: {env.driver_version}")
+    if env.cuda_runtime_version:
+        lines.append(f"CUDA: {env.cuda_runtime_version}")
+    lines.append(f"Recommended: CUDA {env.recommended_cuda}")
+    lines.append("")
+    for gpu in env.gpus:
+        vram = f"{gpu.vram_total_mb}MB" if gpu.vram_total_mb else "?"
+        lines.append(f"  GPU {gpu.index}: {gpu.name} ({gpu.sm_version()}) [{gpu.architecture}] {vram}")
+    return "\n".join(lines)
+
+
+# Aliases
+detect_cuda_version = get_recommended_cuda_version

comfy_env/env/manager.py

@@ -6,12 +6,13 @@ Uses uv for fast environment creation and package installation.
 
 import subprocess
 import shutil
+import sys
 from pathlib import Path
 from typing import Optional, Callable
 
 from .config import IsolatedEnv
 from .platform import get_platform, PlatformProvider
-from .detection import detect_cuda_version
+from .cuda_gpu_detection import detect_cuda_version
 from .security import (
     normalize_env_name,
     validate_dependency,
@@ -263,13 +264,29 @@ class IsolatedEnvManager:
         """
         python_exe = self.get_python(env)
 
-        if not env.requirements and not env.requirements_file:
+        # Merge platform-specific requirements
+        if sys.platform == 'win32':
+            platform_reqs = env.windows_requirements
+            platform_name = 'Windows'
+        elif sys.platform == 'darwin':
+            platform_reqs = env.darwin_requirements
+            platform_name = 'macOS'
+        else:
+            platform_reqs = env.linux_requirements
+            platform_name = 'Linux'
+
+        all_requirements = list(env.requirements) + list(platform_reqs)
+
+        if platform_reqs:
+            self.log(f"Including {len(platform_reqs)} {platform_name}-specific packages")
+
+        if not all_requirements and not env.requirements_file:
             self.log("No requirements to install")
             return
 
         # Validate requirements for security
-        if env.requirements:
-            validate_dependencies(env.requirements)
+        if all_requirements:
+            validate_dependencies(all_requirements)
 
         # Validate wheel sources
         for wheel_source in env.wheel_sources:
@@ -311,11 +328,11 @@ class IsolatedEnvManager:
             self.log(f"Installing {len(env.no_deps_requirements)} CUDA packages")
             self._install_cuda_packages(env, pip_args)
 
-        # Install individual requirements
-        if env.requirements:
-            self.log(f"Installing {len(env.requirements)} packages")
+        # Install individual requirements (including platform-specific)
+        if all_requirements:
+            self.log(f"Installing {len(all_requirements)} packages")
             result = subprocess.run(
-                pip_args + env.requirements,
+                pip_args + all_requirements,
                 capture_output=True,
                 text=True,
             )
@@ -458,7 +475,7 @@ class IsolatedEnvManager:
             url_template = source["url_template"]
             url = self._substitute_template(url_template, vars_dict)
 
-            self.log(f"    Trying {source.get('name', 'unknown')}: {url[:80]}...")
+            self.log(f"    Trying {source.get('name', 'unknown')}: {url}")
             result = subprocess.run(
                 pip_args + ["--no-deps", url],
                 capture_output=True, text=True,
@@ -467,7 +484,7 @@ class IsolatedEnvManager:
             if result.returncode == 0:
                 return  # Success!
 
-            errors.append(f"{source.get('name', 'unknown')}: {result.stderr[:100]}")
+            errors.append(f"{source.get('name', 'unknown')}: {result.stderr.strip()}")
 
         # All sources failed
         raise RuntimeError(

comfy_env/env/platform/windows.py

@@ -45,12 +45,7 @@ class WindowsPlatformProvider(PlatformProvider):
                     f"Running in {shell_env.upper()} environment.\n"
                     f"This package requires native Windows Python.\n"
                     f"Please use PowerShell, Command Prompt, or native Windows terminal.")
-
-        # Check Visual C++ Redistributable
-        vc_ok, vc_error = self._check_vc_redistributable()
-        if not vc_ok:
-            return (False, vc_error)
-
+        # Note: VC++ runtime is handled by msvc-runtime package, no system check needed
         return (True, None)
 
     def _detect_shell_environment(self) -> str:
@@ -67,94 +62,6 @@ class WindowsPlatformProvider(PlatformProvider):
 
         return 'native-windows'
 
-    def _find_vc_dlls(self) -> Dict[str, Optional[Path]]:
-        """Find VC++ runtime DLLs in common locations."""
-        required_dlls = ['vcruntime140.dll', 'msvcp140.dll']
-        found = {}
-
-        # Search locations in order of preference
-        search_paths = []
-
-        # 1. Current Python environment (conda/venv)
-        if hasattr(sys, 'base_prefix'):
-            search_paths.append(Path(sys.base_prefix) / 'Library' / 'bin')
-            search_paths.append(Path(sys.base_prefix) / 'DLLs')
-        if hasattr(sys, 'prefix'):
-            search_paths.append(Path(sys.prefix) / 'Library' / 'bin')
-            search_paths.append(Path(sys.prefix) / 'DLLs')
-
-        # 2. System directories
-        system_root = os.environ.get('SystemRoot', r'C:\Windows')
-        search_paths.append(Path(system_root) / 'System32')
-
-        # 3. Visual Studio redistributable directories
-        program_files = os.environ.get('ProgramFiles', r'C:\Program Files')
-        vc_redist = Path(program_files) / 'Microsoft Visual Studio' / '2022' / 'Community' / 'VC' / 'Redist' / 'MSVC'
-        if vc_redist.exists():
-            for version_dir in vc_redist.iterdir():
-                search_paths.append(version_dir / 'x64' / 'Microsoft.VC143.CRT')
-
-        for dll_name in required_dlls:
-            found[dll_name] = None
-            for search_path in search_paths:
-                dll_path = search_path / dll_name
-                if dll_path.exists():
-                    found[dll_name] = dll_path
-                    break
-
-        return found
-
-    def bundle_vc_dlls_to_env(self, env_dir: Path) -> Tuple[bool, Optional[str]]:
-        """Bundle VC++ runtime DLLs into the isolated environment."""
-        required_dlls = ['vcruntime140.dll', 'msvcp140.dll']
-        found_dlls = self._find_vc_dlls()
-
-        # Check which DLLs are missing
-        missing = [dll for dll, path in found_dlls.items() if path is None]
-
-        if missing:
-            return (False,
-                f"Could not find VC++ DLLs to bundle: {', '.join(missing)}\n\n"
-                f"Please install Visual C++ Redistributable:\n"
-                f"  Download: https://aka.ms/vs/17/release/vc_redist.x64.exe\n"
-                f"\nAfter installation, delete the environment and try again.")
-
-        # Copy DLLs to the environment's Scripts directory
-        scripts_dir = env_dir / 'Scripts'
-
-        copied = []
-        for dll_name, source_path in found_dlls.items():
-            if source_path:
-                try:
-                    if scripts_dir.exists():
-                        scripts_target = scripts_dir / dll_name
-                        if not scripts_target.exists():
-                            shutil.copy2(source_path, scripts_target)
-                            copied.append(f"{dll_name} -> Scripts/")
-                except (OSError, IOError) as e:
-                    return (False, f"Failed to copy {dll_name}: {e}")
-
-        return (True, None)
-
-    def _check_vc_redistributable(self) -> Tuple[bool, Optional[str]]:
-        """Check if Visual C++ Redistributable DLLs are available."""
-        required_dlls = ['vcruntime140.dll', 'msvcp140.dll']
-        found_dlls = self._find_vc_dlls()
-
-        missing = [dll for dll, path in found_dlls.items() if path is None]
-
-        if missing:
-            error_msg = (
-                f"Visual C++ Redistributable DLLs not found!\n"
-                f"\nMissing: {', '.join(missing)}\n"
-                f"\nPlease install Visual C++ Redistributable for Visual Studio 2015-2022:\n"
-                f"\n  Download (64-bit): https://aka.ms/vs/17/release/vc_redist.x64.exe\n"
-                f"\nAfter installation, restart your terminal and try again."
-            )
-            return (False, error_msg)
-
-        return (True, None)
-
     def make_executable(self, path: Path) -> None:
         # No-op on Windows - executables are determined by extension
         pass

comfy_env/errors.py

@@ -291,35 +291,3 @@ class InstallError(EnvManagerError):
 
         details = "\n".join(details_parts) if details_parts else None
         super().__init__(message, details)
-
-
-def format_environment_mismatch(
-    expected: "RuntimeEnv",
-    actual: "RuntimeEnv",
-) -> str:
-    """
-    Format a message explaining environment mismatch.
-
-    Used when the current environment doesn't match what's needed.
-    """
-    mismatches = []
-
-    if expected.cuda_version != actual.cuda_version:
-        mismatches.append(
-            f"  CUDA: expected {expected.cuda_version}, got {actual.cuda_version}"
-        )
-
-    if expected.torch_version != actual.torch_version:
-        mismatches.append(
-            f"  PyTorch: expected {expected.torch_version}, got {actual.torch_version}"
-        )
-
-    if expected.python_version != actual.python_version:
-        mismatches.append(
-            f"  Python: expected {expected.python_version}, got {actual.python_version}"
-        )
-
-    if not mismatches:
-        return "Environment matches expected configuration"
-
-    return "Environment mismatch:\n" + "\n".join(mismatches)

comfy_env/install.py

@@ -24,12 +24,13 @@ import sys
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
-from .env.config import IsolatedEnv
-from .env.config_file import discover_env_config, load_env_from_file
+from .env.config import IsolatedEnv, ToolConfig
+from .env.config_file import discover_env_config, load_env_from_file, load_config, discover_config
 from .env.manager import IsolatedEnvManager
 from .errors import CUDANotFoundError, DependencyError, InstallError, WheelNotFoundError
 from .registry import PACKAGE_REGISTRY, get_cuda_short2, is_registered
 from .resolver import RuntimeEnv, WheelResolver, parse_wheel_requirement
+from .tools import install_tool
 
 
 def install(
@@ -77,20 +78,40 @@ def install(
     log = log_callback or print
     node_dir = Path(node_dir) if node_dir else Path.cwd()
 
-    # Load configuration
-    env_config = _load_config(config, node_dir)
-    if env_config is None:
+    # Load full configuration (includes tools)
+    full_config = _load_full_config(config, node_dir)
+    if full_config is None:
         raise FileNotFoundError(
             "No configuration file found. "
             "Create comfyui_env.toml or specify path explicitly."
         )
 
-    log(f"Found configuration: {env_config.name}")
+    # Install tools first (e.g., Blender)
+    # Tools are installed to ComfyUI root (shared across all nodes)
+    if full_config.tools:
+        log(f"Installing {len(full_config.tools)} tool(s)...")
+        comfyui_root = node_dir.parent.parent  # custom_nodes/../.. = ComfyUI/
+        for name, tool_config in full_config.tools.items():
+            if dry_run:
+                log(f"  Would install {name} {tool_config.version}")
+            else:
+                install_tool(tool_config, log, comfyui_root)
+
+    # Get environment config
+    env_config = full_config.default_env
+    if env_config is None and not full_config.has_local:
+        log("No packages to install")
+        return True
+
+    if env_config:
+        log(f"Found configuration: {env_config.name}")
 
-    if mode == "isolated":
+    if mode == "isolated" and env_config:
         return _install_isolated(env_config, node_dir, log, dry_run)
-    else:
+    elif env_config:
         return _install_inplace(env_config, node_dir, log, dry_run, verify_wheels)
+    else:
+        return True
 
 
 def _load_config(
@@ -107,6 +128,17 @@ def _load_config(
     return discover_env_config(node_dir)
 
 
+def _load_full_config(config: Optional[Union[str, Path]], node_dir: Path):
+    """Load full EnvManagerConfig (includes tools)."""
+    from .env.config import EnvManagerConfig
+    if config is not None:
+        config_path = Path(config)
+        if not config_path.is_absolute():
+            config_path = node_dir / config_path
+        return load_config(config_path, node_dir)
+    return discover_config(node_dir)
+
+
 def _install_isolated(
     env_config: IsolatedEnv,
     node_dir: Path,
@@ -140,6 +172,12 @@ def _install_inplace(
     """Install in-place into current environment using the package registry."""
     log("Installing in-place mode")
 
+    # Install MSVC runtime on Windows (required for CUDA/PyTorch native extensions)
+    if sys.platform == "win32":
+        log("Installing MSVC runtime for Windows...")
+        if not dry_run:
+            _pip_install(["msvc-runtime"], no_deps=False, log=log)
+
     # Detect runtime environment
     env = RuntimeEnv.detect()
     log(f"Detected environment: {env}")
@@ -421,6 +459,7 @@ def _install_from_github_release(
                 url = url.replace(f"{{{key}}}", str(value))
 
         log(f"  Trying {source_name}: {package}=={version}...")
+        log(f"    Resolved wheel to: {url}")
 
         try:
             pip_cmd = _get_pip_command()

comfy_env/ipc/bridge.py

@@ -48,10 +48,6 @@ class WorkerBridge:
         result = bridge.call("process", image=my_image)
     """
 
-    # Singleton instances by environment hash
-    _instances: Dict[str, "WorkerBridge"] = {}
-    _instances_lock = threading.Lock()
-
     def __init__(
         self,
         env: IsolatedEnv,
@@ -81,38 +77,6 @@ class WorkerBridge:
         self._process_lock = threading.Lock()
         self._stderr_thread: Optional[threading.Thread] = None
 
-    @classmethod
-    def get_instance(
-        cls,
-        env: IsolatedEnv,
-        worker_script: Path,
-        base_dir: Optional[Path] = None,
-        log_callback: Optional[Callable[[str], None]] = None,
-    ) -> "WorkerBridge":
-        """
-        Get or create a singleton bridge instance for an environment.
-
-        Args:
-            env: Isolated environment configuration
-            worker_script: Path to the worker Python script
-            base_dir: Base directory for environments
-            log_callback: Optional callback for logging
-
-        Returns:
-            WorkerBridge instance (reused if same env hash)
-        """
-        env_hash = env.get_env_hash()
-
-        with cls._instances_lock:
-            if env_hash not in cls._instances:
-                cls._instances[env_hash] = cls(
-                    env=env,
-                    worker_script=worker_script,
-                    base_dir=base_dir,
-                    log_callback=log_callback,
-                )
-            return cls._instances[env_hash]
-
     @classmethod
     def from_config_file(
         cls,