dars-framework 1.2.3__py3-none-any.whl

dars/components/basic/radiobutton.py

@@ -0,0 +1,35 @@
+from dars.core.component import Component
+from dars.core.properties import StyleProps
+from dars.core.events import EventTypes
+from typing import Optional, Union, Dict, Any, Callable
+
+class RadioButton(Component):
+    def __init__(
+        self,
+        label: str = "",
+        value: str = "",
+        name: str = "radio_group",
+        checked: bool = False,
+        id: Optional[str] = None,
+        class_name: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+        disabled: bool = False,
+        required: bool = False,
+        on_change: Optional[Callable] = None,
+        **props
+    ):
+        super().__init__(id=id, class_name=class_name, style=style, **props)
+        self.label = label
+        self.value = value or label  # Si no se proporciona value, usar label
+        self.name = name  # Requerido para agrupar radio buttons
+        self.checked = checked
+        self.disabled = disabled
+        self.required = required
+        
+        # Registrar evento de cambio si se proporciona
+        if on_change:
+            self.set_event(EventTypes.CHANGE, on_change)
+
+    def render(self, exporter: Any) -> str:
+        # El método render será implementado por cada exportador
+        raise NotImplementedError("El método render debe ser implementado por el exportador")

dars/components/basic/select.py

@@ -0,0 +1,82 @@
+from dars.core.component import Component
+from dars.core.properties import StyleProps
+from dars.core.events import EventTypes
+from typing import Optional, Union, Dict, Any, Callable, List
+
+class SelectOption:
+    """Class to represent a select option"""
+    def __init__(self, value: str, label: str, disabled: bool = False):
+        self.value = value
+        self.label = label
+        self.disabled = disabled
+
+class Select(Component):
+    def __init__(
+        self,
+        options: List[Union[SelectOption, Dict[str, Any], str]] = None,
+        value: Optional[str] = None,
+        placeholder: str = "Seleccionar...",
+        multiple: bool = False,
+        size: Optional[int] = None,
+        id: Optional[str] = None,
+        class_name: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+        disabled: bool = False,
+        required: bool = False,
+        on_change: Optional[Callable] = None,
+        **props
+    ):
+        super().__init__(id=id, class_name=class_name, style=style, **props)
+        self.options = self._process_options(options or [])
+        self.value = value
+        self.placeholder = placeholder
+        self.multiple = multiple
+        self.size = size  # Número de opciones visibles (para select múltiple)
+        self.disabled = disabled
+        self.required = required
+        
+        # Registrar evento de cambio si se proporciona
+        if on_change:
+            self.set_event(EventTypes.CHANGE, on_change)
+    
+    def _process_options(self, options: List[Union[SelectOption, Dict[str, Any], str]]) -> List[SelectOption]:
+        """Procesa las opciones y las convierte a objetos SelectOption"""
+        processed_options = []
+        
+        for option in options:
+            if isinstance(option, SelectOption):
+                processed_options.append(option)
+            elif isinstance(option, dict):
+                processed_options.append(SelectOption(
+                    value=option.get('value', ''),
+                    label=option.get('label', option.get('value', '')),
+                    disabled=option.get('disabled', False)
+                ))
+            elif isinstance(option, str):
+                processed_options.append(SelectOption(value=option, label=option))
+        
+        return processed_options
+    
+    def add_option(self, value: str, label: str = None, disabled: bool = False):
+        """Añade una nueva opción al select"""
+        self.options.append(SelectOption(
+            value=value,
+            label=label or value,
+            disabled=disabled
+        ))
+    
+    def remove_option(self, value: str):
+        """Elimina una opción por su valor"""
+        self.options = [opt for opt in self.options if opt.value != value]
+    
+    def get_selected_option(self) -> Optional[SelectOption]:
+        """Obtiene la opción seleccionada actualmente"""
+        if self.value:
+            for option in self.options:
+                if option.value == self.value:
+                    return option
+        return None
+
+    def render(self, exporter: Any) -> str:
+        # El método render será implementado por cada exportador
+        raise NotImplementedError("El método render debe ser implementado por el exportador")

dars/components/basic/slider.py

@@ -0,0 +1,63 @@
+from dars.core.component import Component
+from dars.core.properties import StyleProps
+from dars.core.events import EventTypes
+from typing import Optional, Union, Dict, Any, Callable
+
+class Slider(Component):
+    def __init__(
+        self,
+        min_value: Union[int, float] = 0,
+        max_value: Union[int, float] = 100,
+        value: Union[int, float] = 50,
+        step: Union[int, float] = 1,
+        label: str = "",
+        show_value: bool = True,
+        orientation: str = "horizontal",  # "horizontal" o "vertical"
+        id: Optional[str] = None,
+        class_name: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+        disabled: bool = False,
+        on_change: Optional[Callable] = None,
+        on_input: Optional[Callable] = None
+    ):
+        super().__init__(id=id, class_name=class_name, style=style)
+        self.min_value = min_value
+        self.max_value = max_value
+        self.value = max(min_value, min(max_value, value))  # Asegurar que esté en rango
+        self.step = step
+        self.label = label
+        self.show_value = show_value
+        self.orientation = orientation
+        self.disabled = disabled
+        
+        # Validar orientación
+        if orientation not in ["horizontal", "vertical"]:
+            raise ValueError("orientation debe ser 'horizontal' o 'vertical'")
+        
+        # Registrar eventos si se proporcionan
+        if on_change:
+            self.set_event(EventTypes.CHANGE, on_change)
+        if on_input:
+            self.set_event(EventTypes.INPUT, on_input)
+    
+    def set_value(self, value: Union[int, float]):
+        """Establece el valor del slider asegurando que esté en rango"""
+        self.value = max(self.min_value, min(self.max_value, value))
+    
+    def get_percentage(self) -> float:
+        """Obtiene el porcentaje actual del slider (0-100)"""
+        if self.max_value == self.min_value:
+            return 0
+        return ((self.value - self.min_value) / (self.max_value - self.min_value)) * 100
+    
+    def is_at_min(self) -> bool:
+        """Verifica si el slider está en su valor mínimo"""
+        return self.value == self.min_value
+    
+    def is_at_max(self) -> bool:
+        """Verifica si el slider está en su valor máximo"""
+        return self.value == self.max_value
+
+    def render(self, exporter: Any) -> str:
+        # El método render será implementado por cada exportador
+        raise NotImplementedError("El método render debe ser implementado por el exportador")

dars/components/basic/spinner.py

@@ -0,0 +1,12 @@
+from dars.core.component import Component
+
+class Spinner(Component):
+    """
+    Circular loading indicator (spinner).
+    """
+
+    def __init__(self, **props):
+        super().__init__(**props)
+
+    def render(self) -> str:
+        return '<div class="dars-spinner"></div>'

dars/components/basic/text.py

@@ -0,0 +1,23 @@
+from dars.core.component import Component
+from dars.core.properties import StyleProps
+from typing import Optional, Union, Dict, Any
+
+class Text(Component):
+    def __init__(
+        self, 
+        text: str = "", 
+        id: Optional[str] = None, 
+        class_name: Optional[str] = None, 
+        style: Optional[Dict[str, Any]] = None,
+        **props
+    ):
+        super().__init__(id=id, class_name=class_name, style=style, **props)
+        self.text = text
+
+    def render(self, exporter: Any) -> str:
+        # El método render será implementado por cada exportador
+        # para generar el código específico de la plataforma.
+        # Por ahora, solo definimos la interfaz.
+        raise NotImplementedError("El método render debe ser implementado por el exportador")
+
+

dars/components/basic/textarea.py

@@ -0,0 +1,46 @@
+from dars.core.component import Component
+from typing import Optional, Dict, Any
+
+class Textarea(Component):
+    """Component for multiline text areas."""
+    def __init__(
+        self,
+        value: str = "",
+        placeholder: str = "",
+        rows: int = 4,
+        cols: int = 50,
+        disabled: bool = False,
+        readonly: bool = False,
+        required: bool = False,
+        max_length: Optional[int] = None,
+        class_name: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ):
+        super().__init__(class_name=class_name, style=style, **kwargs)
+        self.value = value
+        self.placeholder = placeholder
+        self.rows = rows
+        self.cols = cols
+        self.disabled = disabled
+        self.readonly = readonly
+        self.required = required
+        self.max_length = max_length
+
+    def render(self) -> str:
+        attrs = [
+            f'rows="{self.rows}"',
+            f'cols="{self.cols}"',
+        ]
+        if self.placeholder: attrs.append(f'placeholder="{self.placeholder}"')
+        if self.disabled: attrs.append('disabled')
+        if self.readonly: attrs.append('readonly')
+        if self.required: attrs.append('required')
+        if self.max_length: attrs.append(f'maxlength="{self.max_length}"')
+        if self.class_name: attrs.append(f'class="{self.class_name}"')
+        if self.style: attrs.append(f'style="{self.render_styles(self.style)}"')
+        
+        return f'<textarea {" ".join(attrs)}>{self.value}</textarea>'
+
+
+

dars/components/basic/tooltip.py

@@ -0,0 +1,19 @@
+from dars.core.component import Component
+from typing import Optional
+
+class Tooltip(Component):
+    """
+    Tooltip: information box on hover.
+    text: text to display
+    child: wrapped component or HTML
+    position: top, right, bottom, left (optional)
+    """
+
+    def __init__(self, text: str, child: Component, position: Optional[str] = "top", **props):
+        super().__init__(**props)
+        self.text = text
+        self.child = child
+        self.position = position
+
+    def render(self) -> str:
+        return f'<div class="dars-tooltip dars-tooltip-{self.position}">{self.child.render() if hasattr(self.child, "render") else self.child}<span class="dars-tooltip-text">{self.text}</span></div>'

dars/components/layout/anchor.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+class AnchorPoint:
+    """
+    Represents an anchor or alignment point for a child in a layout (top, left, right, bottom, center, etc).
+    """
+    def __init__(self, x: Optional[str] = None, y: Optional[str] = None, name: Optional[str] = None):
+        self.x = x  # e.g. 'left', 'center', 'right', percent or px
+        self.y = y  # e.g. 'top', 'center', 'bottom', percent or px
+        self.name = name  # Optional semantic name for anchor
+
+    def __repr__(self):
+        return f"AnchorPoint(x={self.x}, y={self.y}, name={self.name})"

dars/components/layout/flex.py

@@ -0,0 +1,26 @@
+from dars.components.layout.grid import LayoutBase
+from typing import List, Optional
+
+class FlexLayout(LayoutBase):
+    """
+    Responsive flexbox layout component. Allows direction, wrap, justify, align, and anchor points for children.
+    """
+    def __init__(self, 
+                 children: Optional[List[object]] = None,
+                 direction: str = "row",
+                 wrap: str = "wrap",
+                 justify: str = "flex-start",
+                 align: str = "stretch",
+                 gap: str = "16px",
+                 anchors: Optional[dict] = None,
+                 **kwargs):
+        super().__init__(children=children, anchors=anchors, **kwargs)
+        self.direction = direction
+        self.wrap = wrap
+        self.justify = justify
+        self.align = align
+        self.gap = gap
+
+    def add_child(self, child, anchor: Optional[str] = None):
+        self.children.append(child)
+        # Could store anchor info per child if needed

dars/components/layout/grid.py

@@ -0,0 +1,45 @@
+from dars.core.component import Component
+from typing import List, Optional, Dict, Any
+
+class LayoutBase(Component):
+    """
+    Base class for all layout components. Allows adding children and anchor/positioning info.
+    """
+    def __init__(self, children: Optional[List[Component]] = None, anchors: Optional[Dict[str, Any]] = None, **kwargs):
+        super().__init__(**kwargs)
+        self.children = children or []
+        self.anchors = anchors or {}
+
+    def add_child(self, child: Component):
+        self.children.append(child)
+
+    def render(self, exporter=None):
+        # Layouts se renderizan solo por el exporter, pero se requiere para evitar TypeError
+        return ""
+
+class GridLayout(LayoutBase):
+    """
+    Responsive grid layout component. Supports rows/columns and anchor points for children.
+    """
+    def __init__(self, rows: int = 1, cols: int = 1, children: Optional[List[Component]] = None, anchors: Optional[Dict[str, Any]] = None, gap: str = "16px", **kwargs):
+        super().__init__(children=children, anchors=anchors, **kwargs)
+        self.rows = rows
+        self.cols = cols
+        self.gap = gap
+
+    def add_child(self, child: Component, row: int = 0, col: int = 0, row_span: int = 1, col_span: int = 1, anchor: Optional[str] = None):
+        # Store child with layout info
+        if not hasattr(self, '_child_layout'):
+            self._child_layout = []
+        self._child_layout.append({
+            'child': child,
+            'row': row,
+            'col': col,
+            'row_span': row_span,
+            'col_span': col_span,
+            'anchor': anchor
+        })
+        self.children.append(child)
+
+    def get_child_layout(self):
+        return getattr(self, '_child_layout', [])

dars/config.py

@@ -0,0 +1,134 @@
+import json
+import os
+from typing import Tuple, Dict, Any
+
+DEFAULT_CONFIG = {
+    "entry": "main.py",
+    "format": "html",
+    "outdir": "dist",
+    "publicDir": None,  # autodetect if None: prefers ./public then ./assets
+    "include": [],
+    "exclude": ["**/__pycache__", ".git", ".venv", "node_modules"],
+    "bundle": True,
+}
+
+CONFIG_FILENAME = "dars.config.json"
+
+
+def load_config(project_root: str) -> Tuple[Dict[str, Any], bool]:
+    """Load dars.config.json from project_root. Returns (config, found)."""
+    config_path = os.path.join(project_root, CONFIG_FILENAME)
+    if not os.path.isfile(config_path):
+        # Autodetect public dir if exists for convenience even without config
+        cfg = DEFAULT_CONFIG.copy()
+        if os.path.isdir(os.path.join(project_root, "public")):
+            cfg["publicDir"] = "public"
+        elif os.path.isdir(os.path.join(project_root, "assets")):
+            cfg["publicDir"] = "assets"
+        return cfg, False
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        cfg = DEFAULT_CONFIG.copy()
+        cfg.update({k: v for k, v in data.items() if v is not None})
+        return cfg, True
+    except Exception:
+        # On parse error, fallback to defaults but mark as not found to avoid enforcing
+        cfg = DEFAULT_CONFIG.copy()
+        return cfg, False
+
+
+def resolve_paths(cfg: Dict[str, Any], project_root: str) -> Dict[str, Any]:
+    """Return a copy of cfg with absolute resolved paths for entry, publicDir, outdir."""
+    out = dict(cfg)
+    if out.get("entry"):
+        out["entry_abs"] = os.path.join(project_root, out["entry"])
+    else:
+        out["entry_abs"] = None
+    if out.get("publicDir"):
+        out["public_abs"] = os.path.join(project_root, out["publicDir"])
+    else:
+        # If None, keep None; exporter may still auto-detect
+        out["public_abs"] = None
+    if out.get("outdir"):
+        out["outdir_abs"] = os.path.join(project_root, out["outdir"])
+    else:
+        out["outdir_abs"] = os.path.join(project_root, "dist")
+    return out
+
+
+def copy_public_dir(public_dir: str, dest_dir: str, include=None, exclude=None):
+    """Copy entire public_dir into dest_dir applying basic include/exclude filters.
+    Exclude supports substrings or glob-like simple matches; keep it simple to avoid heavy deps.
+    """
+    import shutil
+    from pathlib import Path
+
+    if not public_dir or not os.path.isdir(public_dir):
+        return
+
+    include = include or []
+    exclude = exclude or []
+
+    def is_excluded(path: Path) -> bool:
+        # Simple checks: substring or name matches
+        p_str = str(path)
+        for pat in exclude:
+            if pat in p_str:
+                return True
+        return False
+
+    def is_included(path: Path) -> bool:
+        if not include:
+            return True
+        p_str = str(path)
+        for pat in include:
+            if pat in p_str:
+                return True
+        return False
+
+    for root, dirs, files in os.walk(public_dir):
+        # filter excluded dirs in-place
+        dirs[:] = [d for d in dirs if not is_excluded(Path(root) / d)]
+        for f in files:
+            src_path = Path(root) / f
+            if is_excluded(src_path) or not is_included(src_path):
+                continue
+            rel = src_path.relative_to(public_dir)
+            dst_path = Path(dest_dir) / rel
+            os.makedirs(dst_path.parent, exist_ok=True)
+            try:
+                shutil.copy2(str(src_path), str(dst_path))
+            except Exception:
+                # Best-effort; ignore copy errors
+                pass
+
+
+def write_default_config(project_root: str, overwrite: bool = False) -> str:
+    """Create a dars.config.json with defaults if it doesn't exist (or overwrite=True).
+    Returns the path to the config file.
+    """
+    path = os.path.join(project_root, CONFIG_FILENAME)
+    if os.path.exists(path) and not overwrite:
+        return path
+    cfg = DEFAULT_CONFIG.copy()
+    # Prefer autodetected public dir as default
+    if os.path.isdir(os.path.join(project_root, "public")):
+        cfg["publicDir"] = "public"
+    elif os.path.isdir(os.path.join(project_root, "assets")):
+        cfg["publicDir"] = "assets"
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(cfg, f, indent=2)
+    return path
+
+
+def update_config(project_root: str, updates: Dict[str, Any]) -> str:
+    """Update or create config merging with defaults.
+    Returns the path to the config file.
+    """
+    cfg, _ = load_config(project_root)
+    cfg.update({k: v for k, v in updates.items() if v is not None})
+    path = os.path.join(project_root, CONFIG_FILENAME)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(cfg, f, indent=2)
+    return path