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

scitex/_dev/__init__.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/__init__.py
+
+"""
+SciTeX Developer Utilities (Internal Module).
+
+This module provides internal developer tools for managing the scitex ecosystem.
+
+Functions
+---------
+list_versions : List versions across ecosystem packages
+check_versions : Check version consistency
+load_config : Load developer configuration
+check_all_hosts : Check versions on SSH hosts
+check_all_remotes : Check versions on GitHub remotes
+run_dashboard : Run the Flask version dashboard
+
+Examples
+--------
+>>> from scitex._dev import list_versions
+>>> versions = list_versions()
+>>> versions["scitex"]["local"]["pyproject_toml"]
+'2.17.1'
+
+>>> from scitex._dev import check_versions
+>>> result = check_versions(["scitex", "figrecipe"])
+>>> result["summary"]["ok"]
+2
+
+>>> from scitex._dev import load_config
+>>> config = load_config()
+>>> len(config.packages)
+8
+"""
+
+from ._config import (
+    DevConfig,
+    GitHubRemote,
+    HostConfig,
+    PackageConfig,
+    PyPIAccount,
+    create_default_config,
+    get_config_path,
+    get_enabled_hosts,
+    get_enabled_remotes,
+    load_config,
+)
+from ._ecosystem import ECOSYSTEM, get_all_packages, get_local_path
+from ._github import (
+    check_all_remotes,
+    compare_with_local,
+    get_github_latest_tag,
+    get_github_release,
+    get_github_tags,
+)
+from ._ssh import (
+    check_all_hosts,
+    get_remote_version,
+    get_remote_versions,
+    test_host_connection,
+)
+from ._versions import check_versions, list_versions
+
+__all__ = [
+    # Versions
+    "list_versions",
+    "check_versions",
+    # Ecosystem
+    "ECOSYSTEM",
+    "get_all_packages",
+    "get_local_path",
+    # Config
+    "load_config",
+    "get_config_path",
+    "create_default_config",
+    "get_enabled_hosts",
+    "get_enabled_remotes",
+    "DevConfig",
+    "HostConfig",
+    "GitHubRemote",
+    "PackageConfig",
+    "PyPIAccount",
+    # SSH
+    "check_all_hosts",
+    "get_remote_version",
+    "get_remote_versions",
+    "test_host_connection",
+    # GitHub
+    "check_all_remotes",
+    "compare_with_local",
+    "get_github_tags",
+    "get_github_latest_tag",
+    "get_github_release",
+]
+
+
+def run_dashboard(
+    host: str = "127.0.0.1",
+    port: int = 5000,
+    debug: bool = False,
+    open_browser: bool = True,
+) -> None:
+    """Run the Flask version dashboard.
+
+    Parameters
+    ----------
+    host : str
+        Host to bind to.
+    port : int
+        Port to listen on.
+    debug : bool
+        Enable debug mode.
+    open_browser : bool
+        Open browser automatically.
+    """
+    from ._dashboard import run_dashboard as _run
+
+    _run(host=host, port=port, debug=debug, open_browser=open_browser)
+
+
+# EOF

scitex/_dev/_config.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_config.py
+
+"""Configuration management for scitex developer utilities."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class HostConfig:
+    """SSH host configuration."""
+
+    name: str
+    hostname: str
+    user: str
+    role: str = "dev"  # dev, staging, prod
+    enabled: bool = True
+    ssh_key: str | None = None
+    port: int = 22
+
+
+@dataclass
+class GitHubRemote:
+    """GitHub remote configuration."""
+
+    name: str
+    org: str
+    enabled: bool = True
+
+
+@dataclass
+class PyPIAccount:
+    """PyPI account configuration."""
+
+    name: str
+    enabled: bool = True
+
+
+@dataclass
+class PackageConfig:
+    """Package configuration."""
+
+    name: str
+    local_path: str
+    pypi_name: str
+    github_repo: str | None = None
+    import_name: str | None = None
+
+
+@dataclass
+class DevConfig:
+    """Full developer configuration."""
+
+    packages: list[PackageConfig] = field(default_factory=list)
+    hosts: list[HostConfig] = field(default_factory=list)
+    github_remotes: list[GitHubRemote] = field(default_factory=list)
+    pypi_accounts: list[PyPIAccount] = field(default_factory=list)
+    branches: list[str] = field(default_factory=lambda: ["main", "develop"])
+
+
+def _get_default_config_path() -> Path:
+    """Get default config file path."""
+    return Path.home() / ".scitex" / "dev_config.yaml"
+
+
+def _load_yaml(path: Path) -> dict[str, Any]:
+    """Load YAML file."""
+    if not path.exists():
+        return {}
+
+    try:
+        import yaml
+
+        with open(path) as f:
+            return yaml.safe_load(f) or {}
+    except ImportError:
+        # Fallback: basic YAML parsing for simple configs
+        content = path.read_text()
+        # Very basic parsing - handles simple key: value pairs
+        result: dict[str, Any] = {}
+        current_key = None
+        current_list: list[Any] = []
+
+        for line in content.split("\n"):
+            line = line.rstrip()
+            if not line or line.startswith("#"):
+                continue
+            if line.startswith("  - "):
+                # List item
+                current_list.append(line[4:].strip())
+            elif line.startswith("  "):
+                # Nested dict item - skip for basic parsing
+                continue
+            elif ":" in line:
+                if current_key and current_list:
+                    result[current_key] = current_list
+                    current_list = []
+                key, val = line.split(":", 1)
+                current_key = key.strip()
+                val = val.strip()
+                if val:
+                    result[current_key] = val
+        if current_key and current_list:
+            result[current_key] = current_list
+        return result
+    except Exception:
+        return {}
+
+
+def _parse_host_config(data: dict[str, Any]) -> HostConfig:
+    """Parse host config from dict."""
+    return HostConfig(
+        name=data.get("name", "unknown"),
+        hostname=data.get("hostname", "localhost"),
+        user=data.get("user", os.getenv("USER", "user")),
+        role=data.get("role", "dev"),
+        enabled=data.get("enabled", True),
+        ssh_key=data.get("ssh_key"),
+        port=data.get("port", 22),
+    )
+
+
+def _parse_github_remote(data: dict[str, Any]) -> GitHubRemote:
+    """Parse GitHub remote from dict."""
+    return GitHubRemote(
+        name=data.get("name", "unknown"),
+        org=data.get("org", ""),
+        enabled=data.get("enabled", True),
+    )
+
+
+def _parse_pypi_account(data: dict[str, Any]) -> PyPIAccount:
+    """Parse PyPI account from dict."""
+    return PyPIAccount(
+        name=data.get("name", ""),
+        enabled=data.get("enabled", True),
+    )
+
+
+def _parse_package_config(data: dict[str, Any]) -> PackageConfig:
+    """Parse package config from dict."""
+    return PackageConfig(
+        name=data.get("name", "unknown"),
+        local_path=data.get("local_path", ""),
+        pypi_name=data.get("pypi_name", data.get("name", "")),
+        github_repo=data.get("github_repo"),
+        import_name=data.get("import_name"),
+    )
+
+
+def load_config(config_path: str | Path | None = None) -> DevConfig:
+    """Load config from YAML with environment variable overrides.
+
+    Parameters
+    ----------
+    config_path : str | Path | None
+        Path to config file. If None, uses SCITEX_DEV_CONFIG env var
+        or ~/.scitex/dev_config.yaml
+
+    Returns
+    -------
+    DevConfig
+        Loaded configuration.
+    """
+    # Determine config path
+    if config_path is None:
+        config_path = os.getenv("SCITEX_DEV_CONFIG")
+    if config_path is None:
+        config_path = _get_default_config_path()
+    else:
+        config_path = Path(config_path).expanduser()
+
+    # Load YAML
+    data = _load_yaml(config_path)
+
+    # Parse packages
+    packages = []
+    if "packages" in data and isinstance(data["packages"], list):
+        for pkg_data in data["packages"]:
+            if isinstance(pkg_data, dict):
+                packages.append(_parse_package_config(pkg_data))
+
+    # If no packages in config, use ecosystem defaults
+    if not packages:
+        from ._ecosystem import ECOSYSTEM
+
+        for name, info in ECOSYSTEM.items():
+            packages.append(
+                PackageConfig(
+                    name=name,
+                    local_path=info.get("local_path", ""),
+                    pypi_name=info.get("pypi_name", name),
+                    github_repo=info.get("github_repo"),
+                    import_name=info.get("import_name"),
+                )
+            )
+
+    # Parse hosts
+    hosts = []
+    if "hosts" in data and isinstance(data["hosts"], list):
+        for host_data in data["hosts"]:
+            if isinstance(host_data, dict):
+                hosts.append(_parse_host_config(host_data))
+
+    # Override from env
+    env_hosts = os.getenv("SCITEX_DEV_HOSTS", "").strip()
+    if env_hosts:
+        enabled_names = set(env_hosts.split(","))
+        for host in hosts:
+            host.enabled = host.name in enabled_names
+
+    # Parse GitHub remotes
+    github_remotes = []
+    if "github_remotes" in data and isinstance(data["github_remotes"], list):
+        for remote_data in data["github_remotes"]:
+            if isinstance(remote_data, dict):
+                github_remotes.append(_parse_github_remote(remote_data))
+
+    # Default GitHub remote from ecosystem
+    if not github_remotes:
+        github_remotes.append(GitHubRemote(name="ywatanabe1989", org="ywatanabe1989"))
+
+    # Override from env
+    env_remotes = os.getenv("SCITEX_DEV_GITHUB_REMOTES", "").strip()
+    if env_remotes:
+        enabled_names = set(env_remotes.split(","))
+        for remote in github_remotes:
+            remote.enabled = remote.name in enabled_names
+
+    # Parse PyPI accounts
+    pypi_accounts = []
+    if "pypi_accounts" in data and isinstance(data["pypi_accounts"], list):
+        for acct_data in data["pypi_accounts"]:
+            if isinstance(acct_data, dict):
+                pypi_accounts.append(_parse_pypi_account(acct_data))
+
+    if not pypi_accounts:
+        pypi_accounts.append(PyPIAccount(name="ywatanabe1989"))
+
+    # Parse branches
+    branches = data.get("branches", ["main", "develop"])
+    if not isinstance(branches, list):
+        branches = ["main", "develop"]
+
+    return DevConfig(
+        packages=packages,
+        hosts=hosts,
+        github_remotes=github_remotes,
+        pypi_accounts=pypi_accounts,
+        branches=branches,
+    )
+
+
+def get_enabled_hosts(config: DevConfig | None = None) -> list[HostConfig]:
+    """Get list of enabled hosts.
+
+    Parameters
+    ----------
+    config : DevConfig | None
+        Configuration to use. If None, loads default config.
+
+    Returns
+    -------
+    list[HostConfig]
+        List of enabled hosts.
+    """
+    if config is None:
+        config = load_config()
+    return [h for h in config.hosts if h.enabled]
+
+
+def get_enabled_remotes(config: DevConfig | None = None) -> list[GitHubRemote]:
+    """Get list of enabled GitHub remotes.
+
+    Parameters
+    ----------
+    config : DevConfig | None
+        Configuration to use. If None, loads default config.
+
+    Returns
+    -------
+    list[GitHubRemote]
+        List of enabled remotes.
+    """
+    if config is None:
+        config = load_config()
+    return [r for r in config.github_remotes if r.enabled]
+
+
+def get_config_path() -> Path:
+    """Get the config file path (may not exist)."""
+    path = os.getenv("SCITEX_DEV_CONFIG")
+    if path:
+        return Path(path).expanduser()
+    return _get_default_config_path()
+
+
+def create_default_config() -> Path:
+    """Create default config file if it doesn't exist.
+
+    Returns
+    -------
+    Path
+        Path to the config file.
+    """
+    config_path = _get_default_config_path()
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if config_path.exists():
+        return config_path
+
+    default_config = """\
+# SciTeX Developer Configuration
+# Timestamp: 2026-02-02
+
+# Ecosystem packages to track
+packages:
+  - name: scitex
+    local_path: ~/proj/scitex-python
+    pypi_name: scitex
+    github_repo: ywatanabe1989/scitex-python
+    import_name: scitex
+  - name: figrecipe
+    local_path: ~/proj/figrecipe
+    pypi_name: figrecipe
+    github_repo: ywatanabe1989/figrecipe
+    import_name: figrecipe
+  - name: scitex-cloud
+    local_path: ~/proj/scitex-cloud
+    pypi_name: scitex-cloud
+    github_repo: ywatanabe1989/scitex-cloud
+    import_name: scitex_cloud
+  - name: scitex-writer
+    local_path: ~/proj/scitex-writer
+    pypi_name: scitex-writer
+    github_repo: ywatanabe1989/scitex-writer
+    import_name: scitex_writer
+  - name: crossref-local
+    local_path: ~/proj/crossref-local
+    pypi_name: crossref-local
+    github_repo: ywatanabe1989/crossref-local
+    import_name: crossref_local
+
+# Hosts to check via SSH
+hosts:
+  - name: ywata-note-win
+    hostname: localhost
+    user: ywatanabe
+    role: dev
+    enabled: true
+  - name: nas
+    hostname: nas.local
+    user: ywatanabe
+    role: staging
+    enabled: true
+  - name: scitex-cloud
+    hostname: scitex.ai
+    user: deploy
+    role: prod
+    enabled: false
+
+# GitHub remotes to check
+github_remotes:
+  - name: ywatanabe1989
+    org: ywatanabe1989
+    enabled: true
+  - name: scitex-ai
+    org: scitex-ai
+    enabled: false
+
+# PyPI accounts
+pypi_accounts:
+  - name: ywatanabe1989
+    enabled: true
+
+# Branches to track
+branches:
+  - main
+  - develop
+"""
+    config_path.write_text(default_config)
+    return config_path
+
+
+# EOF

scitex/_dev/_dashboard/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_dashboard/__init__.py
+
+"""Flask dashboard for scitex version management."""
+
+from ._app import create_app, run_dashboard
+
+__all__ = ["create_app", "run_dashboard"]
+
+# EOF

scitex/_dev/_dashboard/_app.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_dashboard/_app.py
+
+"""Flask application factory for the dashboard."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from flask import Flask
+
+
+def create_app() -> Flask:
+    """Create and configure the Flask application.
+
+    Returns
+    -------
+    Flask
+        Configured Flask application.
+    """
+    try:
+        from flask import Flask
+    except ImportError as e:
+        raise ImportError(
+            "Flask is required for the dashboard. Install with: pip install flask"
+        ) from e
+
+    from pathlib import Path
+
+    static_folder = Path(__file__).parent / "static"
+    app = Flask(__name__, static_folder=str(static_folder), static_url_path="/static")
+
+    # Disable JSON key sorting to preserve insertion order (Flask 2.2+)
+    app.json.sort_keys = False
+
+    # Register routes
+    from ._routes import register_routes
+
+    register_routes(app)
+
+    return app
+
+
+def run_dashboard(
+    host: str = "127.0.0.1",
+    port: int = 5000,
+    debug: bool = False,
+    open_browser: bool = True,
+) -> None:
+    """Run the Flask dashboard server.
+
+    Parameters
+    ----------
+    host : str
+        Host to bind to. Default "127.0.0.1".
+    port : int
+        Port to listen on. Default 5000.
+    debug : bool
+        Enable Flask debug mode.
+    open_browser : bool
+        Open browser automatically.
+    """
+    app = create_app()
+
+    url = f"http://{host}:{port}"
+    print(f"Starting SciTeX Version Dashboard at {url}")
+    print("Press Ctrl+C to stop.")
+
+    if open_browser:
+        import threading
+        import webbrowser
+
+        def open_url():
+            import time
+
+            time.sleep(1)  # Wait for server to start
+            webbrowser.open(url)
+
+        threading.Thread(target=open_url, daemon=True).start()
+
+    try:
+        app.run(host=host, port=port, debug=debug, threaded=True)
+    except KeyboardInterrupt:
+        print("\nDashboard stopped.")
+
+
+# EOF