comfygit-core 0.5.0__tar.gz → 0.6.0__tar.gz

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfygit-core
-Version: 0.5.0
+Version: 0.6.0
 Summary: ComfyGit Core - Git-based ComfyUI environment manager
 Project-URL: Documentation, https://docs.comfygit.org/
 Project-URL: Repository, https://github.com/comfygit-ai/comfygit
@@ -10,7 +10,7 @@ Requires-Python: >=3.10
 Requires-Dist: blake3>=0.3.3
 Requires-Dist: huggingface-hub>=0.11.0
 Requires-Dist: packaging>=16.2
-Requires-Dist: requests>=2.33.0
+Requires-Dist: requests>=2.32.4
 Requires-Dist: requirements-parser>=0.11.0
 Requires-Dist: tomlkit>=0.11.0
 Requires-Dist: uv>=0.11.8

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfygit-core"
-version = "0.5.0"
+version = "0.6.0"
 description = "ComfyGit Core - Git-based ComfyUI environment manager"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -8,7 +8,7 @@ dependencies = [
     "blake3>=0.3.3",
     "huggingface_hub>=0.11.0",
     "packaging>=16.2",
-    "requests>=2.33.0",
+    "requests>=2.32.4",
     "requirements-parser>=0.11.0",
     "tomlkit>=0.11.0",
     "uv>=0.11.8",

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/analyzers/node_classifier.py

@@ -6,11 +6,10 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-import tomllib
-
 from ..configs.comfyui_builtin_nodes import COMFYUI_BUILTIN_NODES
 from ..logging.logging_config import get_logger
 from ..models.comfyui_builtin_versions import BuiltinVersionGateInfo
+from ..utils.toml_compat import tomllib
 
 if TYPE_CHECKING:
     from ..configs.model_config import ModelConfig

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/analyzers/node_git_analyzer.py

@@ -67,7 +67,7 @@ def get_node_git_info(node_path: Path) -> GitInfo | None:
                 git_info.github_repo = github_match.group(2).replace(".git", "")
 
         # Check if there are uncommitted changes
-        status_entries = git_status_porcelain(node_path)
+        status_entries = git_status_porcelain(node_path, check=False)
         git_info.is_dirty = bool(status_entries)
 
         return git_info

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/analyzers/status_scanner.py

@@ -41,6 +41,25 @@ def _versions_match(actual: str | None, expected: str | None) -> bool:
         return False
 
 
+_UV_DRY_RUN_CHANGE_PREFIXES = (
+    "Would update lockfile",
+    "Would download ",
+    "Would install ",
+    "Would uninstall ",
+    "Would upgrade ",
+    "Would downgrade ",
+    "Would remove ",
+)
+
+
+def _uv_dry_run_reports_changes(output: str) -> bool:
+    """Return True when uv dry-run output says sync would mutate the env."""
+    return any(
+        line.strip().startswith(_UV_DRY_RUN_CHANGE_PREFIXES)
+        for line in output.splitlines()
+    )
+
+
 class StatusScanner:
     """Scans environment to get current state."""
 
@@ -58,7 +77,12 @@ class StatusScanner:
         self._comfyui_path = comfyui_path
         self._pytorch_manager = pytorch_manager
 
-    def get_full_comparison(self) -> EnvironmentComparison:
+    def get_full_comparison(
+        self,
+        *,
+        check_package_sync: bool = False,
+        backend_override: str | None = None,
+    ) -> EnvironmentComparison:
         """Get complete environment comparison with all details.
 
         Args:
@@ -77,17 +101,19 @@ class StatusScanner:
         # Get basic comparison
         comparison = self.compare_states(current, expected)
 
-        # Skip package sync check for performance (100-500ms saved)
-        # Rationale:
-        #   - Users rarely manually modify .venv/
-        #   - Operations like 'run', 'repair', 'node add' auto-sync before executing
-        #   - Status is high-frequency with workflow caching - needs to be fast
-        #   - Package drift self-corrects on next sync operation
-        # If thorough check needed, use 'cg repair --dry-run' (future)
-        # TODO: Add package sync status
-        # package_status = self.check_packages_sync()
-        comparison.packages_in_sync = True #package_status.in_sync
-        comparison.package_sync_message = "" #package_status.message
+        if check_package_sync:
+            package_status = self.check_packages_sync(
+                backend_override=backend_override
+            )
+            comparison.packages_in_sync = package_status.in_sync
+            comparison.package_sync_message = package_status.message
+        else:
+            # Keep high-frequency status fast unless the manifest diff says uv
+            # materialization may be needed. Package drift self-corrects on the
+            # next explicit sync/run path, but dependency edits should guide the
+            # user to sync before committing.
+            comparison.packages_in_sync = True
+            comparison.package_sync_message = ""
 
         return comparison
 
@@ -400,7 +426,11 @@ class StatusScanner:
 
         return comparison
 
-    def check_packages_sync(self) -> PackageSyncStatus:
+    def check_packages_sync(
+        self,
+        *,
+        backend_override: str | None = None,
+    ) -> PackageSyncStatus:
         """Check if packages are in sync with pyproject.toml.
 
         Returns:
@@ -410,13 +440,20 @@ class StatusScanner:
             # Use UV's dry-run to check if sync would change anything
             # Disposable PyTorch overlay materialization ensures the check uses the correct backend.
             extras, all_extras = self._pyproject.resolve_sync_extras(None, False)
-            self._uv.sync_project(
+            dry_run_output = self._uv.sync_project(
                 dry_run=True,
                 all_groups=True,
                 pytorch_manager=self._pytorch_manager,
+                backend_override=backend_override,
                 extras=extras,
                 all_extras=all_extras,
             )
+            if _uv_dry_run_reports_changes(dry_run_output):
+                return PackageSyncStatus(
+                    in_sync=False,
+                    message="Packages out of sync (run 'cg sync' to update)",
+                    details=dry_run_output,
+                )
             return PackageSyncStatus(
                 in_sync=True, message="Packages match pyproject.toml"
             )

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/caching/workflow_cache.py

@@ -246,7 +246,7 @@ class WorkflowCacheRepository:
         if from_version == to_version:
             return
 
-        logger.info(f"Migrating workflow cache schema v{from_version} → v{to_version}")
+        logger.info(f"Migrating workflow cache schema v{from_version} -> v{to_version}")
 
         # Drop and recreate (cache is ephemeral)
         self.sqlite.execute_write("DROP TABLE IF EXISTS workflow_cache")

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/configs/package_config.py

@@ -31,6 +31,7 @@ DEFAULT_PROBE_PROTECTED = [
     "torchvision",
     "torchaudio",
     "torchsde",
+    "uv",
 ]
 
 class PackageConfigManager:

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/constants.py

@@ -77,6 +77,12 @@ LEGACY_SYSTEM_NODES = {
 MANAGER_NODE_ID = 'comfygit-manager'
 MANAGER_GITHUB_URL = 'https://github.com/comfygit-ai/comfygit-manager'
 
+# Runtime-only PyTorch backend override used by `cg run --torch-backend`.
+# This is intentionally non-persistent: it tells child Manager/UI processes
+# which backend policy launched the current ComfyUI process without writing to
+# `.pytorch-backend`.
+ACTIVE_TORCH_BACKEND_OVERRIDE_ENV = "COMFYGIT_TORCH_BACKEND_OVERRIDE"
+
 # Schema version for environment pyproject.toml format.
 # Increment when making breaking changes to the pyproject.toml structure.
 # v1: Original format with inline PyTorch config (indexes, sources, constraints)

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/core/environment.py

@@ -7,13 +7,14 @@ import re
 import shutil
 import subprocess
 from collections.abc import Mapping, Sequence
-from datetime import UTC, datetime
+from datetime import datetime, timezone
 from functools import cached_property, wraps
 from pathlib import Path
 from typing import TYPE_CHECKING, cast
 
 from ..analyzers.ref_diff_analyzer import RefDiffAnalyzer
 from ..analyzers.status_scanner import StatusScanner
+from ..constants import ACTIVE_TORCH_BACKEND_OVERRIDE_ENV
 from ..factories.uv_factory import create_uv_for_environment
 from ..logging.logging_config import get_logger
 from ..managers.environment_git_orchestrator import EnvironmentGitOrchestrator
@@ -82,6 +83,11 @@ if TYPE_CHECKING:
         DependencyResolutionApplyResult,
         DependencyResolutionPreview,
     )
+    from ..models.lifecycle import (
+        EnvironmentLifecycleStatus,
+        LifecycleOperationState,
+        LifecycleRuntimeState,
+    )
     from ..models.manifest import (
         EnvironmentManifestSnapshot,
         ManifestWorkflowEntry,
@@ -107,6 +113,7 @@ if TYPE_CHECKING:
     from ..services.node_lookup_service import NodeLookupService
 
 logger = get_logger(__name__)
+UTC = timezone.utc
 
 
 def _workflow_api_prompt_relpath(workflow_name: str) -> Path:
@@ -582,8 +589,27 @@ class Environment:
     # Environment Management
     # =====================================================
 
+    def _get_active_torch_backend_override(self) -> str | None:
+        """Return the non-persistent backend override active for this process."""
+        backend = os.environ.get(ACTIVE_TORCH_BACKEND_OVERRIDE_ENV)
+        if not backend:
+            return None
+
+        if self.is_valid_torch_backend(backend):
+            return backend
+
+        logger.warning(
+            "Ignoring invalid %s=%r",
+            ACTIVE_TORCH_BACKEND_OVERRIDE_ENV,
+            backend,
+        )
+        return None
+
     def status(self) -> EnvironmentStatus:
         """Get environment sync and git status."""
+        git_status = self.git_manager.get_status(self.pyproject)
+        active_backend_override = self._get_active_torch_backend_override()
+
         # Each subsystem provides its complete status
         scanner = StatusScanner(
             comfyui_path=self.comfyui_path,
@@ -592,9 +618,10 @@ class Environment:
             pyproject=self.pyproject,
             pytorch_manager=self.pytorch_manager,
         )
-        comparison = scanner.get_full_comparison()
-
-        git_status = self.git_manager.get_status(self.pyproject)
+        comparison = scanner.get_full_comparison(
+            check_package_sync=git_status.has_dependency_changes,
+            backend_override=active_backend_override,
+        )
 
         workflow_status = self.workflow_manager.get_workflow_status()
 
@@ -609,6 +636,37 @@ class Environment:
             missing_models=missing_models
         )
 
+    def get_lifecycle_status(
+        self,
+        *,
+        status: EnvironmentStatus | None = None,
+        include_readiness: bool = False,
+        runtime_state: LifecycleRuntimeState | None = None,
+        operation_state: LifecycleOperationState | None = None,
+    ) -> EnvironmentLifecycleStatus:
+        """Return composed lifecycle health and recommended actions.
+
+        This facade keeps adapters on the public Environment API. Core computes
+        manifest/filesystem/snapshot/workspace-index signals from existing
+        status/readiness paths; Manager or CLI may pass runtime/operation state
+        that only the adapter can observe.
+        """
+        from ..services.environment_lifecycle import (
+            build_lifecycle_status_from_environment_status,
+        )
+        from ..utils.git import git_rev_parse
+
+        readiness = self.get_readiness() if include_readiness else None
+        return build_lifecycle_status_from_environment_status(
+            status or self.status(),
+            environment_name=self.name,
+            workspace_path=str(self.workspace_paths.root),
+            current_commit=git_rev_parse(self.cec_path, "HEAD"),
+            readiness=readiness,
+            runtime_state=runtime_state,
+            operation_state=operation_state,
+        )
+
     def get_manager_status(self) -> ManagerStatus:
         """Check current comfygit-manager installation status.
 
@@ -652,7 +710,7 @@ class Environment:
                 is_legacy = True
                 # Try to read version from symlink target
                 try:
-                    import tomllib
+                    from ..utils.toml_compat import tomllib
                     target_pyproject = legacy_path / "pyproject.toml"
                     if target_pyproject.exists():
                         with open(target_pyproject, "rb") as f:
@@ -844,9 +902,8 @@ class Environment:
 
     def _register_existing_manager(self, manager_path: Path) -> None:
         """Register existing manager directory in pyproject.toml."""
-        import tomllib
-
         from ..constants import MANAGER_NODE_ID
+        from ..utils.toml_compat import tomllib
 
         # Detect version from manager's pyproject.toml
         version = None
@@ -961,6 +1018,10 @@ class Environment:
         """
         from ..services.environment_sync_coordinator import EnvironmentSyncCoordinator
 
+        effective_backend_override = (
+            backend_override or self._get_active_torch_backend_override()
+        )
+
         return EnvironmentSyncCoordinator(self).sync(
             dry_run=dry_run,
             model_strategy=model_strategy,
@@ -970,7 +1031,7 @@ class Environment:
             sync_callbacks=sync_callbacks,
             verbose=verbose,
             preserve_workflows=preserve_workflows,
-            backend_override=backend_override,
+            backend_override=effective_backend_override,
             overlay_names=overlay_names,
             extras=extras,
             all_extras=all_extras,
@@ -1469,10 +1530,9 @@ class Environment:
         Returns:
             MergeValidation with is_compatible flag and any conflicts
         """
-        import tomllib
-
         from ..merging.merge_validator import MergeValidator
         from ..utils.git import git_show
+        from ..utils.toml_compat import tomllib
 
         # Load configs from both branches
         pyproject_path = Path("pyproject.toml")
@@ -1509,12 +1569,11 @@ class Environment:
         Returns:
             MergeResult with success status and details
         """
-        import tomllib
-
         from ..merging.atomic_executor import AtomicMergeExecutor
         from ..merging.merge_validator import MergeValidator
         from ..models.merge_plan import MergePlan
         from ..utils.git import git_show
+        from ..utils.toml_compat import tomllib
 
         # Load configs to compute final workflow set
         pyproject_path = Path("pyproject.toml")
@@ -1599,11 +1658,18 @@ class Environment:
             raise
 
     # TODO wrap subprocess completed process instance
-    def run(self, args: list[str] | None = None) -> subprocess.CompletedProcess:
+    def run(
+        self,
+        args: list[str] | None = None,
+        *,
+        backend_override: str | None = None,
+    ) -> subprocess.CompletedProcess:
         """Run ComfyUI in this environment.
 
         Args:
             args: Arguments to pass to ComfyUI
+            backend_override: Non-persistent PyTorch backend override used for
+                this launched process.
 
         Returns:
             CompletedProcess
@@ -1618,6 +1684,8 @@ class Environment:
         child_env = os.environ.copy()
         child_env["COMFYGIT_ENV_NAME"] = self.name
         child_env["COMFYGIT_CG_RUN_SUPERVISOR"] = "1"
+        if backend_override:
+            child_env[ACTIVE_TORCH_BACKEND_OVERRIDE_ENV] = backend_override
 
         logger.info(f"Starting ComfyUI with: {' '.join(cmd)}")
         return run_command(
@@ -1779,12 +1847,19 @@ class Environment:
         return success_count, failed
 
     @_requires_env_lock
-    def remove_node(self, identifier: str, untrack_only: bool = False) -> NodeRemovalResult:
+    def remove_node(
+        self,
+        identifier: str,
+        untrack_only: bool = False,
+        resolve_with_overlays: bool = False,
+    ) -> NodeRemovalResult:
         """Remove a custom node.
 
         Args:
             identifier: Node identifier or name
             untrack_only: If True, only remove from pyproject.toml without touching filesystem
+            resolve_with_overlays: If True, resolve post-removal sync with all active/extra
+                                   overlays. If False, node sync defaults to pytorch-only overlays.
 
         Returns:
             NodeRemovalResult: Details about the removal
@@ -1792,19 +1867,25 @@ class Environment:
         Raises:
             CDNodeNotFoundError: If node not found
         """
-        return self.node_manager.remove_node(identifier, untrack_only=untrack_only)
+        return self.node_manager.remove_node(
+            identifier,
+            untrack_only=untrack_only,
+            skip_optional_overlays=not resolve_with_overlays,
+        )
 
     @_requires_env_lock
     def remove_nodes_with_progress(
         self,
         node_ids: list[str],
-        callbacks: NodeInstallCallbacks | None = None
+        callbacks: NodeInstallCallbacks | None = None,
+        resolve_with_overlays: bool = False,
     ) -> tuple[int, list[tuple[str, str]]]:
         """Remove multiple nodes with callback support for progress tracking.
 
         Args:
             node_ids: List of node identifiers to remove
             callbacks: Optional callbacks for progress feedback
+            resolve_with_overlays: If True, resolve node removals with all overlays.
 
         Returns:
             Tuple of (success_count, failed_nodes)
@@ -1824,7 +1905,7 @@ class Environment:
                 callbacks.on_node_start(node_id, idx + 1, len(node_ids))
 
             try:
-                self.remove_node(node_id)
+                self.remove_node(node_id, resolve_with_overlays=resolve_with_overlays)
                 success_count += 1
                 if callbacks and callbacks.on_node_complete:
                     callbacks.on_node_complete(node_id, True, None)
@@ -1898,6 +1979,16 @@ class Environment:
         """Copy saved ComfyUI workflow files into tracked `.cec` workflow storage."""
         return self.workflow_manager.copy_all_workflows()
 
+    @_requires_env_lock
+    def capture_workflow(self, workflow_name: str) -> Path:
+        """Capture one saved workflow into the tracked working environment.
+
+        The workflow is copied from ComfyUI's saved workflow directory into
+        `.cec/workflows`, and best-effort dependency metadata is reconciled into
+        the manifest. This does not commit the snapshot or install dependencies.
+        """
+        return self.workflow_manager.capture_workflow(workflow_name)
+
     def get_workflow_status(self) -> DetailedWorkflowStatus:
         """Return analyzed workflow status without exposing the workflow manager."""
         return self.workflow_manager.get_workflow_status()
@@ -2379,7 +2470,13 @@ class Environment:
             config = edit.config
 
             for wf_analysis in workflow_status.analyzed_workflows:
-                if wf_analysis.sync_state in ("new", "modified"):
+                if (
+                    wf_analysis.sync_state in ("new", "modified")
+                    or self.workflow_manager.resolution_changes_manifest(
+                        wf_analysis.resolution,
+                        config=config,
+                    )
+                ):
                     # Apply resolution results to pyproject (in-memory mutations)
                     self.workflow_manager.apply_resolution(wf_analysis.resolution, config=config)
                     edit.mark_changed()
@@ -2486,7 +2583,6 @@ class Environment:
     # Workflow Contract Management
     # =====================================================
 
-    @_requires_env_lock
     def get_workflow_execution_contract(self, workflow_name: str) -> WorkflowExecutionContract | None:
         """Get the saved execution contract for a workflow."""
         return self.pyproject.workflows.get_execution_contract(workflow_name)
@@ -2644,7 +2740,7 @@ class Environment:
                 substituted = self.package_config.apply_substitution(pkg)
                 if substituted != pkg:
                     substitutions[pkg] = substituted
-                    logger.info(f"Package substitution: {pkg} → {substituted}")
+                    logger.info(f"Package substitution: {pkg} -> {substituted}")
                 transformed_packages.append(substituted)
             final_packages = transformed_packages
 

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/core/workspace.py

@@ -40,6 +40,7 @@ from ..repositories.model_repository import ModelRepository
 from ..services.model_downloader import ModelDownloader
 from ..services.registry_data_manager import RegistryDataManager
 from ..utils.environment_cleanup import (
+    DELETED_ENVIRONMENT_PREFIX,
     cleanup_partial_environment,
     is_environment_complete,
     remove_environment_directory,
@@ -524,6 +525,8 @@ class Workspace:
             return environments
 
         for env_dir in self.paths.environments.iterdir():
+            if env_dir.name.startswith(DELETED_ENVIRONMENT_PREFIX):
+                continue
             cec_path = env_dir / ".cec"
             if env_dir.is_dir() and cec_path.exists() and is_environment_complete(cec_path):
                 try:
@@ -612,7 +615,20 @@ class Workspace:
         env_path = self.paths.environments / name
 
         if env_path.exists():
-            raise CDEnvironmentExistsError(f"Environment '{name}' already exists")
+            cec_path = env_path / ".cec"
+            if is_environment_complete(cec_path):
+                raise CDEnvironmentExistsError(f"Environment '{name}' already exists")
+
+            logger.warning(
+                "Removing incomplete environment directory before recreating '%s': %s",
+                name,
+                env_path,
+            )
+            if not cleanup_partial_environment(env_path) or env_path.exists():
+                raise CDEnvironmentExistsError(
+                    f"Environment '{name}' has an incomplete leftover directory at {env_path}. "
+                    "Delete it manually or close processes using it before trying again."
+                )
 
         try:
             # Create the environment

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/integrations/uv_command.py

@@ -36,7 +36,7 @@ class CommandResult:
 class UVCommand:
     """Pure wrapper around UV CLI commands. No business logic or pyproject.toml manipulation."""
 
-    DEFAULT_TIMEOUT = None  # no timeout
+    DEFAULT_TIMEOUT: int | None = None  # no timeout
 
     def __init__(
         self,

{comfygit_core-0.5.0 → comfygit_core-0.6.0}/src/comfygit_core/lifecycle/switch_observer.py

@@ -5,7 +5,7 @@ import json
 import threading
 import time
 from collections.abc import Callable
-from datetime import UTC, datetime
+from datetime import datetime, timezone
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from typing import Any
@@ -17,6 +17,7 @@ SUPERVISOR_INFO_FILE = ".supervisor_control.json"
 SWITCH_STATUS_ROUTE = "/v2/comfygit/switch_status"
 SWITCH_LOGS_ROUTE = "/v2/comfygit/switch_logs"
 SUPERVISOR_HEALTH_ROUTE = "/v2/comfygit/supervisor/health"
+UTC = timezone.utc
 
 
 def metadata_dir_for(workspace_path: Path) -> Path:
@@ -100,11 +101,15 @@ def write_supervisor_advertisement(
     port: int,
     *,
     kind: str = "cg_run_supervisor",
+    public_origin: str | None = None,
 ) -> None:
     metadata_dir = metadata_dir_for(workspace_path)
     metadata_dir.mkdir(parents=True, exist_ok=True)
+    payload: dict[str, Any] = {"host": host, "port": port, "kind": kind}
+    if public_origin:
+        payload["public_origin"] = public_origin.rstrip("/")
     (metadata_dir / SUPERVISOR_INFO_FILE).write_text(
-        json.dumps({"host": host, "port": port, "kind": kind}, indent=2),
+        json.dumps(payload, indent=2),
         encoding="utf-8",
     )
 
@@ -146,6 +151,7 @@ class SwitchObserverServer:
         port: int,
         *,
         kind: str = "cg_run_supervisor",
+        public_origin: str | None = None,
         post_handlers: dict[str, Callable[[], dict[str, Any]]] | None = None,
     ) -> None:
         self.workspace_path = workspace_path
@@ -153,6 +159,7 @@ class SwitchObserverServer:
         self.host = host
         self.port = port
         self.kind = kind
+        self.public_origin = public_origin.rstrip("/") if public_origin else None
         self.post_handlers = post_handlers or {}
         self._server: ThreadingHTTPServer | None = None
         self._thread: threading.Thread | None = None
@@ -170,7 +177,13 @@ class SwitchObserverServer:
             daemon=True,
         )
         self._thread.start()
-        write_supervisor_advertisement(self.workspace_path, self.host, self.port, kind=self.kind)
+        write_supervisor_advertisement(
+            self.workspace_path,
+            self.host,
+            self.port,
+            kind=self.kind,
+            public_origin=self.public_origin,
+        )
         self.append_log(f"Supervisor control server listening on {self.host}:{self.port}")
 
     def stop(self) -> None: