dars-framework 1.2.3__py3-none-any.whl

dars/all.py

@@ -0,0 +1,69 @@
+# Barrel import for all Dars components and core modules
+# Usage: from dars.all import *
+
+# Core
+from dars.core.app import App
+from dars.core.component import Component
+from dars.core.events import EventManager
+from dars.core.properties import *
+
+# Basic Components
+from dars.components.basic.button import Button
+from dars.components.basic.checkbox import Checkbox
+from dars.components.basic.container import Container
+from dars.components.basic.datepicker import DatePicker
+from dars.components.basic.image import Image
+from dars.components.basic.input import Input
+from dars.components.basic.link import Link
+from dars.components.basic.page import Page
+from dars.components.basic.progressbar import ProgressBar
+from dars.components.basic.radiobutton import RadioButton
+from dars.components.basic.select import Select
+from dars.components.basic.slider import Slider
+from dars.components.basic.spinner import Spinner
+from dars.components.basic.text import Text
+from dars.components.basic.textarea import Textarea
+from dars.components.basic.tooltip import Tooltip
+from dars.components.basic.markdown import Markdown
+
+# Advanced Components
+from dars.components.advanced.accordion import Accordion
+from dars.components.advanced.card import Card
+from dars.components.advanced.modal import Modal
+from dars.components.advanced.navbar import Navbar
+from dars.components.advanced.table import Table
+from dars.components.advanced.tabs import Tabs
+
+
+# Layout
+from dars.components.layout.grid import GridLayout, LayoutBase
+from dars.components.layout.flex import FlexLayout
+from dars.components.layout.anchor import AnchorPoint
+
+from dars.scripts.script import *
+from dars.scripts.dscript import dScript
+
+# Exporters (optional, for direct use)
+from dars.exporters.web.html_css_js import HTMLCSSJSExporter
+from dars.core.events import EventTypes
+from dars.core.events import EventHandler,  EventEmitter,  EventManager
+
+from dars.version import __version__
+from dars.dars_tests import *
+from dars.dars_tests.run_tests import run_app_tests, run_unit_tests, main
+# CLI (optional, for advanced usage)
+# from dars.cli.main import main as dars_cli_main
+from dars.core.state import dState, Mod
+
+__all__ = [
+    'App', 'Component', 'EventManager',
+    'Button', 'Checkbox', 'Container', 'DatePicker', 'Image', 'Input', 'Link', 'Page', 'ProgressBar',
+    'RadioButton', 'Select', 'Slider', 'Spinner', 'Text', 'Textarea', 'Tooltip',
+    'Accordion', 'Card', 'Modal', 'Navbar', 'Table', 'Tabs',
+    'GridLayout', 'FlexLayout', 'LayoutBase', 'AnchorPoint',
+    'InlineScript', 'FileScript', 'dScript', 'HTMLCSSJSExporter',
+    'EventTypes', 'EventHandler', 'EventEmitter', 'EventManager', 'Markdown',
+    '__version__',
+    'run_app_tests', 'run_unit_tests', 'main',
+    'dState', 'Mod',
+]

dars/cli/doctor/__init__.py

@@ -0,0 +1 @@
+# dars.cli.doctor package

dars/cli/doctor/detect.py

@@ -0,0 +1,154 @@
+import os, subprocess, sys, re
+from typing import Tuple, Optional, List, Dict
+from dars.core.js_bridge import has_bun, has_node, _run as js_run
+
+SEMVER_RE = re.compile(r"v?(\d+)\.(\d+)\.(\d+)")
+
+
+def _run(cmd: List[str]) -> Tuple[int, str, str]:
+    try:
+        p = subprocess.run(cmd, capture_output=True, text=True, shell=False)
+        return p.returncode, p.stdout.strip(), p.stderr.strip()
+    except Exception as e:
+        return 1, "", str(e)
+
+
+def which(bin_name: str) -> Optional[str]:
+    if os.name == 'nt':
+        code, out, _ = _run(["where", bin_name])
+    else:
+        code, out, _ = _run(["which", bin_name])
+    if code == 0 and out:
+        return out.splitlines()[0].strip()
+    return None
+
+
+def parse_semver(s: str) -> Optional[str]:
+    m = SEMVER_RE.search(s or "")
+    if not m:
+        return None
+    return f"{m.group(1)}.{m.group(2)}.{m.group(3)}"
+
+
+def detect_node() -> Dict[str, Optional[str]]:
+    path = which("node")
+    if not path:
+        return {"ok": False, "version": None, "path": None}
+    code, out, _ = _run([path, "--version"])  # prints like v18.19.1
+    ver = parse_semver(out)
+    return {"ok": bool(ver), "version": ver, "path": path}
+
+
+def detect_esbuild() -> Dict[str, Optional[str]]:
+    # Prefer bun x esbuild --version
+    if has_bun():
+        code, out, err = js_run(["bun", "x", "esbuild", "--version"])  # type: ignore
+        if code == 0:
+            return {"ok": True, "version": out.strip() or "unknown", "path": "bun x esbuild"}
+    # Node fallback
+    if has_node():
+        code, out, err = js_run(["npx", "--yes", "esbuild", "--version"])  # type: ignore
+        if code == 0:
+            return {"ok": True, "version": out.strip() or "unknown", "path": "npx esbuild"}
+    return {"ok": False, "version": None, "path": None}
+
+
+def detect_vite() -> Dict[str, Optional[str]]:
+    # Prefer bun x vite --version
+    if has_bun():
+        code, out, err = js_run(["bun", "x", "vite", "--version"])  # type: ignore
+        if code == 0:
+            return {"ok": True, "version": out.strip() or "unknown", "path": "bun x vite"}
+    if has_node():
+        code, out, err = js_run(["npx", "--yes", "vite", "--version"])  # type: ignore
+        if code == 0:
+            return {"ok": True, "version": out.strip() or "unknown", "path": "npx vite"}
+    return {"ok": False, "version": None, "path": None}
+
+
+def detect_bun() -> Dict[str, Optional[str]]:
+    path = which("bun")
+    if not path:
+        return {"ok": False, "version": None, "path": None}
+    code, out, _ = _run([path, "--version"])  # prints like 1.1.24
+    ver = parse_semver(out) or out.strip()
+    return {"ok": bool(ver), "version": ver, "path": path}
+
+
+def read_pyproject_deps(pyproject_path: Optional[str] = None) -> List[str]:
+    """Extract [project].dependencies items as a list of requirement strings.
+    Avoids pulling unrelated keys (e.g., license).
+    """
+    path = pyproject_path or os.path.join(os.getcwd(), "pyproject.toml")
+    if not os.path.isfile(path):
+        return []
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        reqs: List[str] = []
+        in_project = False
+        in_array = False
+        buf: List[str] = []
+        for raw in lines:
+            l = raw.strip()
+            # Track project table
+            if l.startswith('['):
+                in_project = (l == '[project]')
+                # leaving dependencies array if we hit a new table
+                if l != '[project]':
+                    in_array = False
+                continue
+            if not in_project:
+                continue
+            # Find dependencies array start
+            if not in_array and l.startswith('dependencies') and '=' in l:
+                # Could be inline or multiline
+                # Normalize to everything after '='
+                after = l.split('=', 1)[1].strip()
+                if after.startswith('[') and after.endswith(']'):
+                    # Inline array
+                    buf = [after]
+                    in_array = False
+                elif after.startswith('['):
+                    buf = [after]
+                    in_array = True
+                else:
+                    # Malformed; skip
+                    buf = []
+                    in_array = False
+                # If inline, fall-through to extraction below
+            elif in_array:
+                buf.append(l)
+                if ']' in l:
+                    in_array = False
+            # When we have a complete buffer (inline or closed multiline), extract
+            if buf and not in_array:
+                content = ' '.join(buf)
+                # Extract quoted items within brackets
+                m = re.findall(r'"([^"\\]*(?:\\.[^"\\]*)*)"', content)
+                for item in m:
+                    if item:
+                        reqs.append(item)
+                buf = []
+        return reqs
+    except Exception:
+        return []
+
+
+def check_python_deps(requirements: List[str]) -> Dict[str, List[str]]:
+    missing: List[str] = []
+    try:
+        try:
+            import importlib.metadata as md  # py3.8+
+        except Exception:
+            import importlib_metadata as md  # type: ignore
+        for spec in requirements:
+            name = spec.split("==")[0].split(">=")[0].split("<=")[0]
+            try:
+                md.version(name)
+            except Exception:
+                missing.append(spec)
+    except Exception:
+        # if detection fails, don't block
+        pass
+    return {"missing": missing}

dars/cli/doctor/doctor.py

@@ -0,0 +1,176 @@
+import os, sys
+from typing import Dict, List
+from .detect import detect_node, detect_bun, detect_esbuild, detect_vite, read_pyproject_deps, check_python_deps
+from .installers import install_node, install_bun, install_esbuild, install_vite
+from .persist import load_config, save_config
+from .ui import render_report, prompt_action, confirm_install
+from rich.console import Console
+
+console = Console()
+
+
+def run_doctor(check_only: bool = False, auto_yes: bool = False, install_all: bool = False, force: bool = False) -> int:
+    cfg = load_config()
+
+    # Detect with spinner
+    with console.status("[cyan]Checking environment...[/cyan]"):
+        node = detect_node()
+        bun = detect_bun()
+        esb = detect_esbuild()
+        vit = detect_vite()
+        reqs = read_pyproject_deps()
+        py = check_python_deps(reqs)
+
+    render_report(node, bun, py, esb, vit)
+
+    missing_items: List[str] = []
+    if not node.get('ok'): missing_items.append('Node.js LTS')
+    if not bun.get('ok'): missing_items.append('Bun stable')
+    if py.get('missing'): missing_items.append('Python deps')
+    optional_missing: List[str] = []
+    if not esb.get('ok'): optional_missing.append('esbuild (optional)')
+    if not vit.get('ok'): optional_missing.append('vite (optional)')
+
+    if check_only:
+        return 0 if not missing_items else 1
+
+    # Decide next steps
+    has_missing = bool(missing_items)
+
+    # Always show a small action menu; if nothing missing, offer re-run/quit
+    if not check_only:
+        choice = '1' if (auto_yes and install_all and has_missing) else prompt_action(has_missing)
+        if has_missing:
+            if choice == '3':
+                return 1
+            if choice == '2':
+                return run_doctor(check_only=False, auto_yes=auto_yes, install_all=install_all, force=True)
+        else:
+            # No missing: '1' => re-run, '2' => quit
+            if choice == '2':
+                return 0
+            if choice == '1':
+                return run_doctor(check_only=False, auto_yes=auto_yes, install_all=install_all, force=True)
+
+    if not has_missing:
+        cfg['requirements']['node'].update({'ok': True, 'version': node.get('version')})
+        cfg['requirements']['bun'].update({'ok': True, 'version': bun.get('version')})
+        cfg['python_deps'] = {'ok': True, 'missing': []}
+        cfg['satisfied'] = True
+        save_config(cfg)
+        return 0
+
+    if auto_yes and install_all:
+        choice = '1'
+    else:
+        choice = prompt_action()
+    if choice == '3':
+        return 1
+
+    if choice == '2':
+        # Re-run immediately
+        return run_doctor(check_only=False, auto_yes=auto_yes, install_all=install_all, force=True)
+
+    # choice == '1' => Install ALL missing
+    summary: List[str] = []
+    if not node.get('ok'): summary.append('Node.js LTS (winget)')
+    if not bun.get('ok'): summary.append('Bun (winget)')
+    if py.get('missing'): summary.append(f"Python deps: {', '.join(py['missing'])}")
+    if optional_missing:
+        summary.extend(optional_missing)
+
+    if not auto_yes:
+        if not confirm_install(summary):
+            return 1
+
+    # Installers: always run Node then Bun sequentially (idempotent if already installed)
+    with console.status("[cyan]Installing selected items...[/cyan]"):
+        try:
+            install_node()
+        except Exception:
+            pass
+        try:
+            install_bun()
+        except Exception:
+            pass
+        # Optional developer tools
+        try:
+            if not esb.get('ok'):
+                install_esbuild()
+        except Exception:
+            pass
+        try:
+            if not vit.get('ok'):
+                install_vite()
+        except Exception:
+            pass
+
+    # Python deps via pip
+    if py.get('missing'):
+        try:
+            import subprocess
+            cmd = [sys.executable, '-m', 'pip', 'install', '--upgrade'] + py['missing']
+            subprocess.run(cmd, check=False)
+        except Exception:
+            pass
+
+    # Re-check after attempted install
+    with console.status("[cyan]Re-checking...[/cyan]"):
+        node2 = detect_node()
+        bun2 = detect_bun()
+        esb2 = detect_esbuild()
+        vit2 = detect_vite()
+        py2 = check_python_deps(read_pyproject_deps())
+
+    render_report(node2, bun2, py2, esb2, vit2)
+
+    all_ok = node2.get('ok') and bun2.get('ok') and not py2.get('missing')
+
+    cfg['requirements']['node'].update({'ok': bool(node2.get('ok')), 'version': node2.get('version')})
+    cfg['requirements']['bun'].update({'ok': bool(bun2.get('ok')), 'version': bun2.get('version')})
+    cfg['python_deps'] = {'ok': not bool(py2.get('missing')), 'missing': py2.get('missing') or []}
+    cfg['satisfied'] = bool(all_ok)
+    save_config(cfg)
+
+    return 0 if all_ok else 1
+
+
+def run_forcedev() -> int:
+    """Force-install everything without initial verification or prompts.
+    - Attempts Node LTS and Bun installers unconditionally (best-effort)
+    - Installs/updates all Python deps from pyproject.toml
+    - Re-checks and persists satisfied state
+    Returns 0 if environment ends OK, else 1.
+    """
+    # Best-effort installs (no UI)
+    try:
+        install_node()
+    except Exception:
+        pass
+    try:
+        install_bun()
+    except Exception:
+        pass
+
+    reqs = read_pyproject_deps()
+    if reqs:
+        try:
+            import subprocess, sys as _sys
+            cmd = [_sys.executable, '-m', 'pip', 'install', '--upgrade'] + reqs
+            subprocess.run(cmd, check=False)
+        except Exception:
+            pass
+
+    # Re-check and persist
+    cfg = load_config()
+    node2 = detect_node()
+    bun2 = detect_bun()
+    py2 = check_python_deps(read_pyproject_deps())
+    all_ok = node2.get('ok') and bun2.get('ok') and not py2.get('missing')
+
+    cfg['requirements']['node'].update({'ok': bool(node2.get('ok')), 'version': node2.get('version')})
+    cfg['requirements']['bun'].update({'ok': bool(bun2.get('ok')), 'version': bun2.get('version')})
+    cfg['python_deps'] = {'ok': not bool(py2.get('missing')), 'missing': py2.get('missing') or []}
+    cfg['satisfied'] = bool(all_ok)
+    save_config(cfg)
+    return 0 if all_ok else 1

dars/cli/doctor/installers.py

@@ -0,0 +1,100 @@
+import os, sys, subprocess
+from typing import Tuple
+from dars.core.js_bridge import has_bun
+
+
+def run(cmd: list) -> Tuple[int, str, str]:
+    try:
+        p = subprocess.run(cmd, capture_output=True, text=True, shell=False)
+        return p.returncode, p.stdout.strip(), p.stderr.strip()
+    except Exception as e:
+        return 1, "", str(e)
+
+
+def run_live(cmd: list, shell: bool = False) -> int:
+    """Run a command inheriting stdout/stderr so the user sees prompts/output live."""
+    try:
+        p = subprocess.run(cmd, shell=shell)
+        return p.returncode or 0
+    except Exception:
+        return 1
+
+
+# --- Windows installers (preferred: winget) ---
+
+def install_node_windows() -> Tuple[bool, str]:
+    # OpenJS.NodeJS.LTS is the winget package id for Node.js LTS
+    code, out, err = run(["winget", "install", "-e", "--id", "OpenJS.NodeJS.LTS"])
+    ok = (code == 0)
+    return ok, (out or err)
+
+
+def install_bun_windows() -> Tuple[bool, str]:
+    # 1) Try winget first (Oven-sh.Bun)
+    code, out, err = run(["winget", "install", "-e", "--id", "Oven-sh.Bun"])
+    if code == 0:
+        return True, (out or err)
+    # 2) Fallback: official bun.sh PowerShell installer (streams output)
+    # Command shown to the user for transparency
+    print("Executing: powershell -NoProfile -ExecutionPolicy Bypass -c \"irm bun.sh/install.ps1 | iex\"")
+    ps_cmd = [
+        "powershell",
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-c",
+        "irm bun.sh/install.ps1 | iex",
+    ]
+    code2 = run_live(ps_cmd, shell=False)
+    return code2 == 0, (out or err)
+
+
+# --- Stubs for macOS/Linux (future extension) ---
+
+def install_node_posix() -> Tuple[bool, str]:
+    # For now, provide guidance only
+    msg = "Please install Node.js LTS from https://nodejs.org (or use a package manager)."
+    return False, msg
+
+
+def install_bun_posix() -> Tuple[bool, str]:
+    # Use official installer with live output
+    # Prefer bash -lc; fallback to sh -lc
+    cmd_str = "curl -fsSL https://bun.sh/install | bash"
+    print(f"Executing: bash -lc \"{cmd_str}\"")
+    # Try bash first
+    code = run_live(["bash", "-lc", cmd_str], shell=False)
+    if code != 0:
+        print(f"bash failed, falling back to: sh -lc \"{cmd_str}\"")
+        code = run_live(["sh", "-lc", cmd_str], shell=False)
+    return code == 0, ""
+
+
+def install_node() -> Tuple[bool, str]:
+    if os.name == 'nt':
+        return install_node_windows()
+    return install_node_posix()
+
+
+def install_bun() -> Tuple[bool, str]:
+    if os.name == 'nt':
+        return install_bun_windows()
+    return install_bun_posix()
+
+
+def install_esbuild() -> Tuple[bool, str]:
+    # Prefer Bun-managed dev dep
+    if has_bun():
+        print("Executing: bun add -d esbuild")
+        code = run_live(["bun", "add", "-d", "esbuild"], shell=False)
+        return (code == 0, "")
+    # Node fallback: use npx without install (sufficient for detection), nothing to install
+    return True, ""
+
+
+def install_vite() -> Tuple[bool, str]:
+    if has_bun():
+        print("Executing: bun add -d vite")
+        code = run_live(["bun", "add", "-d", "vite"], shell=False)
+        return (code == 0, "")
+    return True, ""

dars/cli/doctor/persist.py

@@ -0,0 +1,62 @@
+import json, os, sys
+from datetime import datetime
+from typing import Any, Dict, Tuple
+
+APP_NAME = "Dars"
+
+
+def _config_base_dir() -> str:
+    # Windows
+    if os.name == 'nt':
+        base = os.getenv('APPDATA') or os.path.expanduser('~')
+        return os.path.join(base, APP_NAME)
+    # POSIX
+    xdg = os.getenv('XDG_CONFIG_HOME')
+    if xdg:
+        return os.path.join(xdg, 'dars')
+    return os.path.join(os.path.expanduser('~/.config'), 'dars')
+
+
+def get_config_path() -> str:
+    d = _config_base_dir()
+    os.makedirs(d, exist_ok=True)
+    return os.path.join(d, 'config.json')
+
+
+def load_config() -> Dict[str, Any]:
+    p = get_config_path()
+    if not os.path.isfile(p):
+        return {
+            'requirements': {
+                'node': {'ok': False, 'version': None, 'source': None, 'checked_at': None},
+                'bun': {'ok': False, 'version': None, 'source': None, 'checked_at': None},
+                'optional': {}
+            },
+            'python_deps': {'ok': True, 'missing': [], 'checked_at': None},
+            'satisfied': False,
+            'last_doctor': None,
+        }
+    try:
+        with open(p, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception:
+        return {
+            'requirements': {
+                'node': {'ok': False, 'version': None, 'source': None, 'checked_at': None},
+                'bun': {'ok': False, 'version': None, 'source': None, 'checked_at': None},
+                'optional': {}
+            },
+            'python_deps': {'ok': True, 'missing': [], 'checked_at': None},
+            'satisfied': False,
+            'last_doctor': None,
+        }
+
+
+def save_config(cfg: Dict[str, Any]) -> None:
+    p = get_config_path()
+    try:
+        cfg['last_doctor'] = datetime.utcnow().isoformat() + 'Z'
+    except Exception:
+        pass
+    with open(p, 'w', encoding='utf-8') as f:
+        json.dump(cfg, f, indent=2)

dars/cli/doctor/preflight.py

@@ -0,0 +1,33 @@
+import os
+from typing import Any
+from .persist import load_config, save_config
+from .doctor import run_doctor
+
+
+SKIP_COMMANDS = { 'doctor', 'forcedev' }
+
+
+def check_and_gate(command: str) -> None:
+    """
+    Runs once before any CLI command (except 'doctor').
+    If environment hasn't satisfied mandatory requirements, invoke doctor.
+    After a successful run, future commands proceed without gating.
+    """
+    if command in SKIP_COMMANDS:
+        return
+    # Allow CI to skip interactivity but still fail properly
+    if os.getenv('DARS_NO_PREFLIGHT') == '1':
+        return
+
+    cfg = load_config()
+    if cfg.get('satisfied'):
+        return
+
+    # If not satisfied, run doctor interactively
+    code = run_doctor(check_only=False, auto_yes=False, install_all=False, force=False)
+    # If doctor returns non-zero, we still persist current state and let the caller decide to exit
+    # but generally, the CLI will continue only if requirements are satisfied; we make it strict here
+    cfg = load_config()
+    if not cfg.get('satisfied'):
+        # Propagate an exception to abort command execution
+        raise SystemExit(1)

dars/cli/doctor/ui.py

@@ -0,0 +1,54 @@
+from typing import Dict, List
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+
+console = Console()
+
+def render_report(node: Dict, bun: Dict, py: Dict, esb: Dict = None, vit: Dict = None):
+    table = Table(title="Dars Doctor — Environment Report", box=None)
+    table.add_column("Component", style="cyan")
+    table.add_column("Required", style="white")
+    table.add_column("Detected", style="green")
+    table.add_column("Status", style="bold")
+
+    n_status = "OK" if node.get("ok") else "MISSING"
+    b_status = "OK" if bun.get("ok") else "MISSING"
+    p_missing = py.get("missing", [])
+    p_status = "OK" if not p_missing else f"Missing: {len(p_missing)}"
+
+    table.add_row("Node.js", "LTS (stable)", node.get("version") or "-", n_status)
+    table.add_row("Bun", "Stable", bun.get("version") or "-", b_status)
+    table.add_row("Python deps", "pyproject.toml", "-", p_status)
+    if esb is not None:
+        table.add_row("esbuild", "optional", (esb.get("version") if esb else "-") or "-", "OK" if esb and esb.get("ok") else "MISSING")
+    if vit is not None:
+        table.add_row("vite", "optional", (vit.get("version") if vit else "-") or "-", "OK" if vit and vit.get("ok") else "MISSING")
+
+    console.print(table)
+    if p_missing:
+        bullets = "\n".join([f" • {req}" for req in p_missing])
+        console.print(Panel(bullets or "", title="Missing Python packages", border_style="yellow"))
+
+
+def prompt_action(has_missing: bool) -> str:
+    console.print(Panel("Select an action", border_style="cyan"))
+    if has_missing:
+        console.print("[1] Install ALL missing\n[2] Re-run checks\n[3] Quit")
+        choices = ["1","2","3"]
+        default = "1"
+    else:
+        console.print("[1] Re-run checks\n[2] Quit")
+        choices = ["1","2"]
+        default = "1"
+    while True:
+        choice = Prompt.ask("Choice", choices=choices, default=default)
+        return choice
+
+
+def confirm_install(summary_lines: List[str]) -> bool:
+    console.print(Panel("The following will be installed:", border_style="yellow"))
+    for line in summary_lines:
+        console.print(f" • {line}")
+    return Confirm.ask("Proceed with installation?", default=True)