dars-framework 1.2.3__py3-none-any.whl

dars/core/state.py

@@ -0,0 +1,309 @@
+from typing import Any, Dict, List, Optional
+from dars.scripts.script import InlineScript
+
+# Global registry collected at authoring time (Python)
+STATE_BOOTSTRAP: List[Dict[str, Any]] = []
+
+class DarsState:
+    def __init__(self, name: str, id: Optional[str], states: Optional[List[Any]], is_custom: bool = False):
+        self.name = name
+        self.id = id
+        self.states = states or []
+        self.is_custom = is_custom
+        self.rules: Dict[str, Dict[str, Any]] = {}
+        self._bootstrap_ref: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = {
+            "name": self.name,
+            "id": self.id,
+            "states": self.states,
+            "isCustom": self.is_custom,
+        }
+        try:
+            d["defaultIndex"] = 0
+            d["defaultValue"] = (self.states[0] if isinstance(self.states, list) and len(self.states) > 0 else None)
+        except Exception:
+            d["defaultIndex"] = 0
+            d["defaultValue"] = None
+        if self.rules:
+            d["rules"] = self.rules
+        return d
+
+    def state(self, idx: Optional[int] = None, cComp: bool = False, render: Optional[Any] = None, goto: Optional[Any] = None) -> InlineScript:
+        """
+        Convenience: returns an InlineScript that, when added to a page/app,
+        triggers a state change via the JS runtime. Intended for quick prototyping.
+
+        - idx: target state index/value
+        - cComp: if True, performs a full HTML replace (custom component flow)
+        - render: HTML string to inject when cComp=True
+        """
+        target_id = self.id or ""
+
+        def _escape_js_str(s: str) -> str:
+            return s.replace("\\", "\\\\").replace("'", "\\'").replace("\n", "\\n").replace("\r", "")
+
+        # Compute HTML if needed
+        html_val = None
+        if cComp and render is not None:
+            try:
+                # DeferredAttr -> clone component with attrs
+                if hasattr(render, 'clone_with') and callable(getattr(render, 'clone_with')):
+                    render = render.clone_with()
+                # If it's a Component instance, render it to HTML
+                try:
+                    from dars.core.component import Component as _DarsComponent
+                    if isinstance(render, _DarsComponent):
+                        from dars.exporters.web.html_css_js import HTMLCSSJSExporter
+                        _exp = HTMLCSSJSExporter()
+                        html_val = _exp.render_component(render)
+                except Exception:
+                    html_val = None
+                if html_val is None and isinstance(render, str):
+                    html_val = render
+            except Exception:
+                html_val = None
+
+        # Build payload
+        parts = [f"id: '{_escape_js_str(target_id)}'", f"name: '{_escape_js_str(self.name)}'"]
+        if idx is not None:
+            parts.append(f"state: {idx}")
+        if goto is not None:
+            if isinstance(goto, str):
+                parts.append(f"goto: '{_escape_js_str(goto)}'")
+            else:
+                parts.append(f"goto: {goto}")
+        if cComp:
+            html_str = _escape_js_str(html_val or "")
+            parts.append("useCustomRender: true")
+            parts.append(f"html: '{html_str}'")
+        payload = ", ".join(parts)
+
+        code = (
+            "(async () => {\n"
+            "  try {\n"
+            "    let ch = window.__DARS_CHANGE_FN;\n"
+            "    if (!ch) {\n"
+            "      if (window.Dars && typeof window.Dars.change === 'function') {\n"
+            "        ch = window.Dars.change.bind(window.Dars);\n"
+            "      } else {\n"
+            "        const m = await import('./lib/dars.min.js');\n"
+            "        ch = (m.change || (m.default && m.default.change));\n"
+            "      }\n"
+            "      if (typeof ch === 'function') window.__DARS_CHANGE_FN = ch;\n"
+            "    }\n"
+            f"    if (typeof ch === 'function') ch({{{payload}}});\n"
+            "  } catch (e) { /* noop */ }\n"
+            "})();\n"
+        )
+        return InlineScript(code, module=True)
+
+    # --- cState: define rules/mods for a given state index ---
+    def cState(self, idx: int, mods: Optional[List[Dict[str, Any]]] = None) -> 'CStateRuleBuilder':
+        key = str(idx)
+        if idx == 0:
+            raise ValueError(
+                "Default state (index 0) is immutable. Do not define cState(0). "
+                "Configure the component's default directly on the instance instead."
+            )
+        if key not in self.rules:
+            self.rules[key] = {}
+        if mods:
+            existing = list(self.rules[key].get('mods', []))
+            existing.extend(mods)
+            self.rules[key]['mods'] = existing
+            # mirror into bootstrap ref if exists
+            if self._bootstrap_ref is not None:
+                self._bootstrap_ref.setdefault('rules', {})
+                self._bootstrap_ref['rules'][key] = self.rules[key]
+        return CStateRuleBuilder(self, key)
+
+    # sugar: direct goto builder for rules
+    def goto(self, value: Any) -> 'CStateRuleBuilder':
+        # attach as default rule for current state if exists, else for state 0
+        key = str(0)
+        if key not in self.rules:
+            self.rules[key] = {}
+        self.rules[key]['goto'] = value
+        if self._bootstrap_ref is not None:
+            self._bootstrap_ref.setdefault('rules', {})
+            self._bootstrap_ref['rules'][key] = self.rules[key]
+        return CStateRuleBuilder(self, key)
+
+
+class Mod:
+    @staticmethod
+    def inc(target: Any, prop: str = 'text', by: int = 1) -> Dict[str, Any]:
+        tid = getattr(target, 'id', None) or str(target)
+        return {"op": "inc", "target": tid, "prop": prop, "by": by}
+
+    @staticmethod
+    def dec(target: Any, prop: str = 'text', by: int = 1) -> Dict[str, Any]:
+        return Mod.inc(target, prop=prop, by=(-abs(by)))
+
+    @staticmethod
+    def set(target: Any, **attrs) -> Dict[str, Any]:
+        tid = getattr(target, 'id', None) or str(target)
+        return {"op": "set", "target": tid, "attrs": attrs}
+
+    @staticmethod
+    def toggle_class(target: Any, name: str, on: Optional[bool] = None) -> Dict[str, Any]:
+        tid = getattr(target, 'id', None) or str(target)
+        d: Dict[str, Any] = {"op": "toggleClass", "target": tid, "name": name}
+        if on is not None:
+            d['on'] = bool(on)
+        return d
+
+    @staticmethod
+    def append_text(target: Any, value: str) -> Dict[str, Any]:
+        tid = getattr(target, 'id', None) or str(target)
+        return {"op": "appendText", "target": tid, "value": value}
+
+    @staticmethod
+    def prepend_text(target: Any, value: str) -> Dict[str, Any]:
+        tid = getattr(target, 'id', None) or str(target)
+        return {"op": "prependText", "target": tid, "value": value}
+
+    @staticmethod
+    def call(target: Any, state: Any = None, goto: Any = None) -> Dict[str, Any]:
+        """Invoke another dState's state change.
+        - target: DarsState instance or state name string; if a component is passed, use its id.
+        - state: target state index/value.
+        - goto: relative/absolute goto directive (e.g., '+1').
+        The runtime will resolve the state by name first (registry), falling back to id.
+        """
+        name: Optional[str] = None
+        sid: Optional[str] = None
+        try:
+            # DarsState instance
+            if hasattr(target, 'name') and hasattr(target, 'id'):
+                name = getattr(target, 'name', None)
+                sid = getattr(target, 'id', None)
+            elif isinstance(target, str):
+                name = target
+            else:
+                # Maybe a component; try id
+                sid = getattr(target, 'id', None) or str(target)
+        except Exception:
+            name = None
+            sid = None
+        d: Dict[str, Any] = {"op": "call"}
+        if name:
+            d['name'] = name
+        if sid:
+            d['id'] = sid
+        if state is not None:
+            d['state'] = state
+        if goto is not None:
+            d['goto'] = goto
+        return d
+
+
+class CStateRuleBuilder:
+    def __init__(self, st: DarsState, key: str):
+        self.st = st
+        self.key = key
+
+    def _ensure(self):
+        if self.key not in self.st.rules:
+            self.st.rules[self.key] = {}
+        if 'mods' not in self.st.rules[self.key]:
+            self.st.rules[self.key]['mods'] = []
+
+    def inc(self, target: Any, prop: str = 'text', by: int = 1) -> 'CStateRuleBuilder':
+        self._ensure()
+        self.st.rules[self.key]['mods'].append(Mod.inc(target, prop, by))
+        if self.st._bootstrap_ref is not None:
+            self.st._bootstrap_ref.setdefault('rules', {})
+            self.st._bootstrap_ref['rules'][self.key] = self.st.rules[self.key]
+        return self
+
+    def dec(self, target: Any, prop: str = 'text', by: int = 1) -> 'CStateRuleBuilder':
+        self._ensure()
+        self.st.rules[self.key]['mods'].append(Mod.dec(target, prop, by))
+        if self.st._bootstrap_ref is not None:
+            self.st._bootstrap_ref.setdefault('rules', {})
+            self.st._bootstrap_ref['rules'][self.key] = self.st.rules[self.key]
+        return self
+
+    def set(self, target: Any, **attrs) -> 'CStateRuleBuilder':
+        self._ensure()
+        self.st.rules[self.key]['mods'].append(Mod.set(target, **attrs))
+        if self.st._bootstrap_ref is not None:
+            self.st._bootstrap_ref.setdefault('rules', {})
+            self.st._bootstrap_ref['rules'][self.key] = self.st.rules[self.key]
+        return self
+
+    def toggle_class(self, target: Any, name: str, on: Optional[bool] = None) -> 'CStateRuleBuilder':
+        self._ensure()
+        self.st.rules[self.key]['mods'].append(Mod.toggle_class(target, name, on))
+        if self.st._bootstrap_ref is not None:
+            self.st._bootstrap_ref.setdefault('rules', {})
+            self.st._bootstrap_ref['rules'][self.key] = self.st.rules[self.key]
+        return self
+
+    def append_text(self, target: Any, value: str) -> 'CStateRuleBuilder':
+        self._ensure()
+        self.st.rules[self.key]['mods'].append(Mod.append_text(target, value))
+        if self.st._bootstrap_ref is not None:
+            self.st._bootstrap_ref.setdefault('rules', {})
+            self.st._bootstrap_ref['rules'][self.key] = self.st.rules[self.key]
+        return self
+
+    def prepend_text(self, target: Any, value: str) -> 'CStateRuleBuilder':
+        self._ensure()
+        self.st.rules[self.key]['mods'].append(Mod.prepend_text(target, value))
+        if self.st._bootstrap_ref is not None:
+            self.st._bootstrap_ref.setdefault('rules', {})
+            self.st._bootstrap_ref['rules'][self.key] = self.st.rules[self.key]
+        return self
+
+    def call(self, target: Any, state: Any = None, goto: Any = None) -> 'CStateRuleBuilder':
+        """Append a cross-state call op to this rule."""
+        self._ensure()
+        self.st.rules[self.key]['mods'].append(Mod.call(target, state=state, goto=goto))
+        if self.st._bootstrap_ref is not None:
+            self.st._bootstrap_ref.setdefault('rules', {})
+            self.st._bootstrap_ref['rules'][self.key] = self.st.rules[self.key]
+        return self
+
+    def goto(self, value: Any) -> 'CStateRuleBuilder':
+        if self.key not in self.st.rules:
+            self.st.rules[self.key] = {}
+        self.st.rules[self.key]['goto'] = value
+        if self.st._bootstrap_ref is not None:
+            self.st._bootstrap_ref.setdefault('rules', {})
+            self.st._bootstrap_ref['rules'][self.key] = self.st.rules[self.key]
+        return self
+
+
+def dState(name: str, component: Any = None, id: Optional[str] = None, states: Optional[List[Any]] = None, is_custom: bool = False) -> DarsState:
+    """
+    Declare a state associated with a component or an element id.
+    - name: state name (unique enough per app).
+    - component: a Dars component instance; if provided and has .id, it is used.
+    - id: explicit target id when component is not provided.
+    - states: optional list of possible state values (metadata).
+    - is_custom: mark as custom component to indicate full HTML replace flows.
+
+    Returns a DarsState object (for ergonomics), and records the state
+    in a global bootstrap list consumed by the exporter.
+    """
+    target_id = None
+    try:
+        if component is not None and hasattr(component, 'id'):
+            target_id = getattr(component, 'id')
+    except Exception:
+        target_id = None
+    if not target_id:
+        target_id = id
+
+    st = DarsState(name=name, id=target_id, states=states, is_custom=is_custom)
+    try:
+        d = st.to_dict()
+        STATE_BOOTSTRAP.append(d)
+        st._bootstrap_ref = d
+    except Exception:
+        pass
+    return st

dars/dars_tests/apps_test/health_check.py

@@ -0,0 +1,56 @@
+from dars.all import *
+
+app = App(title="Dars-HealthCheck", theme="dark")
+# Crear componentes
+container = Container(
+    Text(
+        text="Dars Health Check",
+        style={
+            'font-size': '48px',
+            'color': '#2c3e50',
+            'margin-bottom': '20px',
+            'font-weight': 'bold',
+            'text-align': 'center'
+        }
+    ),
+    Text(
+        text="Dars Health Check",
+        style={
+            'font-size': '20px',
+            'color': '#7f8c8d',
+            'margin-bottom': '40px',
+            'text-align': 'center'
+        }
+    ),
+
+    Button(
+        text="Check",
+        on_click= dScript("""alert('Health Check')"""),
+        on_mouse_enter=dScript("""this.style.backgroundColor = '#2980b9';"""),
+        on_mouse_leave=dScript("""this.style.backgroundColor = '#3498db';"""),
+        style={
+            'background-color': '#3498db',
+            'color': 'white',
+            'padding': '15px 30px',
+            'border': 'none',
+            'border-radius': '8px',
+            'font-size': '18px',
+            'cursor': 'pointer',
+            'transition': 'background-color 0.3s'
+        }
+    ),
+    style={
+        'display': 'flex',
+        'flex-direction': 'column',
+        'align-items': 'center',
+        'justify-content': 'center',
+        'min-height': '100vh',
+        'background-color': '#f0f2f5',
+        'font-family': 'Arial, sans-serif'
+    }
+) 
+
+app.set_root(container)
+
+if __name__ == "__main__":
+    app.rTimeCompile()

dars/dars_tests/run_tests.py

@@ -0,0 +1,275 @@
+# Runner that executes the test files and prints a colored report using rich
+import runpy, glob, importlib.util, os, sys, traceback, subprocess, time, threading
+import requests
+import signal
+import webbrowser
+import shutil
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+console = Console()
+
+def run_unit_tests(unit_test_paths=None):
+    """Run unit test files, optionally from specific paths"""
+    if unit_test_paths is None:
+        # Default behavior: run all tests in tests directory
+        tests = sorted(glob.glob(os.path.join(os.path.dirname(__file__), 'tests', 'test_*.py')))
+    else:
+        # Use provided test paths
+        tests = unit_test_paths
+    
+    results = []
+    for t in tests:
+        name = os.path.basename(t)
+        try:
+            console.print(Panel(f'Running {name}', style='cyan'))
+            ns = runpy.run_path(t, run_name='__main__')
+            results.append((name, True, None))
+            console.print(f'[green]PASS[/green] {name}')
+        except Exception as e:
+            results.append((name, False, traceback.format_exc()))
+            console.print(f'[red]FAIL[/red] {name}')
+            console.print(traceback.format_exc())
+    return results
+
+def check_server(port=8000, timeout=10):
+    """Check if the server is running on the given port"""
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        try:
+            response = requests.get(f'http://localhost:{port}', timeout=2)
+            if response.status_code < 500:
+                return True
+        except requests.exceptions.RequestException:
+            time.sleep(0.5)
+    return False
+
+def run_app_with_timeout(app_file, timeout=15):
+    """Run a Dars app with rTimeCompile and capture its output with a timeout"""
+    try:
+        env = os.environ.copy()
+        env['PYTHONIOENCODING'] = 'utf-8'
+
+        process = subprocess.Popen(
+            [sys.executable, app_file],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=os.path.dirname(app_file) or None,  # evita cwd = "" en Windows
+            env=env,
+        )
+        
+        # Esperar a que el servidor se inicie o timeout
+        server_started = False
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            if check_server(8000, 2):
+                server_started = True
+                break
+            # Verificar si el proceso ha terminado (lo que indicaría un error)
+            if process.poll() is not None:
+                break
+            time.sleep(1)
+        
+        # Recoger la salida (aunque no haya terminado, para capturar errores iniciales)
+        try:
+            stdout, stderr = process.communicate(timeout=2)
+        except subprocess.TimeoutExpired:
+            stdout, stderr = b"", b""
+        
+        stdout_str = stdout.decode('utf-8', errors='replace') if stdout else ''
+        stderr_str = stderr.decode('utf-8', errors='replace') if stderr else ''
+        
+        return {
+            'success': server_started,
+            'process': process,
+            'stdout': stdout_str,
+            'stderr': stderr_str
+        }
+        
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e),
+            'stdout': '',
+            'stderr': ''
+        }
+
+
+def safe_read_file(file_path):
+    """Leer un archivo de forma segura manejando diferentes codificaciones"""
+    encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+    
+    for encoding in encodings:
+        try:
+            with open(file_path, 'r', encoding=encoding) as f:
+                return f.read()
+        except UnicodeDecodeError:
+            continue
+    
+    # Si todas las codificaciones fallan, usar modo binario con reemplazo de errores
+    with open(file_path, 'rb') as f:
+        return f.read().decode('utf-8', errors='replace')
+
+def run_app_tests(app_test_paths=None):
+    """Run Dars application tests that use rTimeCompile, optionally from specific paths"""
+    if app_test_paths is None:
+        # Default behavior: run all apps in apps_test directory
+        apps_test_dir = os.path.join(os.path.dirname(__file__), 'apps_test')
+        if not os.path.exists(apps_test_dir):
+            console.print(f"[yellow]apps_test directory not found: {apps_test_dir}[/yellow]")
+            return []
+        
+        apps = sorted(glob.glob(os.path.join(apps_test_dir, '*.py')))
+    else:
+        # Use provided app paths
+        apps = app_test_paths
+    
+    results = []
+    
+    for app_file in apps:
+        name = os.path.basename(app_file)
+        try:
+            console.print(Panel(f'Testing Dars App: {name}', style='magenta'))
+            
+            # Verificar si la aplicación usa rTimeCompile de forma segura
+            content = safe_read_file(app_file)
+            uses_rTimeCompile = 'rTimeCompile' in content
+            
+            if not uses_rTimeCompile:
+                console.print(f"[yellow]Skipping {name} - does not use rTimeCompile[/yellow]")
+                continue
+            
+            # Ejecutar la aplicación con timeout
+            result = run_app_with_timeout(app_file, timeout=20)
+            
+            if result['success']:
+                # Éxito: el servidor se inició correctamente
+                results.append((name, True, "App started server successfully on port 8000"))
+                console.print(f'[green]PASS[/green] {name}')
+                
+                # Abrir el navegador para verificación visual
+                console.print("[green]Opening browser for visual verification...[/green]")
+                webbrowser.open('http://localhost:8000')
+                
+                # Preguntar al usuario si quiere terminar el proceso
+                console.print("\n[bold]Please verify the application in your browser.[/bold]")
+                console.print("After verification, you can:")
+                console.print("1. Press 'y' to terminate the process and continue with tests")
+                console.print("2. Press 'n' to keep the server running and continue")
+                
+                response = Prompt.ask("\nTerminate process and continue?", choices=["y", "n"], default="y")
+                
+                if response.lower() == "y":
+                    # Terminar el proceso
+                    if 'process' in result and result['process'].poll() is None:
+                        console.print("[yellow]Terminating app process...[/yellow]")
+                        try:
+                            # Enviar señal de interrupción (equivalente a Ctrl+C)
+                            if os.name == 'nt':  # Windows
+                                result['process'].terminate()
+                            else:  # Unix
+                                result['process'].send_signal(signal.SIGINT)
+                            
+                            # Esperar a que termine
+                            result['process'].wait(timeout=10)
+                            console.print("[green]App process terminated successfully[/green]")
+                            
+                            # Limpiar carpeta dars_preview
+                            preview_dir = os.path.join(os.path.dirname(app_file), "dars_preview")
+                            if os.path.exists(preview_dir):
+                                shutil.rmtree(preview_dir)
+                                console.print("[green]Preview directory cleaned up[/green]")
+                                
+                        except:
+                            console.print("[red]Force killing app process...[/red]")
+                            result['process'].kill()
+                else:
+                    console.print("[yellow]Keeping server running...[/yellow]")
+            else:
+                # Fallo: el servidor no se inició
+                error_msg = result['stderr'] or result['stdout'] or "Unknown error"
+                results.append((name, False, error_msg))
+                console.print(f'[red]FAIL[/red] {name}: {error_msg}')
+            
+            # Terminar el proceso si todavía está ejecutándose (solo si no elegimos mantenerlo)
+            if 'process' in result and result['process'].poll() is None:
+                console.print("[yellow]Terminating app process...[/yellow]")
+                try:
+                    # Enviar señal de interrupción (equivalente a Ctrl+C)
+                    if os.name == 'nt':  # Windows
+                        result['process'].terminate()
+                    else:  # Unix
+                        result['process'].send_signal(signal.SIGINT)
+                    
+                    # Esperar a que termine
+                    result['process'].wait(timeout=10)
+                    console.print("[green]App process terminated successfully[/green]")
+                    
+                    # Limpiar carpeta dars_preview
+                    preview_dir = os.path.join(os.path.dirname(app_file), "dars_preview")
+                    if os.path.exists(preview_dir):
+                        shutil.rmtree(preview_dir)
+                        console.print("[green]Preview directory cleaned up[/green]")
+                        
+                except:
+                    console.print("[red]Force killing app process...[/red]")
+                    result['process'].kill()
+                    
+        except Exception as e:
+            results.append((name, False, str(e)))
+            console.print(f'[red]FAIL[/red] {name}: {e}')
+    
+    return results
+
+def main(unit_test_paths=None, app_test_paths=None):
+    """
+    Run Dars test suite with optional specific test paths
+    
+    Args:
+        unit_test_paths (list): Optional list of paths to unit test files
+        app_test_paths (list): Optional list of paths to application test files
+    """
+    # Run unit tests
+    console.print(Panel("Running Unit Tests", style="cyan"))
+    unit_results = run_unit_tests(unit_test_paths)
+    
+    # Run app tests
+    console.print(Panel("Running App Tests (rTimeCompile)", style="magenta"))
+    app_results = run_app_tests(app_test_paths)
+    
+    # Combine results
+    all_results = unit_results + app_results
+    
+    # Print results table
+    table = Table(title='Dars Test Suite Results')
+    table.add_column('Test File')
+    table.add_column('Result')
+    table.add_column('Details', overflow='fold')
+    
+    for name, ok, details in all_results:
+        table.add_row(name, '[green]PASS[/green]' if ok else '[red]FAIL[/red]', details or '')
+    
+    console.print(table)
+    
+    # Exit code
+    any_fail = any(not ok for _, ok, _ in all_results)
+    if any_fail:
+        console.print('[bold red]Some tests failed.[/bold red]')
+        sys.exit(1)
+    else:
+        console.print('[bold green]All tests passed.[/bold green]')
+
+if __name__ == '__main__':
+    # Parse command line arguments for custom test paths
+    import argparse
+    parser = argparse.ArgumentParser(description='Run Dars Framework tests')
+    parser.add_argument('--unit-tests', nargs='+', help='Paths to specific unit test files')
+    parser.add_argument('--app-tests', nargs='+', help='Paths to specific application test files')
+    
+    args = parser.parse_args()
+    
+    # Run tests with optional paths
+    main(unit_test_paths=args.unit_tests, app_test_paths=args.app_tests)