comfy-env 0.0.18__tar.gz → 0.0.21__tar.gz

comfy_env-0.0.21/.github/workflows/publish.yml

@@ -0,0 +1,67 @@
+name: Bump Version & Publish
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  bump-and-publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Get current version
+        id: get_version
+        run: |
+          current=$(grep '^version = ' pyproject.toml | sed 's/version = "\(.*\)"/\1/' | tr -d '\r')
+          echo "current=$current" >> $GITHUB_OUTPUT
+
+      - name: Bump patch version
+        id: bump_version
+        run: |
+          current="${{ steps.get_version.outputs.current }}"
+          IFS='.' read -r major minor patch <<< "$current"
+          new_patch=$((patch + 1))
+          new_version="${major}.${minor}.${new_patch}"
+          sed -i "s/^version = \".*\"/version = \"${new_version}\"/" pyproject.toml
+          echo "new_version=$new_version" >> $GITHUB_OUTPUT
+          echo "Bumped version: $current -> $new_version"
+
+      - name: Commit version bump
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add pyproject.toml
+          git commit -m "Bump version to ${{ steps.bump_version.outputs.new_version }} [skip ci]"
+          git tag "v${{ steps.bump_version.outputs.new_version }}"
+          git push origin main --tags
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: v${{ steps.bump_version.outputs.new_version }}
+          name: v${{ steps.bump_version.outputs.new_version }}
+          generate_release_notes: true
+          files: dist/*
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{comfy_env-0.0.18 → comfy_env-0.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.18
+Version: 0.0.21
 Summary: Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation
 Project-URL: Homepage, https://github.com/PozzettiAndrea/comfy-env
 Project-URL: Repository, https://github.com/PozzettiAndrea/comfy-env
@@ -126,7 +126,7 @@ comfy-env resolve nvdiffrast==0.4.0
 comfy-env doctor
 ```
 
-## Configuration
+## Configurations
 
 ### comfy-env.toml
 

{comfy_env-0.0.18 → comfy_env-0.0.21}/README.md

@@ -98,7 +98,7 @@ comfy-env resolve nvdiffrast==0.4.0
 comfy-env doctor
 ```
 
-## Configuration
+## Configurations
 
 ### comfy-env.toml
 

{comfy_env-0.0.18 → comfy_env-0.0.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.0.18"
+version = "0.0.21"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}

{comfy_env-0.0.18 → comfy_env-0.0.21}/src/comfy_env/decorator.py

@@ -113,6 +113,31 @@ def _clone_tensor_if_needed(obj: Any, smart_clone: bool = True) -> Any:
     return obj
 
 
+def _find_node_package_dir(source_file: Path) -> Path:
+    """
+    Find the node package root directory by searching for comfy-env.toml.
+
+    Walks up from the source file's directory until it finds a config file,
+    or falls back to heuristics if not found.
+    """
+    from .env.config_file import CONFIG_FILE_NAMES
+
+    current = source_file.parent
+
+    # Walk up the directory tree looking for config file
+    while current != current.parent:  # Stop at filesystem root
+        for config_name in CONFIG_FILE_NAMES:
+            if (current / config_name).exists():
+                return current
+        current = current.parent
+
+    # Fallback: use old heuristic if no config found
+    node_dir = source_file.parent
+    if node_dir.name == "nodes":
+        return node_dir.parent
+    return node_dir
+
+
 # ---------------------------------------------------------------------------
 # Worker Management
 # ---------------------------------------------------------------------------
@@ -262,10 +287,7 @@ def isolated(
         # Get source file info for sys.path setup
         source_file = Path(inspect.getfile(cls))
         node_dir = source_file.parent
-        if node_dir.name == "nodes":
-            node_package_dir = node_dir.parent
-        else:
-            node_package_dir = node_dir
+        node_package_dir = _find_node_package_dir(source_file)
 
         # Build sys.path for worker
         sys_path_additions = [str(node_dir)]
@@ -367,13 +389,10 @@ def isolated(
                     call_kwargs = {k: _clone_tensor_if_needed(v) for k, v in call_kwargs.items()}
 
                 # Get module name for import in worker
+                # Note: ComfyUI uses full filesystem paths as module names for custom nodes.
+                # The worker's _execute_method_call handles this by using file-based imports.
                 module_name = cls.__module__
 
-                # Handle ComfyUI's dynamic import which can set __module__ to a path
-                if module_name.startswith('/') or module_name.startswith('\\'):
-                    # Module name is a filesystem path - use the source file stem instead
-                    module_name = source_file.stem
-
                 # Call worker using appropriate method
                 if worker_config.python is None:
                     # TorchMPWorker - use call_method protocol (avoids pickle issues)

{comfy_env-0.0.18 → comfy_env-0.0.21}/src/comfy_env/env/config.py

@@ -5,6 +5,18 @@ from pathlib import Path
 from typing import Dict, List, Optional
 
 
+@dataclass
+class SystemConfig:
+    """Configuration for system-level packages.
+
+    These are OS-level packages (apt, brew, etc.) that need to be installed
+    before Python packages can work properly.
+    """
+    linux: List[str] = field(default_factory=list)    # apt packages
+    darwin: List[str] = field(default_factory=list)   # brew packages (future)
+    windows: List[str] = field(default_factory=list)  # winget packages (future)
+
+
 @dataclass
 class LocalConfig:
     """Configuration for local (host environment) installs.
@@ -37,6 +49,7 @@ class EnvManagerConfig:
     Full configuration parsed from comfy-env.toml.
 
     Supports the v2 schema:
+        [system]            - System-level packages (apt, brew, etc.)
         [local.cuda]        - CUDA packages for host environment
         [local.packages]    - Regular packages for host environment
         [envname]           - Isolated env definition
@@ -45,11 +58,17 @@ class EnvManagerConfig:
         [node_reqs]         - Node dependencies
         [tools]             - External tools (e.g., blender = "4.2")
     """
+    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)
 
+    @property
+    def has_system(self) -> bool:
+        """Check if there are system packages to install."""
+        return bool(self.system.linux or self.system.darwin or self.system.windows)
+
     @property
     def has_local(self) -> bool:
         """Check if there are local packages to install."""

{comfy_env-0.0.18 → comfy_env-0.0.21}/src/comfy_env/env/config_file.py

@@ -63,7 +63,7 @@ else:
     except ImportError:
         tomllib = None  # type: ignore
 
-from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, ToolConfig
+from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, SystemConfig, ToolConfig
 from .cuda_gpu_detection import detect_cuda_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"}
+RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "tools", "system"}
 
 
 def load_config(
@@ -426,12 +426,14 @@ def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig
         return _convert_simple_to_full(data, base_dir)
 
     # Parse full schema
+    system = _parse_system_section(data.get("system", {}))
     local = _parse_local_section(data.get("local", {}))
     envs = _parse_env_sections(data, base_dir)
     node_reqs = _parse_node_reqs(data.get("node_reqs", {}))
     tools = _parse_tools_section(data.get("tools", {}))
 
     return EnvManagerConfig(
+        system=system,
         local=local,
         envs=envs,
         node_reqs=node_reqs,
@@ -613,6 +615,34 @@ def _parse_tools_section(tools_data: Dict[str, Any]) -> Dict[str, ToolConfig]:
     return tools
 
 
+def _parse_system_section(system_data: Dict[str, Any]) -> SystemConfig:
+    """Parse [system] section.
+
+    Supports:
+        [system]
+        linux = ["libgl1", "libopengl0"]
+        darwin = ["mesa"]  # future
+        windows = ["vcredist"]  # future
+    """
+    linux = system_data.get("linux", [])
+    darwin = system_data.get("darwin", [])
+    windows = system_data.get("windows", [])
+
+    # Ensure all are lists
+    if not isinstance(linux, list):
+        linux = [linux] if linux else []
+    if not isinstance(darwin, list):
+        darwin = [darwin] if darwin else []
+    if not isinstance(windows, list):
+        windows = [windows] if windows else []
+
+    return SystemConfig(
+        linux=linux,
+        darwin=darwin,
+        windows=windows,
+    )
+
+
 def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
     """Convert simple config format to full EnvManagerConfig.
 
@@ -622,8 +652,9 @@ 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 section (shared between simple and full format)
+    # Parse tools and system sections (shared between simple and full format)
     tools = _parse_tools_section(data.get("tools", {}))
+    system = _parse_system_section(data.get("system", {}))
 
     # Check if this has explicit env settings (isolated venv) vs just CUDA packages (local install)
     env_section = data.get("env", {})
@@ -632,6 +663,7 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
     if has_explicit_env:
         # Isolated venv config
         return EnvManagerConfig(
+            system=system,
             local=LocalConfig(),
             envs={simple_env.name: simple_env},
             node_reqs=[],
@@ -648,6 +680,7 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
                 cuda_packages[req] = ""
 
         return EnvManagerConfig(
+            system=system,
             local=LocalConfig(
                 cuda_packages=cuda_packages,
                 requirements=simple_env.requirements,

{comfy_env-0.0.18 → comfy_env-0.0.21}/src/comfy_env/install.py

@@ -24,13 +24,111 @@ import sys
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
-from .env.config import IsolatedEnv, ToolConfig
+from .env.config import IsolatedEnv, SystemConfig
 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_system_packages(
+    system_config: SystemConfig,
+    log: Callable[[str], None],
+    dry_run: bool = False,
+) -> bool:
+    """
+    Install system-level packages (apt, brew, etc.).
+
+    Args:
+        system_config: SystemConfig with package lists per OS.
+        log: Logging callback.
+        dry_run: If True, show what would be installed without installing.
+
+    Returns:
+        True if installation succeeded or no packages needed.
+    """
+    platform = sys.platform
+
+    if platform.startswith("linux"):
+        packages = system_config.linux
+        if not packages:
+            return True
+
+        log(f"Installing {len(packages)} system package(s) via apt...")
+
+        if dry_run:
+            log(f"  Would install: {', '.join(packages)}")
+            return True
+
+        # Check if apt-get is available
+        if not shutil.which("apt-get"):
+            log("  Warning: apt-get not found. Cannot install system packages.")
+            log(f"  Please install manually: {', '.join(packages)}")
+            return True  # Don't fail - just warn
+
+        # Check if we can use sudo
+        sudo_available = shutil.which("sudo") is not None
+
+        try:
+            if sudo_available:
+                # Try with sudo
+                log("  Running apt-get update...")
+                update_result = subprocess.run(
+                    ["sudo", "apt-get", "update"],
+                    capture_output=True,
+                    text=True,
+                )
+                if update_result.returncode != 0:
+                    log(f"  Warning: apt-get update failed: {update_result.stderr.strip()}")
+                    # Continue anyway - packages might already be cached
+
+                log(f"  Installing: {', '.join(packages)}")
+                install_cmd = ["sudo", "apt-get", "install", "-y"] + packages
+                install_result = subprocess.run(
+                    install_cmd,
+                    capture_output=True,
+                    text=True,
+                )
+
+                if install_result.returncode != 0:
+                    log(f"  Warning: apt-get install failed: {install_result.stderr.strip()}")
+                    log(f"  Please install manually: sudo apt-get install {' '.join(packages)}")
+                    return True  # Don't fail - just warn
+                else:
+                    log("  System packages installed successfully.")
+                    return True
+            else:
+                log("  Warning: sudo not available. Cannot install system packages automatically.")
+                log(f"  Please install manually: sudo apt-get install {' '.join(packages)}")
+                return True  # Don't fail - just warn
+
+        except Exception as e:
+            log(f"  Warning: Failed to install system packages: {e}")
+            log(f"  Please install manually: sudo apt-get install {' '.join(packages)}")
+            return True  # Don't fail - just warn
+
+    elif platform == "darwin":
+        packages = system_config.darwin
+        if not packages:
+            return True
+
+        log(f"System packages for macOS: {', '.join(packages)}")
+        log("  Note: macOS system package installation not yet implemented.")
+        log(f"  Please install manually with Homebrew: brew install {' '.join(packages)}")
+        return True
+
+    elif platform == "win32":
+        packages = system_config.windows
+        if not packages:
+            return True
+
+        log(f"System packages for Windows: {', '.join(packages)}")
+        log("  Note: Windows system package installation not yet implemented.")
+        log(f"  Please install manually.")
+        return True
+
+    return True
 
 
 def install(
@@ -86,16 +184,10 @@ def install(
             "Create comfy-env.toml or specify path explicitly."
         )
 
-    # 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)
+    # Install system packages first (apt, brew, etc.)
+    # These need to be installed before Python packages that depend on them
+    if full_config.has_system:
+        _install_system_packages(full_config.system, log, dry_run)
 
     # Get environment config
     env_config = full_config.default_env

{comfy_env-0.0.18 → comfy_env-0.0.21}/src/comfy_env/workers/torch_mp.py

@@ -106,6 +106,190 @@ def _worker_loop(queue_in, queue_out, sys_path_additions=None):
             break
 
 
+class PathBasedModuleFinder:
+    """
+    Meta path finder that handles ComfyUI's path-based module names.
+
+    ComfyUI uses full filesystem paths as module names for custom nodes.
+    This finder intercepts imports of such modules and loads them from disk.
+    """
+
+    def find_spec(self, fullname, path, target=None):
+        import importlib.util
+        import os
+
+        # Only handle path-based module names (starting with /)
+        if not fullname.startswith('/'):
+            return None
+
+        # Parse the module name to find base path and submodule parts
+        parts = fullname.split('.')
+        base_path = parts[0]
+        submodule_parts = parts[1:] if len(parts) > 1 else []
+
+        # Walk through parts to find where path ends and module begins
+        for i, part in enumerate(submodule_parts):
+            test_path = os.path.join(base_path, part)
+            if os.path.exists(test_path):
+                base_path = test_path
+            else:
+                # Remaining parts are module names
+                submodule_parts = submodule_parts[i:]
+                break
+        else:
+            # All parts were path components
+            submodule_parts = []
+
+        # Determine the file to load
+        if submodule_parts:
+            # We're importing a submodule
+            current_path = base_path
+            for part in submodule_parts[:-1]:
+                current_path = os.path.join(current_path, part)
+
+            submod = submodule_parts[-1]
+            submod_file = os.path.join(current_path, submod + '.py')
+            submod_pkg = os.path.join(current_path, submod, '__init__.py')
+
+            if os.path.exists(submod_file):
+                return importlib.util.spec_from_file_location(fullname, submod_file)
+            elif os.path.exists(submod_pkg):
+                return importlib.util.spec_from_file_location(
+                    fullname, submod_pkg,
+                    submodule_search_locations=[os.path.join(current_path, submod)]
+                )
+        else:
+            # Top-level path-based module
+            if os.path.isdir(base_path):
+                init_path = os.path.join(base_path, "__init__.py")
+                if os.path.exists(init_path):
+                    return importlib.util.spec_from_file_location(
+                        fullname, init_path,
+                        submodule_search_locations=[base_path]
+                    )
+            elif os.path.isfile(base_path):
+                return importlib.util.spec_from_file_location(fullname, base_path)
+
+        return None
+
+
+# Global flag to track if we've installed the finder
+_path_finder_installed = False
+
+
+def _ensure_path_finder_installed():
+    """Install the PathBasedModuleFinder if not already installed."""
+    import sys
+    global _path_finder_installed
+    if not _path_finder_installed:
+        sys.meta_path.insert(0, PathBasedModuleFinder())
+        _path_finder_installed = True
+        logger.debug("[comfy_env] Installed PathBasedModuleFinder for path-based module names")
+
+
+def _load_path_based_module(module_name: str):
+    """
+    Load a module that has a filesystem path as its name.
+
+    ComfyUI uses full filesystem paths as module names for custom nodes.
+    This function handles that case by using file-based imports.
+    """
+    import importlib.util
+    import os
+    import sys
+
+    # Check if it's already in sys.modules
+    if module_name in sys.modules:
+        return sys.modules[module_name]
+
+    # Check if module_name contains submodule parts (e.g., "/path/to/pkg.submod.subsubmod")
+    # In this case, we need to load the parent packages first
+    if '.' in module_name:
+        parts = module_name.split('.')
+        # Find where the path ends and module parts begin
+        # The path part won't exist as a directory when combined with module parts
+        base_path = parts[0]
+        submodule_parts = []
+
+        for i, part in enumerate(parts[1:], 1):
+            test_path = os.path.join(base_path, part)
+            if os.path.exists(test_path):
+                base_path = test_path
+            else:
+                # This and remaining parts are module names, not path components
+                submodule_parts = parts[i:]
+                break
+
+        if submodule_parts:
+            # Load parent package first
+            parent_module = _load_path_based_module(base_path)
+
+            # Now load submodules
+            current_module = parent_module
+            current_name = base_path
+            for submod in submodule_parts:
+                current_name = f"{current_name}.{submod}"
+                if current_name in sys.modules:
+                    current_module = sys.modules[current_name]
+                else:
+                    # Try to import as attribute or load from file
+                    if hasattr(current_module, submod):
+                        current_module = getattr(current_module, submod)
+                    else:
+                        # Try to load the submodule file
+                        if hasattr(current_module, '__path__'):
+                            for parent_path in current_module.__path__:
+                                submod_file = os.path.join(parent_path, submod + '.py')
+                                submod_pkg = os.path.join(parent_path, submod, '__init__.py')
+                                if os.path.exists(submod_file):
+                                    spec = importlib.util.spec_from_file_location(current_name, submod_file)
+                                    current_module = importlib.util.module_from_spec(spec)
+                                    current_module.__package__ = f"{base_path}.{'.'.join(submodule_parts[:-1])}" if len(submodule_parts) > 1 else base_path
+                                    sys.modules[current_name] = current_module
+                                    spec.loader.exec_module(current_module)
+                                    break
+                                elif os.path.exists(submod_pkg):
+                                    spec = importlib.util.spec_from_file_location(current_name, submod_pkg,
+                                        submodule_search_locations=[os.path.dirname(submod_pkg)])
+                                    current_module = importlib.util.module_from_spec(spec)
+                                    sys.modules[current_name] = current_module
+                                    spec.loader.exec_module(current_module)
+                                    break
+                        else:
+                            raise ModuleNotFoundError(f"Cannot find submodule {submod} in {current_name}")
+            return current_module
+
+    # Simple path-based module (no submodule parts)
+    if os.path.isdir(module_name):
+        init_path = os.path.join(module_name, "__init__.py")
+        submodule_search_locations = [module_name]
+    else:
+        init_path = module_name
+        submodule_search_locations = None
+
+    if not os.path.exists(init_path):
+        raise ModuleNotFoundError(f"Cannot find module at path: {module_name}")
+
+    spec = importlib.util.spec_from_file_location(
+        module_name,
+        init_path,
+        submodule_search_locations=submodule_search_locations
+    )
+    module = importlib.util.module_from_spec(spec)
+
+    # Set up package attributes for relative imports
+    if os.path.isdir(module_name):
+        module.__path__ = [module_name]
+        module.__package__ = module_name
+    else:
+        module.__package__ = module_name.rsplit('.', 1)[0] if '.' in module_name else ''
+
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+
+    return module
+
+
 def _execute_method_call(module_name: str, class_name: str, method_name: str,
                          self_state: dict, kwargs: dict) -> Any:
     """
@@ -114,9 +298,28 @@ def _execute_method_call(module_name: str, class_name: str, method_name: str,
     This function imports the class fresh and calls the original (un-decorated) method.
     """
     import importlib
+    import os
+    import sys
 
     # Import the module
-    module = importlib.import_module(module_name)
+    logger.debug(f"Attempting to import module_name={module_name}")
+
+    # Check if module_name is a filesystem path (ComfyUI uses paths as module names)
+    # This happens because ComfyUI's load_custom_node uses the full path as sys_module_name
+    if module_name.startswith('/') or (os.sep in module_name and not module_name.startswith('.')):
+        # Check if the base path exists to confirm it's a path-based module
+        base_path = module_name.split('.')[0] if '.' in module_name else module_name
+        if os.path.exists(base_path):
+            logger.debug(f"Detected path-based module name, using file-based import")
+            # Install the meta path finder to handle relative imports within the package
+            _ensure_path_finder_installed()
+            module = _load_path_based_module(module_name)
+        else:
+            # Doesn't look like a valid path, try standard import
+            module = importlib.import_module(module_name)
+    else:
+        # Standard module name - use importlib.import_module
+        module = importlib.import_module(module_name)
     cls = getattr(module, class_name)
 
     # Create instance with proper __slots__ handling

comfy_env-0.0.18/.github/workflows/publish.yml

@@ -1,28 +0,0 @@
-name: Publish to PyPI
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    environment: pypi
-    permissions:
-      id-token: write  # Required for trusted publishing
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install build tools
-        run: pip install build
-
-      - name: Build package
-        run: python -m build
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1