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

scitex/_dev/_dashboard/_routes.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_dashboard/_routes.py
+
+"""Flask routes for the dashboard."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from flask import Flask
+
+
+def register_routes(app: Flask) -> None:
+    """Register dashboard routes with Flask app."""
+    from flask import jsonify, request
+
+    from ._templates import get_dashboard_html, get_error_html
+
+    @app.route("/")
+    def index():
+        """Serve the main dashboard page."""
+        try:
+            return get_dashboard_html()
+        except Exception as e:
+            return get_error_html(str(e)), 500
+
+    @app.route("/api/versions")
+    def api_versions():
+        """Get version data as JSON."""
+        try:
+            data = _get_all_version_data()
+            return jsonify(data)
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+    @app.route("/api/packages")
+    def api_packages():
+        """Get local package versions only (fast)."""
+        try:
+            from .._versions import list_versions
+
+            return jsonify(list_versions())
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+    @app.route("/api/config")
+    def api_config():
+        """Get current configuration."""
+        try:
+            from .._config import get_config_path, load_config
+
+            config = load_config()
+            return jsonify(
+                {
+                    "config_path": str(get_config_path()),
+                    "packages": [
+                        {
+                            "name": p.name,
+                            "local_path": p.local_path,
+                            "pypi_name": p.pypi_name,
+                        }
+                        for p in config.packages
+                    ],
+                    "hosts": [
+                        {
+                            "name": h.name,
+                            "hostname": h.hostname,
+                            "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,
+                }
+            )
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+    @app.route("/api/refresh", methods=["POST"])
+    def api_refresh():
+        """Trigger a data refresh."""
+        try:
+            data = _get_all_version_data(force_refresh=True)
+            return jsonify({"status": "ok", "data": data})
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+    @app.route("/api/hosts")
+    def api_hosts():
+        """Get host version data."""
+        try:
+            packages = request.args.getlist("package") or None
+            hosts = request.args.getlist("host") or None
+            from .._ssh import check_all_hosts
+
+            data = check_all_hosts(packages=packages, hosts=hosts)
+            return jsonify(data)
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+    @app.route("/api/remotes")
+    def api_remotes():
+        """Get GitHub remote version data."""
+        try:
+            packages = request.args.getlist("package") or None
+            remotes = request.args.getlist("remote") or None
+            from .._github import check_all_remotes
+
+            data = check_all_remotes(packages=packages, remotes=remotes)
+            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.
+
+    Parameters
+    ----------
+    force_refresh : bool
+        If True, bypass any caching.
+
+    Returns
+    -------
+    dict
+        Combined version data.
+    """
+    from .._config import get_enabled_hosts, get_enabled_remotes, load_config
+    from .._github import check_all_remotes
+    from .._ssh import check_all_hosts
+    from .._versions import list_versions
+
+    config = load_config()
+
+    # Get local versions
+    packages_data = list_versions()
+
+    # Get host versions (if any hosts configured)
+    hosts_data = {}
+    enabled_hosts = get_enabled_hosts(config)
+    if enabled_hosts:
+        try:
+            hosts_data = check_all_hosts(config=config)
+        except Exception:
+            pass
+
+    # Get remote versions (if any remotes configured)
+    remotes_data = {}
+    enabled_remotes = get_enabled_remotes(config)
+    if enabled_remotes:
+        try:
+            remotes_data = check_all_remotes(config=config)
+        except Exception:
+            pass
+
+    return {
+        "packages": packages_data,
+        "hosts": hosts_data,
+        "remotes": remotes_data,
+    }
+
+
+# EOF

scitex/_dev/_dashboard/_scripts.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_dashboard/_scripts.py
+
+"""JavaScript for the dashboard."""
+
+
+def get_javascript() -> str:
+    """Return dashboard JavaScript."""
+    return """
+let cachedData = { packages: {}, hosts: {}, remotes: {} };
+
+async function fetchVersions() {
+    showLoading(true);
+    cachedData = { packages: {}, hosts: {}, remotes: {} };
+    renderFilters();
+    renderData();
+
+    // Load packages first (fast)
+    fetchPackages();
+    // Load hosts and remotes in parallel (slower)
+    fetchHosts();
+    fetchRemotes();
+}
+
+async function fetchPackages() {
+    setSectionLoading('package', true);
+    try {
+        const response = await fetch('/api/packages');
+        cachedData.packages = await response.json();
+        renderFilters();
+        renderData();
+        updateTimestamp();
+        setSectionUpdated('package');
+    } catch (err) {
+        console.error('Failed to fetch packages:', err);
+    } finally {
+        showLoading(false);
+        setSectionLoading('package', false);
+    }
+}
+
+async function fetchHosts() {
+    setSectionLoading('host', true);
+    try {
+        const response = await fetch('/api/hosts');
+        cachedData.hosts = await response.json();
+        renderFilters();
+        renderData();
+        setSectionUpdated('host');
+    } catch (err) {
+        console.error('Failed to fetch hosts:', err);
+        cachedData.hosts = { error: err.message };
+    } finally {
+        setSectionLoading('host', false);
+    }
+}
+
+async function fetchRemotes() {
+    setSectionLoading('remote', true);
+    try {
+        const response = await fetch('/api/remotes');
+        cachedData.remotes = await response.json();
+        renderFilters();
+        renderData();
+        setSectionUpdated('remote');
+    } catch (err) {
+        console.error('Failed to fetch remotes:', err);
+        cachedData.remotes = { error: err.message };
+    } finally {
+        setSectionLoading('remote', false);
+    }
+}
+
+function setSectionLoading(section, loading) {
+    const el = document.getElementById(section + 'Filters');
+    if (el) {
+        if (loading) {
+            el.classList.add('loading-section');
+        } else {
+            el.classList.remove('loading-section');
+        }
+    }
+}
+
+function setSectionUpdated(section) {
+    const el = document.getElementById(section + 'Filters');
+    if (el) {
+        el.classList.add('just-updated');
+        setTimeout(() => el.classList.remove('just-updated'), 1000);
+    }
+}
+
+function updateTimestamp() {
+    document.getElementById('lastUpdated').textContent =
+        'Last updated: ' + new Date().toLocaleTimeString();
+}
+
+// Auto-refresh settings
+let autoRefreshInterval = null;
+let autoRefreshSeconds = 0;
+
+function toggleAutoRefresh(seconds) {
+    if (autoRefreshInterval) {
+        clearInterval(autoRefreshInterval);
+        autoRefreshInterval = null;
+        autoRefreshSeconds = 0;
+        document.getElementById('autoRefreshBtn').textContent = 'Auto: Off';
+        return;
+    }
+    autoRefreshSeconds = seconds;
+    document.getElementById('autoRefreshBtn').textContent = `Auto: ${seconds}s`;
+    autoRefreshInterval = setInterval(() => {
+        fetchPackages();
+        fetchHosts();
+        fetchRemotes();
+    }, seconds * 1000);
+}
+
+function cycleAutoRefresh() {
+    const options = [0, 30, 60, 120];
+    const current = options.indexOf(autoRefreshSeconds);
+    const next = options[(current + 1) % options.length];
+    if (autoRefreshInterval) {
+        clearInterval(autoRefreshInterval);
+        autoRefreshInterval = null;
+    }
+    if (next > 0) {
+        toggleAutoRefresh(next);
+    } else {
+        autoRefreshSeconds = 0;
+        document.getElementById('autoRefreshBtn').textContent = 'Auto: Off';
+    }
+}
+
+function showLoading(show) {
+    document.getElementById('loading').classList.toggle('active', show);
+    document.getElementById('overlay').classList.toggle('active', show);
+}
+
+function renderFilters() {
+    if (!cachedData) return;
+
+    const packageFilters = document.getElementById('packageFilters');
+    const packages = Object.keys(cachedData.packages || {});
+    packageFilters.innerHTML = packages.map(pkg =>
+        `<label><input type="checkbox" value="${pkg}" checked onchange="renderData()"> ${pkg}</label>`
+    ).join('');
+
+    const hostFilters = document.getElementById('hostFilters');
+    const hosts = Object.keys(cachedData.hosts || {});
+    if (hosts.length > 0) {
+        hostFilters.innerHTML = hosts.map(host =>
+            `<label><input type="checkbox" value="${host}" checked onchange="renderData()"> ${host}</label>`
+        ).join('');
+    } else {
+        hostFilters.innerHTML = '<span style="color: var(--text-secondary)">No hosts configured</span>';
+    }
+
+    const remoteFilters = document.getElementById('remoteFilters');
+    const remotes = Object.keys(cachedData.remotes || {});
+    if (remotes.length > 0) {
+        remoteFilters.innerHTML = remotes.map(remote =>
+            `<label><input type="checkbox" value="${remote}" checked onchange="renderData()"> ${remote}</label>`
+        ).join('');
+    } else {
+        remoteFilters.innerHTML = '<span style="color: var(--text-secondary)">No remotes configured</span>';
+    }
+
+    document.querySelectorAll('#statusFilters input').forEach(input => {
+        input.onchange = renderData;
+    });
+}
+
+function getSelectedFilters() {
+    const getChecked = (containerId) =>
+        [...document.querySelectorAll(`#${containerId} input:checked`)].map(el => el.value);
+    return {
+        packages: getChecked('packageFilters'),
+        statuses: getChecked('statusFilters'),
+        hosts: getChecked('hostFilters'),
+        remotes: getChecked('remoteFilters')
+    };
+}
+
+function renderData() {
+    if (!cachedData) return;
+    const filters = getSelectedFilters();
+    const packages = cachedData.packages || {};
+
+    const filteredPackages = Object.entries(packages)
+        .filter(([name, info]) => {
+            if (!filters.packages.includes(name)) return false;
+            if (!filters.statuses.includes(info.status)) 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
+    };
+
+    document.getElementById('summary').innerHTML = `
+        <div class="summary-card total"><div class="number">${summary.total}</div><div class="label">Total</div></div>
+        <div class="summary-card ok"><div class="number">${summary.ok}</div><div class="label">OK</div></div>
+        <div class="summary-card unreleased"><div class="number">${summary.unreleased}</div><div class="label">Unreleased</div></div>
+        <div class="summary-card mismatch"><div class="number">${summary.mismatch}</div><div class="label">Mismatch</div></div>
+    `;
+
+    document.getElementById('packages').innerHTML = filteredPackages.map(([name, info]) => {
+        const local = info.local || {};
+        const git = info.git || {};
+        const remote = info.remote || {};
+        const hostData = cachedData.hosts || {};
+        const remoteData = cachedData.remotes || {};
+
+        const hostVersions = Object.entries(hostData)
+            .filter(([h]) => !h.startsWith('_') && filters.hosts.includes(h))
+            .map(([hostName, hostInfo]) => ({ name: hostName, ...(hostInfo[name] || {}) }));
+
+        const remoteVersions = Object.entries(remoteData)
+            .filter(([r]) => !r.startsWith('_') && filters.remotes.includes(r))
+            .map(([remoteName, remoteInfo]) => ({ name: remoteName, ...(remoteInfo[name] || {}) }));
+
+        return renderPackageCard(name, info, local, git, remote, hostVersions, remoteVersions);
+    }).join('');
+}
+
+function renderPackageCard(name, info, local, git, remote, hostVersions, remoteVersions) {
+    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>
+            <div class="package-body">
+                <div class="version-grid">
+                    <div class="version-section">
+                        <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>
+                        <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>
+                        <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>`;
+    }
+
+    if (remoteVersions.length > 0) {
+        html += `<div class="version-section"><h4>GitHub</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>`;
+    }
+
+    html += `</div>`;
+
+    if (info.issues && info.issues.length > 0) {
+        html += `<div class="issues"><h4>Issues</h4><ul>`;
+        info.issues.forEach(i => { html += `<li>${i}</li>`; });
+        html += `</ul></div>`;
+    }
+
+    html += `</div></div>`;
+    return html;
+}
+
+async function refreshData() { await fetchVersions(); }
+
+function exportJSON() {
+    if (!cachedData) return;
+    const blob = new Blob([JSON.stringify(cachedData, null, 2)], { type: 'application/json' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = 'scitex-versions.json';
+    a.click();
+    URL.revokeObjectURL(url);
+}
+
+fetchVersions();
+"""
+
+
+# EOF

scitex/_dev/_dashboard/_styles.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_dashboard/_styles.py
+
+"""CSS styles for the dashboard."""
+
+
+def get_css() -> str:
+    """Return dashboard CSS."""
+    return """
+:root {
+    --bg-primary: #1a1a2e;
+    --bg-secondary: #16213e;
+    --bg-card: #0f3460;
+    --text-primary: #eee;
+    --text-secondary: #aaa;
+    --accent: #e94560;
+    --success: #4ade80;
+    --warning: #fbbf24;
+    --error: #f87171;
+    --info: #60a5fa;
+}
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    min-height: 100vh;
+    padding: 20px;
+}
+.container { max-width: 1400px; margin: 0 auto; }
+header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 30px;
+    padding: 20px;
+    background: var(--bg-secondary);
+    border-radius: 10px;
+}
+h1 { font-size: 1.8rem; color: var(--accent); }
+.actions { display: flex; gap: 10px; }
+button {
+    padding: 10px 20px;
+    border: none;
+    border-radius: 5px;
+    cursor: pointer;
+    font-size: 0.9rem;
+    transition: all 0.3s ease;
+}
+.btn-primary { background: var(--accent); color: white; }
+.btn-primary:hover { background: #c9184a; }
+.btn-secondary { background: var(--bg-card); color: var(--text-primary); }
+.btn-secondary:hover { background: #1a4d80; }
+.filters {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 20px;
+    margin-bottom: 30px;
+    padding: 20px;
+    background: var(--bg-secondary);
+    border-radius: 10px;
+}
+.filter-group { display: flex; flex-direction: column; gap: 10px; }
+.filter-group h3 {
+    font-size: 0.9rem;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+}
+.filter-options { display: flex; flex-wrap: wrap; gap: 8px; }
+.filter-options label {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+    padding: 5px 10px;
+    background: var(--bg-card);
+    border-radius: 5px;
+    cursor: pointer;
+    font-size: 0.85rem;
+    transition: all 0.2s ease;
+}
+.filter-options label:hover { background: #1a4d80; }
+.filter-options input[type="checkbox"],
+.filter-options input[type="radio"] { accent-color: var(--accent); }
+.summary {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: 15px;
+    margin-bottom: 30px;
+}
+.summary-card {
+    padding: 20px;
+    background: var(--bg-secondary);
+    border-radius: 10px;
+    text-align: center;
+}
+.summary-card .number { font-size: 2rem; font-weight: bold; }
+.summary-card .label { font-size: 0.85rem; color: var(--text-secondary); margin-top: 5px; }
+.summary-card.ok .number { color: var(--success); }
+.summary-card.unreleased .number { color: var(--warning); }
+.summary-card.mismatch .number { color: var(--error); }
+.summary-card.total .number { color: var(--info); }
+.packages { display: grid; gap: 20px; }
+.package-card { background: var(--bg-secondary); border-radius: 10px; overflow: hidden; }
+.package-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 15px 20px;
+    background: var(--bg-card);
+}
+.package-name { font-size: 1.1rem; font-weight: bold; }
+.status-badge {
+    padding: 5px 12px;
+    border-radius: 15px;
+    font-size: 0.75rem;
+    font-weight: bold;
+    text-transform: uppercase;
+}
+.status-ok { background: rgba(74, 222, 128, 0.2); color: var(--success); }
+.status-unreleased { background: rgba(251, 191, 36, 0.2); color: var(--warning); }
+.status-mismatch { background: rgba(248, 113, 113, 0.2); color: var(--error); }
+.status-outdated { background: rgba(167, 139, 250, 0.2); color: #a78bfa; }
+.status-unavailable { background: rgba(156, 163, 175, 0.2); color: #9ca3af; }
+.status-error { background: rgba(248, 113, 113, 0.2); color: var(--error); }
+.package-body { padding: 20px; }
+.version-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 15px;
+}
+.version-section { padding: 10px; background: var(--bg-primary); border-radius: 5px; }
+.version-section h4 {
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+    margin-bottom: 8px;
+    text-transform: uppercase;
+}
+.version-item { display: flex; justify-content: space-between; padding: 5px 0; font-size: 0.9rem; }
+.version-item .key { color: var(--text-secondary); }
+.version-item .value { font-family: monospace; }
+.issues {
+    margin-top: 15px;
+    padding: 10px;
+    background: rgba(248, 113, 113, 0.1);
+    border-radius: 5px;
+    border-left: 3px solid var(--error);
+}
+.issues h4 { font-size: 0.8rem; color: var(--error); margin-bottom: 5px; }
+.issues ul { list-style: none; font-size: 0.85rem; color: var(--text-secondary); }
+.issues li::before { content: "!"; margin-right: 8px; color: var(--error); }
+.loading {
+    display: none;
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    background: var(--bg-secondary);
+    padding: 30px;
+    border-radius: 10px;
+    text-align: center;
+    z-index: 1000;
+}
+.loading.active { display: block; }
+.spinner {
+    border: 4px solid var(--bg-card);
+    border-top: 4px solid var(--accent);
+    border-radius: 50%;
+    width: 40px;
+    height: 40px;
+    animation: spin 1s linear infinite;
+    margin: 0 auto 15px;
+}
+@keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
+.overlay {
+    display: none;
+    position: fixed;
+    top: 0; left: 0; right: 0; bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+    z-index: 999;
+}
+.overlay.active { display: block; }
+.last-updated { font-size: 0.8rem; color: var(--text-secondary); }
+.loading-section { opacity: 0.5; position: relative; }
+.loading-section::after {
+    content: "⟳";
+    position: absolute;
+    right: 5px;
+    top: -20px;
+    font-size: 1rem;
+    animation: spin 1s linear infinite;
+    color: var(--accent);
+}
+.just-updated {
+    animation: flash-green 0.5s ease;
+}
+@keyframes flash-green {
+    0% { background: rgba(74, 222, 128, 0.3); }
+    100% { background: transparent; }
+}
+"""
+
+
+# EOF