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

scitex/_dev/_dashboard/_routes.py

@@ -117,6 +117,19 @@ def register_routes(app: Flask) -> None:
         except Exception as e:
             return jsonify({"error": str(e)}), 500
 
+    @app.route("/api/rtd")
+    def api_rtd():
+        """Get Read the Docs build status."""
+        try:
+            packages = request.args.getlist("package") or None
+            versions = request.args.getlist("version") or None
+            from .._rtd import check_all_rtd
+
+            data = check_all_rtd(packages=packages, versions=versions)
+            return jsonify(data)
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
 
 def _get_all_version_data(force_refresh: bool = False) -> dict[str, Any]:
     """Get all version data from all sources.

scitex/_dev/_dashboard/_scripts.py

@@ -8,19 +8,20 @@
 def get_javascript() -> str:
     """Return dashboard JavaScript."""
     return """
-let cachedData = { packages: {}, hosts: {}, remotes: {} };
+let cachedData = { packages: {}, hosts: {}, remotes: {}, rtd: {} };
 
 async function fetchVersions() {
     showLoading(true);
-    cachedData = { packages: {}, hosts: {}, remotes: {} };
+    cachedData = { packages: {}, hosts: {}, remotes: {}, rtd: {} };
     renderFilters();
     renderData();
 
     // Load packages first (fast)
     fetchPackages();
-    // Load hosts and remotes in parallel (slower)
+    // Load hosts, remotes, and RTD in parallel (slower)
     fetchHosts();
     fetchRemotes();
+    fetchRtd();
 }
 
 async function fetchPackages() {
@@ -72,6 +73,22 @@ async function fetchRemotes() {
     }
 }
 
+async function fetchRtd() {
+    setSectionLoading('rtd', true);
+    try {
+        const response = await fetch('/api/rtd');
+        cachedData.rtd = await response.json();
+        renderFilters();
+        renderData();
+        setSectionUpdated('rtd');
+    } catch (err) {
+        console.error('Failed to fetch RTD status:', err);
+        cachedData.rtd = { error: err.message };
+    } finally {
+        setSectionLoading('rtd', false);
+    }
+}
+
 function setSectionLoading(section, loading) {
     const el = document.getElementById(section + 'Filters');
     if (el) {
@@ -167,6 +184,16 @@ function renderFilters() {
         remoteFilters.innerHTML = '<span style="color: var(--text-secondary)">No remotes configured</span>';
     }
 
+    const rtdFilters = document.getElementById('rtdFilters');
+    const rtdVersions = Object.keys(cachedData.rtd || {});
+    if (rtdVersions.length > 0) {
+        rtdFilters.innerHTML = rtdVersions.map(v =>
+            `<label><input type="checkbox" value="${v}" checked onchange="renderData()"> ${v}</label>`
+        ).join('');
+    } else {
+        rtdFilters.innerHTML = '<span style="color: var(--text-secondary)">Loading...</span>';
+    }
+
     document.querySelectorAll('#statusFilters input').forEach(input => {
         input.onchange = renderData;
     });
@@ -183,6 +210,22 @@ function getSelectedFilters() {
     };
 }
 
+function getEffectiveStatus(name, info) {
+    // Check RTD status and downgrade if needed
+    const rtdData = cachedData.rtd || {};
+    let status = info.status;
+    if (status === 'ok') {
+        const rtdLatest = rtdData['latest'] && rtdData['latest'][name];
+        const rtdStable = rtdData['stable'] && rtdData['stable'][name];
+        if ((rtdLatest && rtdLatest.status === 'failing') ||
+            (rtdStable && rtdStable.status === 'failing') ||
+            (rtdLatest && rtdLatest.status === 'not_found')) {
+            status = 'mismatch';
+        }
+    }
+    return status;
+}
+
 function renderData() {
     if (!cachedData) return;
     const filters = getSelectedFilters();
@@ -191,16 +234,17 @@ function renderData() {
     const filteredPackages = Object.entries(packages)
         .filter(([name, info]) => {
             if (!filters.packages.includes(name)) return false;
-            if (!filters.statuses.includes(info.status)) return false;
+            const effectiveStatus = getEffectiveStatus(name, info);
+            if (!filters.statuses.includes(effectiveStatus)) return false;
             return true;
         });
 
     const summary = {
         total: filteredPackages.length,
-        ok: filteredPackages.filter(([, i]) => i.status === 'ok').length,
-        unreleased: filteredPackages.filter(([, i]) => i.status === 'unreleased').length,
-        mismatch: filteredPackages.filter(([, i]) => i.status === 'mismatch').length,
-        outdated: filteredPackages.filter(([, i]) => i.status === 'outdated').length
+        ok: filteredPackages.filter(([n, i]) => getEffectiveStatus(n, i) === 'ok').length,
+        unreleased: filteredPackages.filter(([n, i]) => getEffectiveStatus(n, i) === 'unreleased').length,
+        mismatch: filteredPackages.filter(([n, i]) => getEffectiveStatus(n, i) === 'mismatch').length,
+        outdated: filteredPackages.filter(([n, i]) => getEffectiveStatus(n, i) === 'outdated').length
     };
 
     document.getElementById('summary').innerHTML = `
@@ -216,6 +260,7 @@ function renderData() {
         const remote = info.remote || {};
         const hostData = cachedData.hosts || {};
         const remoteData = cachedData.remotes || {};
+        const rtdData = cachedData.rtd || {};
 
         const hostVersions = Object.entries(hostData)
             .filter(([h]) => !h.startsWith('_') && filters.hosts.includes(h))
@@ -225,55 +270,111 @@ function renderData() {
             .filter(([r]) => !r.startsWith('_') && filters.remotes.includes(r))
             .map(([remoteName, remoteInfo]) => ({ name: remoteName, ...(remoteInfo[name] || {}) }));
 
-        return renderPackageCard(name, info, local, git, remote, hostVersions, remoteVersions);
+        // Get RTD status for this package (latest and stable)
+        const rtdStatus = {};
+        Object.entries(rtdData).forEach(([version, pkgData]) => {
+            if (pkgData[name]) {
+                rtdStatus[version] = pkgData[name];
+            }
+        });
+
+        return renderPackageCard(name, info, local, git, remote, hostVersions, remoteVersions, rtdStatus);
     }).join('');
 }
 
-function renderPackageCard(name, info, local, git, remote, hostVersions, remoteVersions) {
+function renderPackageCard(name, info, local, git, remote, hostVersions, remoteVersions, rtdStatus) {
+    const pypiUrl = `https://pypi.org/project/${name}/`;
+    const githubUrl = `https://github.com/ywatanabe1989/${name}`;
+    const rtdUrl = `https://${name === 'scitex' ? 'scitex-python' : name}.readthedocs.io/`;
+
+    // Collect all issues for tooltip
+    let allIssues = [...(info.issues || [])];
+
+    // Re-evaluate status based on RTD
+    let effectiveStatus = info.status;
+    if (rtdStatus && Object.keys(rtdStatus).length > 0) {
+        const rtdLatest = rtdStatus['latest'];
+        const rtdStable = rtdStatus['stable'];
+        if (rtdLatest && rtdLatest.status === 'failing') {
+            allIssues.push('RTD latest build failing');
+            if (effectiveStatus === 'ok') effectiveStatus = 'mismatch';
+        }
+        if (rtdStable && rtdStable.status === 'failing') {
+            allIssues.push('RTD stable build failing');
+            if (effectiveStatus === 'ok') effectiveStatus = 'mismatch';
+        }
+        if (rtdLatest && rtdLatest.status === 'not_found') {
+            allIssues.push('RTD project not found');
+            if (effectiveStatus === 'ok') effectiveStatus = 'mismatch';
+        }
+    }
+
+    // Create tooltip text from issues (using &#10; for newlines in title attribute)
+    const tooltipText = allIssues.length > 0 ? allIssues.join('&#10;') : '';
+    const tooltipAttr = tooltipText ? `title="${tooltipText}"` : '';
+
     let html = `
-        <div class="package-card">
-            <div class="package-header">
-                <span class="package-name">${name}</span>
-                <span class="status-badge status-${info.status}">${info.status}</span>
+        <div class="package-card collapsed">
+            <div class="package-header" onclick="toggleCard(this)">
+                <span class="fold-icon">▶</span>
+                <a href="${githubUrl}" target="_blank" class="package-name" onclick="event.stopPropagation()">${name}</a>
+                <span class="status-badge status-${effectiveStatus}" ${tooltipAttr}>${effectiveStatus}</span>
+                <span class="quick-links">
+                    <a href="${pypiUrl}" target="_blank" title="PyPI" onclick="event.stopPropagation()">📦</a>
+                    <a href="${githubUrl}" target="_blank" title="GitHub" onclick="event.stopPropagation()">🐙</a>
+                    <a href="${rtdUrl}" target="_blank" title="Docs" onclick="event.stopPropagation()">📖</a>
+                </span>
             </div>
             <div class="package-body">
                 <div class="version-grid">
                     <div class="version-section">
-                        <h4>Local</h4>
+                        <h4>LOCAL</h4>
                         <div class="version-item"><span class="key">toml</span><span class="value">${local.pyproject_toml || '-'}</span></div>
                         <div class="version-item"><span class="key">installed</span><span class="value">${local.installed || '-'}</span></div>
                     </div>
                     <div class="version-section">
-                        <h4>Git</h4>
+                        <h4>GIT</h4>
                         <div class="version-item"><span class="key">tag</span><span class="value">${git.latest_tag || '-'}</span></div>
                         <div class="version-item"><span class="key">branch</span><span class="value">${git.branch || '-'}</span></div>
                     </div>
                     <div class="version-section">
-                        <h4>PyPI</h4>
+                        <h4><a href="https://pypi.org/project/${name}/" target="_blank">PYPI</a></h4>
                         <div class="version-item"><span class="key">published</span><span class="value">${remote.pypi || '-'}</span></div>
                     </div>`;
 
     if (hostVersions.length > 0) {
-        html += `<div class="version-section"><h4>Hosts</h4>`;
         hostVersions.forEach(h => {
-            html += `<div class="version-item"><span class="key">${h.name}</span><span class="value">${h.installed || h.error || '-'}</span></div>`;
+            html += `<div class="version-section"><h4>${h.name.toUpperCase()}</h4>`;
+            html += `<div class="version-item"><span class="key">toml</span><span class="value">${h.toml || '-'}</span></div>`;
+            html += `<div class="version-item"><span class="key">installed</span><span class="value">${h.installed || h.error || '-'}</span></div>`;
+            html += `</div>`;
         });
-        html += `</div>`;
     }
 
     if (remoteVersions.length > 0) {
-        html += `<div class="version-section"><h4>GitHub</h4>`;
+        html += `<div class="version-section"><h4><a href="${githubUrl}" target="_blank">GITHUB</a></h4>`;
         remoteVersions.forEach(r => {
             html += `<div class="version-item"><span class="key">${r.name}</span><span class="value">${r.latest_tag || r.error || '-'}</span></div>`;
         });
         html += `</div>`;
     }
 
+    if (rtdStatus && Object.keys(rtdStatus).length > 0) {
+        html += `<div class="version-section"><h4><a href="${rtdUrl}" target="_blank">RTD</a></h4>`;
+        Object.entries(rtdStatus).forEach(([version, data]) => {
+            const statusClass = data.status === 'passing' ? 'rtd-passing' : (data.status === 'failing' ? 'rtd-failing' : 'rtd-unknown');
+            const statusIcon = data.status === 'passing' ? '✓' : (data.status === 'failing' ? '✗' : '?');
+            const link = data.url ? `<a href="${data.url}" target="_blank">${statusIcon}</a>` : statusIcon;
+            html += `<div class="version-item"><span class="key">${version}</span><span class="value ${statusClass}">${link} ${data.status || '-'}</span></div>`;
+        });
+        html += `</div>`;
+    }
+
     html += `</div>`;
 
-    if (info.issues && info.issues.length > 0) {
+    if (allIssues.length > 0) {
         html += `<div class="issues"><h4>Issues</h4><ul>`;
-        info.issues.forEach(i => { html += `<li>${i}</li>`; });
+        allIssues.forEach(i => { html += `<li>${i}</li>`; });
         html += `</ul></div>`;
     }
 
@@ -283,6 +384,26 @@ function renderPackageCard(name, info, local, git, remote, hostVersions, remoteV
 
 async function refreshData() { await fetchVersions(); }
 
+function toggleCard(header) {
+    const card = header.parentElement;
+    card.classList.toggle('collapsed');
+}
+
+function toggleAllCards(expand) {
+    document.querySelectorAll('.package-card').forEach(card => {
+        if (expand) {
+            card.classList.remove('collapsed');
+        } else {
+            card.classList.add('collapsed');
+        }
+    });
+}
+
+function toggleFilters() {
+    const filters = document.querySelector('.filters');
+    filters.classList.toggle('collapsed');
+}
+
 function exportJSON() {
     if (!cachedData) return;
     const blob = new Blob([JSON.stringify(cachedData, null, 2)], { type: 'application/json' });

scitex/_dev/_dashboard/_styles.py

@@ -199,6 +199,96 @@ button {
     0% { background: rgba(74, 222, 128, 0.3); }
     100% { background: transparent; }
 }
+.rtd-passing { color: var(--success); }
+.rtd-failing { color: var(--error); }
+.rtd-unknown { color: var(--warning); }
+.rtd-passing a, .rtd-failing a, .rtd-unknown a {
+    color: inherit;
+    text-decoration: none;
+}
+.rtd-passing a:hover, .rtd-failing a:hover, .rtd-unknown a:hover {
+    text-decoration: underline;
+}
+/* Collapsible cards */
+.package-card .package-header {
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}
+.package-card .fold-icon {
+    transition: transform 0.2s ease;
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+}
+.package-card:not(.collapsed) .fold-icon {
+    transform: rotate(90deg);
+}
+.package-card.collapsed .package-body {
+    display: none;
+}
+.package-card .package-name {
+    color: var(--accent);
+    text-decoration: none;
+    font-weight: bold;
+}
+.package-card .package-name:hover {
+    text-decoration: underline;
+}
+.package-card .quick-links {
+    margin-left: auto;
+    display: flex;
+    gap: 8px;
+    font-size: 1rem;
+}
+.package-card .quick-links a {
+    text-decoration: none;
+    opacity: 0.7;
+    transition: opacity 0.2s;
+}
+.package-card .quick-links a:hover {
+    opacity: 1;
+}
+/* Collapsible filters */
+.filters.collapsed .filter-group {
+    display: none;
+}
+.filters-toggle {
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 10px;
+    margin: -20px -20px 15px -20px;
+    background: var(--bg-card);
+    border-radius: 10px 10px 0 0;
+    color: var(--text-secondary);
+    font-size: 0.9rem;
+}
+.filters-toggle .fold-icon {
+    transition: transform 0.2s ease;
+}
+.filters:not(.collapsed) .filters-toggle .fold-icon {
+    transform: rotate(90deg);
+}
+.expand-controls {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 15px;
+}
+.expand-controls button {
+    padding: 5px 12px;
+    font-size: 0.8rem;
+}
+/* Section header links */
+.version-section h4 a {
+    color: var(--text-secondary);
+    text-decoration: none;
+}
+.version-section h4 a:hover {
+    color: var(--accent);
+    text-decoration: underline;
+}
 """
 
 

scitex/_dev/_dashboard/_templates.py

@@ -36,7 +36,11 @@ def get_dashboard_html() -> str:
             </div>
         </header>
 
-        <div class="filters">
+        <div class="filters collapsed">
+            <div class="filters-toggle" onclick="toggleFilters()">
+                <span class="fold-icon">▶</span>
+                <span>Filters &amp; Config</span>
+            </div>
             <div class="filter-group">
                 <h3>Packages</h3>
                 <div class="filter-options" id="packageFilters"></div>
@@ -59,6 +63,15 @@ def get_dashboard_html() -> str:
                 <h3>Remotes</h3>
                 <div class="filter-options" id="remoteFilters"></div>
             </div>
+            <div class="filter-group">
+                <h3>RTD</h3>
+                <div class="filter-options" id="rtdFilters"></div>
+            </div>
+        </div>
+
+        <div class="expand-controls">
+            <button class="btn-secondary" onclick="toggleAllCards(true)">Expand All</button>
+            <button class="btn-secondary" onclick="toggleAllCards(false)">Collapse All</button>
         </div>
 
         <div class="summary" id="summary"></div>

scitex/_dev/_rtd.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-03
+# File: scitex/_dev/_rtd.py
+
+"""Read the Docs build status checking for scitex ecosystem."""
+
+from __future__ import annotations
+
+import urllib.request
+from typing import Any
+
+from ._ecosystem import ECOSYSTEM
+
+# RTD project slugs (if different from package name)
+RTD_SLUGS: dict[str, str] = {
+    "scitex": "scitex-python",
+}
+
+
+def get_rtd_slug(package: str) -> str:
+    """Get RTD project slug for a package."""
+    return RTD_SLUGS.get(package, package)
+
+
+def check_rtd_status(package: str, version: str = "latest") -> dict[str, Any]:
+    """Check Read the Docs build status for a package.
+
+    Parameters
+    ----------
+    package : str
+        Package name.
+    version : str
+        RTD version to check (latest, stable, etc.).
+
+    Returns
+    -------
+    dict
+        Status info with keys: status, version, url, error (if any).
+    """
+    slug = get_rtd_slug(package)
+    badge_url = f"https://readthedocs.org/projects/{slug}/badge/?version={version}"
+    docs_url = f"https://{slug}.readthedocs.io/en/{version}/"
+
+    try:
+        # Fetch the badge SVG content to determine status
+        req = urllib.request.Request(badge_url)
+        req.add_header("User-Agent", "scitex-dev-tools/1.0")
+
+        with urllib.request.urlopen(req, timeout=10) as response:
+            content = response.read().decode("utf-8")
+
+            # Parse SVG content for status
+            if "passing" in content.lower():
+                status = "passing"
+            elif "failing" in content.lower():
+                status = "failing"
+            elif "unknown" in content.lower():
+                status = "unknown"
+            else:
+                status = "unknown"
+
+            return {
+                "status": status,
+                "version": version,
+                "url": docs_url,
+            }
+
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return {
+                "status": "not_found",
+                "version": version,
+                "error": f"Project '{slug}' not found on RTD",
+            }
+        return {
+            "status": "error",
+            "version": version,
+            "error": f"HTTP {e.code}: {e.reason}",
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "version": version,
+            "error": str(e),
+        }
+
+
+def check_all_rtd(
+    packages: list[str] | None = None,
+    versions: list[str] | None = None,
+) -> dict[str, dict[str, dict[str, Any]]]:
+    """Check RTD status for all ecosystem packages.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names. If None, uses ecosystem packages.
+    versions : list[str] | None
+        List of versions to check. Default: ["latest", "stable"].
+
+    Returns
+    -------
+    dict
+        Mapping: version -> package_name -> status_info
+    """
+    if packages is None:
+        packages = list(ECOSYSTEM.keys())
+
+    if versions is None:
+        versions = ["latest", "stable"]
+
+    results: dict[str, dict[str, dict[str, Any]]] = {}
+
+    for version in versions:
+        results[version] = {}
+        for package in packages:
+            results[version][package] = check_rtd_status(package, version)
+
+    return results
+
+
+# EOF

scitex/_dev/_ssh.py

@@ -147,20 +147,49 @@ def get_remote_versions(
     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 "
+    # Build Python command to check all packages (installed + toml)
+    # Use base64 encoding to avoid shell escaping issues
+    import base64
+
+    packages_list = repr(packages)
+    python_script = f"""
 import json
 from importlib.metadata import version
+from pathlib import Path
+import re
+
+def get_toml_version(pkg):
+    pkg_dir_names = [pkg, pkg.replace("-", "_"), pkg.replace("_", "-")]
+    if pkg == "scitex":
+        pkg_dir_names.append("scitex-python")
+    for dir_name in pkg_dir_names:
+        toml_path = Path.home() / "proj" / dir_name / "pyproject.toml"
+        if toml_path.exists():
+            try:
+                content = toml_path.read_text()
+                match = re.search(r'^version\\s*=\\s*["\\'](.*?)["\\']\\s*$', content, re.MULTILINE)
+                if match:
+                    return match.group(1)
+            except Exception:
+                pass
+    return None
+
 results = {{}}
-for pkg in [{packages_str}]:
+for pkg in {packages_list}:
+    result = {{"installed": None, "toml": None, "status": "not_installed"}}
     try:
-        results[pkg] = {{'installed': version(pkg), 'status': 'ok'}}
+        result["installed"] = version(pkg)
+        result["status"] = "ok"
     except Exception as e:
-        results[pkg] = {{'installed': None, 'status': 'not_installed', 'error': str(e)}}
+        result["error"] = str(e)
+    result["toml"] = get_toml_version(pkg)
+    results[pkg] = result
 print(json.dumps(results))
-"
 """
+    encoded = base64.b64encode(python_script.encode()).decode()
+    python_cmd = (
+        f"python3 -c \"import base64;exec(base64.b64decode('{encoded}').decode())\""
+    )
     ssh_args.append(python_cmd)
 
     try:
@@ -179,9 +208,10 @@ print(json.dumps(results))
             }
 
         import json
+        from typing import cast
 
         try:
-            return json.loads(result.stdout.strip())
+            return cast(dict[str, dict[str, Any]], json.loads(result.stdout.strip()))
         except json.JSONDecodeError:
             return {
                 pkg: {