dars-framework 1.0.0__py3-none-any.whl

dars/components/basic/checkbox.py

@@ -0,0 +1,34 @@
+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 Checkbox(Component):
+    def __init__(
+        self,
+        label: str = "",
+        checked: bool = False,
+        value: str = "",
+        name: Optional[str] = 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
+    ):
+        super().__init__(id=id, class_name=class_name, style=style)
+        self.label = label
+        self.checked = checked
+        self.value = value or label  # Si no se proporciona value, usar label
+        self.name = name
+        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/container.py

@@ -0,0 +1,23 @@
+from dars.core.component import Component
+from dars.core.properties import StyleProps
+from typing import Optional, Union, Dict, Any, List
+
+class Container(Component):
+    def __init__(
+        self, 
+        id: Optional[str] = None, 
+        class_name: Optional[str] = None, 
+        style: Optional[Dict[str, Any]] = None,
+        children: Optional[List[Component]] = None
+    ):
+        super().__init__(id=id, class_name=class_name, style=style)
+        
+        # Agregar hijos si se proporcionan
+        if children:
+            for child in children:
+                self.add_child(child)
+
+    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/datepicker.py

@@ -0,0 +1,139 @@
+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
+from datetime import datetime, date
+
+class DatePicker(Component):
+    def __init__(
+        self,
+        value: Optional[Union[str, date, datetime]] = None,
+        min_date: Optional[Union[str, date, datetime]] = None,
+        max_date: Optional[Union[str, date, datetime]] = None,
+        placeholder: str = "Seleccionar fecha",
+        format: str = "YYYY-MM-DD",  # Formato de fecha
+        locale: str = "es",  # Idioma para el picker
+        show_time: bool = False,  # Si incluir selector de tiempo
+        inline: bool = False,  # Si mostrar inline o como popup
+        disabled_dates: Optional[list] = None,  # Fechas deshabilitadas
+        id: Optional[str] = None,
+        class_name: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+        disabled: bool = False,
+        required: bool = False,
+        readonly: bool = False,
+        on_change: Optional[Callable] = None,
+        on_open: Optional[Callable] = None,
+        on_close: Optional[Callable] = None
+    ):
+        super().__init__(id=id, class_name=class_name, style=style)
+        
+        # Asignar atributos básicos primero
+        self.placeholder = placeholder
+        self.format = format
+        self.locale = locale
+        self.show_time = show_time
+        self.inline = inline
+        self.disabled_dates = disabled_dates or []
+        self.disabled = disabled
+        self.required = required
+        self.readonly = readonly
+        
+        # Validar formato
+        valid_formats = ["YYYY-MM-DD", "DD/MM/YYYY", "MM/DD/YYYY", "DD-MM-YYYY"]
+        if format not in valid_formats:
+            raise ValueError(f"format debe ser uno de: {valid_formats}")
+        
+        # Validar locale
+        valid_locales = ["es", "en", "fr", "de", "it", "pt"]
+        if locale not in valid_locales:
+            raise ValueError(f"locale debe ser uno de: {valid_locales}")
+        
+        # Ahora procesar las fechas (después de asignar self.format)
+        self.value = self._process_date(value)
+        self.min_date = self._process_date(min_date)
+        self.max_date = self._process_date(max_date)
+        
+        # Registrar eventos si se proporcionan
+        if on_change:
+            self.set_event(EventTypes.CHANGE, on_change)
+        if on_open:
+            self.set_event("open", on_open)
+        if on_close:
+            self.set_event("close", on_close)
+    
+    def _process_date(self, date_value: Optional[Union[str, date, datetime]]) -> Optional[str]:
+        """Procesa y normaliza el valor de fecha"""
+        if date_value is None:
+            return None
+        
+        if isinstance(date_value, str):
+            # Validar formato de string de fecha
+            try:
+                # Intentar parsear la fecha para validarla
+                if self.format == "YYYY-MM-DD":
+                    datetime.strptime(date_value, "%Y-%m-%d")
+                elif self.format == "DD/MM/YYYY":
+                    datetime.strptime(date_value, "%d/%m/%Y")
+                elif self.format == "MM/DD/YYYY":
+                    datetime.strptime(date_value, "%m/%d/%Y")
+                elif self.format == "DD-MM-YYYY":
+                    datetime.strptime(date_value, "%d-%m-%Y")
+                return date_value
+            except ValueError:
+                raise ValueError(f"Formato de fecha inválido: {date_value}")
+        
+        elif isinstance(date_value, (date, datetime)):
+            # Convertir objeto date/datetime a string según el formato
+            if self.format == "YYYY-MM-DD":
+                return date_value.strftime("%Y-%m-%d")
+            elif self.format == "DD/MM/YYYY":
+                return date_value.strftime("%d/%m/%Y")
+            elif self.format == "MM/DD/YYYY":
+                return date_value.strftime("%m/%d/%Y")
+            elif self.format == "DD-MM-YYYY":
+                return date_value.strftime("%d-%m-%Y")
+        
+        return str(date_value)
+    
+    def set_value(self, value: Union[str, date, datetime]):
+        """Establece el valor de la fecha"""
+        self.value = self._process_date(value)
+    
+    def get_date_object(self) -> Optional[datetime]:
+        """Obtiene el valor como objeto datetime"""
+        if not self.value:
+            return None
+        
+        try:
+            if self.format == "YYYY-MM-DD":
+                return datetime.strptime(self.value, "%Y-%m-%d")
+            elif self.format == "DD/MM/YYYY":
+                return datetime.strptime(self.value, "%d/%m/%Y")
+            elif self.format == "MM/DD/YYYY":
+                return datetime.strptime(self.value, "%m/%d/%Y")
+            elif self.format == "DD-MM-YYYY":
+                return datetime.strptime(self.value, "%d-%m-%Y")
+        except ValueError:
+            return None
+    
+    def is_date_disabled(self, date_to_check: Union[str, date, datetime]) -> bool:
+        """Verifica si una fecha está deshabilitada"""
+        check_date = self._process_date(date_to_check)
+        return check_date in self.disabled_dates
+    
+    def add_disabled_date(self, date_to_disable: Union[str, date, datetime]):
+        """Añade una fecha a la lista de fechas deshabilitadas"""
+        disabled_date = self._process_date(date_to_disable)
+        if disabled_date and disabled_date not in self.disabled_dates:
+            self.disabled_dates.append(disabled_date)
+    
+    def remove_disabled_date(self, date_to_enable: Union[str, date, datetime]):
+        """Elimina una fecha de la lista de fechas deshabilitadas"""
+        enabled_date = self._process_date(date_to_enable)
+        if enabled_date in self.disabled_dates:
+            self.disabled_dates.remove(enabled_date)
+
+    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/image.py

@@ -0,0 +1,36 @@
+from dars.core.component import Component
+from typing import Optional, Dict, Any
+
+class Image(Component):
+    """Componente para mostrar imágenes."""
+    def __init__(
+        self,
+        src: str,
+        alt: str = "",
+        width: Optional[str] = None,
+        height: Optional[str] = None,
+        class_name: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ):
+        super().__init__(class_name=class_name, style=style, **kwargs)
+        self.src = src
+        self.alt = alt
+        self.width = width
+        self.height = height
+
+    def render(self) -> str:
+        attrs = [
+            f'src="{self.src}"',
+            f'alt="{self.alt}"',
+        ]
+        if self.width: attrs.append(f'width="{self.width}"')
+        if self.height: attrs.append(f'height="{self.height}"')
+        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'<img {" ".join(attrs)} />'
+
+
+
+

dars/components/basic/input.py

@@ -0,0 +1,50 @@
+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 Input(Component):
+    def __init__(
+        self, 
+        value: str = "", 
+        placeholder: str = "",
+        input_type: str = "text",  # "text", "password", "email", "number", etc.
+        id: Optional[str] = None, 
+        class_name: Optional[str] = None, 
+        style: Optional[Dict[str, Any]] = None,
+        disabled: bool = False,
+        readonly: bool = False,
+        required: bool = False,
+        max_length: Optional[int] = None,
+        min_length: Optional[int] = None,
+        pattern: Optional[str] = None,
+        on_change: Optional[Callable] = None,
+        on_input: Optional[Callable] = None,
+        on_focus: Optional[Callable] = None,
+        on_blur: Optional[Callable] = None
+    ):
+        super().__init__(id=id, class_name=class_name, style=style)
+        self.value = value
+        self.placeholder = placeholder
+        self.input_type = input_type
+        self.disabled = disabled
+        self.readonly = readonly
+        self.required = required
+        self.max_length = max_length
+        self.min_length = min_length
+        self.pattern = pattern
+        
+        # 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)
+        if on_focus:
+            self.set_event(EventTypes.FOCUS, on_focus)
+        if on_blur:
+            self.set_event(EventTypes.BLUR, on_blur)
+
+    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/link.py

@@ -0,0 +1,31 @@
+from dars.core.component import Component
+from typing import Optional, Dict, Any
+
+class Link(Component):
+    """Componente para crear enlaces."""
+    def __init__(
+        self,
+        text: str,
+        href: str,
+        target: str = "_self",
+        class_name: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ):
+        super().__init__(class_name=class_name, style=style, **kwargs)
+        self.text = text
+        self.href = href
+        self.target = target
+
+    def render(self) -> str:
+        attrs = [
+            f'href="{self.href}"',
+            f'target="{self.target}"',
+        ]
+        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'<a {" ".join(attrs)}>{self.text}</a>'
+
+
+

dars/components/basic/page.py

@@ -0,0 +1,20 @@
+from dars.core.component import Component
+from typing import Optional, Dict, Any, List
+
+class Page(Component):
+    """Componente raíz para páginas en apps multipágina Dars. Permite pasar hijos como argumentos posicionales y scripts por página."""
+    def __init__(self, *children: Component, id: Optional[str] = None, class_name: Optional[str] = None, style: Optional[Dict[str, Any]] = None):
+        super().__init__(id=id, class_name=class_name, style=style)
+        self.scripts = []
+        for child in children:
+            self.add_child(child)
+
+    def add_script(self, script):
+        self.scripts.append(script)
+
+    def get_scripts(self):
+        return self.scripts
+
+    def render(self, exporter: Any) -> str:
+        # El método render será implementado por el exporter
+        raise NotImplementedError("El método render debe ser implementado por el exporter")

dars/components/basic/progressbar.py

@@ -0,0 +1,17 @@
+from dars.core.component import Component
+from typing import Optional
+
+class ProgressBar(Component):
+    """
+    Barra de progreso visual.
+    value: valor actual (0-100)
+    max_value: valor máximo (default 100)
+    """
+    def __init__(self, value: int, max_value: int = 100, **props):
+        super().__init__(**props)
+        self.value = value
+        self.max_value = max_value
+
+    def render(self) -> str:
+        percent = min(max(self.value / self.max_value * 100, 0), 100)
+        return f'<div class="dars-progressbar"><div class="dars-progressbar-bar" style="width: {percent}%;"></div></div>'

dars/components/basic/radiobutton.py

@@ -0,0 +1,34 @@
+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
+    ):
+        super().__init__(id=id, class_name=class_name, style=style)
+        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,81 @@
+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:
+    """Clase para representar una opción del select"""
+    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
+    ):
+        super().__init__(id=id, class_name=class_name, style=style)
+        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,11 @@
+from dars.core.component import Component
+
+class Spinner(Component):
+    """
+    Indicador de carga circular (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,22 @@
+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
+    ):
+        super().__init__(id=id, class_name=class_name, style=style)
+        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):
+    """Componente para áreas de texto multilínea."""
+    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,18 @@
+from dars.core.component import Component
+from typing import Optional
+
+class Tooltip(Component):
+    """
+    Tooltip: cuadro de información al pasar el cursor.
+    text: texto a mostrar
+    child: componente o HTML envuelto
+    position: top, right, bottom, left (opcional)
+    """
+    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})"