scitex 2.16.2__py3-none-any.whl → 2.17.3__py3-none-any.whl

scitex/_dev/_mcp/handlers.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_mcp/handlers.py
+
+"""MCP handler implementations for developer utilities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+async def list_versions_handler(
+    packages: list[str] | None = None,
+) -> dict[str, Any]:
+    """List versions across the scitex ecosystem.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names to check. If None, checks all ecosystem packages.
+
+    Returns
+    -------
+    dict
+        Version information for each package.
+    """
+    from scitex._dev import list_versions
+
+    return list_versions(packages)
+
+
+async def check_versions_handler(
+    packages: list[str] | None = None,
+) -> dict[str, Any]:
+    """Check version consistency across the scitex ecosystem.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names to check. If None, checks all ecosystem packages.
+
+    Returns
+    -------
+    dict
+        Detailed version check results with summary.
+    """
+    from scitex._dev import check_versions
+
+    return check_versions(packages)
+
+
+async def check_hosts_handler(
+    packages: list[str] | None = None,
+    hosts: list[str] | None = None,
+) -> dict[str, Any]:
+    """Check versions on SSH hosts.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names to check. If None, checks all ecosystem packages.
+    hosts : list[str] | None
+        List of host names to check. If None, checks all enabled hosts.
+
+    Returns
+    -------
+    dict
+        Host name -> package name -> version info mapping.
+    """
+    from scitex._dev import check_all_hosts
+
+    return check_all_hosts(packages=packages, hosts=hosts)
+
+
+async def check_remotes_handler(
+    packages: list[str] | None = None,
+    remotes: list[str] | None = None,
+) -> dict[str, Any]:
+    """Check versions on GitHub remotes.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names to check. If None, checks all ecosystem packages.
+    remotes : list[str] | None
+        List of remote names to check. If None, checks all enabled remotes.
+
+    Returns
+    -------
+    dict
+        Remote name -> package name -> version info mapping.
+    """
+    from scitex._dev import check_all_remotes
+
+    return check_all_remotes(packages=packages, remotes=remotes)
+
+
+async def get_config_handler() -> dict[str, Any]:
+    """Get current developer configuration.
+
+    Returns
+    -------
+    dict
+        Configuration including packages, hosts, remotes, branches.
+    """
+    from scitex._dev import get_config_path, load_config
+
+    config = load_config()
+    return {
+        "config_path": str(get_config_path()),
+        "packages": [
+            {
+                "name": p.name,
+                "local_path": p.local_path,
+                "pypi_name": p.pypi_name,
+                "github_repo": p.github_repo,
+            }
+            for p in config.packages
+        ],
+        "hosts": [
+            {
+                "name": h.name,
+                "hostname": h.hostname,
+                "user": h.user,
+                "role": h.role,
+                "enabled": h.enabled,
+            }
+            for h in config.hosts
+        ],
+        "github_remotes": [
+            {"name": r.name, "org": r.org, "enabled": r.enabled}
+            for r in config.github_remotes
+        ],
+        "branches": config.branches,
+    }
+
+
+async def get_full_versions_handler(
+    packages: list[str] | None = None,
+    include_hosts: bool = False,
+    include_remotes: bool = False,
+) -> dict[str, Any]:
+    """Get comprehensive version data from all sources.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names to check. If None, checks all ecosystem packages.
+    include_hosts : bool
+        Include SSH host version checks.
+    include_remotes : bool
+        Include GitHub remote version checks.
+
+    Returns
+    -------
+    dict
+        Combined version data from local, hosts, and remotes.
+    """
+    from scitex._dev import check_all_hosts, check_all_remotes, list_versions
+
+    result = {
+        "packages": list_versions(packages),
+        "hosts": {},
+        "remotes": {},
+    }
+
+    if include_hosts:
+        try:
+            result["hosts"] = check_all_hosts(packages=packages)
+        except Exception as e:
+            result["hosts"] = {"error": str(e)}
+
+    if include_remotes:
+        try:
+            result["remotes"] = check_all_remotes(packages=packages)
+        except Exception as e:
+            result["remotes"] = {"error": str(e)}
+
+    return result
+
+
+# EOF

scitex/_dev/_ssh.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_ssh.py
+
+"""SSH-based remote version checking for scitex ecosystem."""
+
+from __future__ import annotations
+
+import subprocess
+from typing import Any
+
+from ._config import DevConfig, HostConfig, get_enabled_hosts, load_config
+
+
+def get_remote_version(host: HostConfig, package: str) -> dict[str, Any]:
+    """Get version of a package on a remote host via SSH.
+
+    Parameters
+    ----------
+    host : HostConfig
+        Host configuration.
+    package : str
+        Package name (PyPI name).
+
+    Returns
+    -------
+    dict
+        Version info with keys: installed, status, error (if any).
+    """
+    # Build SSH command
+    ssh_args = ["ssh"]
+
+    if host.ssh_key:
+        ssh_args.extend(["-i", host.ssh_key])
+
+    if host.port != 22:
+        ssh_args.extend(["-p", str(host.port)])
+
+    # Add connection options for non-interactive use
+    ssh_args.extend(
+        [
+            "-o",
+            "BatchMode=yes",
+            "-o",
+            "StrictHostKeyChecking=accept-new",
+            "-o",
+            "ConnectTimeout=5",
+        ]
+    )
+
+    ssh_target = f"{host.user}@{host.hostname}"
+    ssh_args.append(ssh_target)
+
+    # Python command to get version
+    python_cmd = f"""python3 -c "
+try:
+    from importlib.metadata import version
+    print(version('{package}'))
+except Exception as e:
+    print('ERROR:' + str(e))
+"
+"""
+    ssh_args.append(python_cmd)
+
+    try:
+        result = subprocess.run(
+            ssh_args,
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+
+        output = result.stdout.strip()
+
+        if result.returncode != 0:
+            error = result.stderr.strip() or "SSH connection failed"
+            return {
+                "installed": None,
+                "status": "error",
+                "error": error,
+            }
+
+        if output.startswith("ERROR:"):
+            return {
+                "installed": None,
+                "status": "not_installed",
+                "error": output[6:],
+            }
+
+        return {
+            "installed": output,
+            "status": "ok",
+        }
+
+    except subprocess.TimeoutExpired:
+        return {
+            "installed": None,
+            "status": "timeout",
+            "error": "SSH connection timed out",
+        }
+    except Exception as e:
+        return {
+            "installed": None,
+            "status": "error",
+            "error": str(e),
+        }
+
+
+def get_remote_versions(
+    host: HostConfig,
+    packages: list[str],
+) -> dict[str, dict[str, Any]]:
+    """Get versions of multiple packages on a remote host.
+
+    Parameters
+    ----------
+    host : HostConfig
+        Host configuration.
+    packages : list[str]
+        List of package names.
+
+    Returns
+    -------
+    dict
+        Package name -> version info mapping.
+    """
+    # Build SSH command that checks all packages at once
+    ssh_args = ["ssh"]
+
+    if host.ssh_key:
+        ssh_args.extend(["-i", host.ssh_key])
+
+    if host.port != 22:
+        ssh_args.extend(["-p", str(host.port)])
+
+    ssh_args.extend(
+        [
+            "-o",
+            "BatchMode=yes",
+            "-o",
+            "StrictHostKeyChecking=accept-new",
+            "-o",
+            "ConnectTimeout=5",
+        ]
+    )
+
+    ssh_target = f"{host.user}@{host.hostname}"
+    ssh_args.append(ssh_target)
+
+    # Build Python command to check all packages
+    packages_str = ",".join(f"'{p}'" for p in packages)
+    python_cmd = f"""python3 -c "
+import json
+from importlib.metadata import version
+results = {{}}
+for pkg in [{packages_str}]:
+    try:
+        results[pkg] = {{'installed': version(pkg), 'status': 'ok'}}
+    except Exception as e:
+        results[pkg] = {{'installed': None, 'status': 'not_installed', 'error': str(e)}}
+print(json.dumps(results))
+"
+"""
+    ssh_args.append(python_cmd)
+
+    try:
+        result = subprocess.run(
+            ssh_args,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        if result.returncode != 0:
+            error = result.stderr.strip() or "SSH connection failed"
+            return {
+                pkg: {"installed": None, "status": "error", "error": error}
+                for pkg in packages
+            }
+
+        import json
+
+        try:
+            return json.loads(result.stdout.strip())
+        except json.JSONDecodeError:
+            return {
+                pkg: {
+                    "installed": None,
+                    "status": "error",
+                    "error": f"Invalid response: {result.stdout[:100]}",
+                }
+                for pkg in packages
+            }
+
+    except subprocess.TimeoutExpired:
+        return {
+            pkg: {"installed": None, "status": "timeout", "error": "SSH timed out"}
+            for pkg in packages
+        }
+    except Exception as e:
+        return {
+            pkg: {"installed": None, "status": "error", "error": str(e)}
+            for pkg in packages
+        }
+
+
+def check_all_hosts(
+    packages: list[str] | None = None,
+    hosts: list[str] | None = None,
+    config: DevConfig | None = None,
+) -> dict[str, dict[str, dict[str, Any]]]:
+    """Check versions on all enabled hosts.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names. If None, uses ecosystem packages.
+    hosts : list[str] | None
+        List of host names to check. If None, checks all enabled hosts.
+    config : DevConfig | None
+        Configuration to use. If None, loads default config.
+
+    Returns
+    -------
+    dict
+        Mapping: host_name -> package_name -> version_info
+    """
+    if config is None:
+        config = load_config()
+
+    if packages is None:
+        from ._ecosystem import get_all_packages
+
+        packages = get_all_packages()
+
+    # Get pypi names for packages
+    from ._ecosystem import ECOSYSTEM
+
+    pypi_names = []
+    name_map = {}  # pypi_name -> package_name
+    for pkg in packages:
+        if pkg in ECOSYSTEM:
+            pypi_name = ECOSYSTEM[pkg].get("pypi_name", pkg)
+        else:
+            pypi_name = pkg
+        pypi_names.append(pypi_name)
+        name_map[pypi_name] = pkg
+
+    # Get enabled hosts
+    enabled_hosts = get_enabled_hosts(config)
+    if hosts:
+        enabled_hosts = [h for h in enabled_hosts if h.name in hosts]
+
+    results: dict[str, dict[str, dict[str, Any]]] = {}
+
+    for host in enabled_hosts:
+        host_versions = get_remote_versions(host, pypi_names)
+        # Map back to package names
+        results[host.name] = {
+            name_map.get(pypi, pypi): info for pypi, info in host_versions.items()
+        }
+        # Add host metadata
+        results[host.name]["_host"] = {
+            "hostname": host.hostname,
+            "role": host.role,
+            "user": host.user,
+        }
+
+    return results
+
+
+def test_host_connection(host: HostConfig) -> dict[str, Any]:
+    """Test SSH connection to a host.
+
+    Parameters
+    ----------
+    host : HostConfig
+        Host to test.
+
+    Returns
+    -------
+    dict
+        Connection status with keys: connected, error, python_version.
+    """
+    ssh_args = ["ssh"]
+
+    if host.ssh_key:
+        ssh_args.extend(["-i", host.ssh_key])
+
+    if host.port != 22:
+        ssh_args.extend(["-p", str(host.port)])
+
+    ssh_args.extend(
+        [
+            "-o",
+            "BatchMode=yes",
+            "-o",
+            "StrictHostKeyChecking=accept-new",
+            "-o",
+            "ConnectTimeout=5",
+        ]
+    )
+
+    ssh_target = f"{host.user}@{host.hostname}"
+    ssh_args.append(ssh_target)
+    ssh_args.append("python3 --version")
+
+    try:
+        result = subprocess.run(
+            ssh_args,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode == 0:
+            return {
+                "connected": True,
+                "python_version": result.stdout.strip(),
+            }
+        return {
+            "connected": False,
+            "error": result.stderr.strip() or "Connection failed",
+        }
+
+    except subprocess.TimeoutExpired:
+        return {"connected": False, "error": "Connection timed out"}
+    except Exception as e:
+        return {"connected": False, "error": str(e)}
+
+
+# EOF