dars-framework 1.2.3__py3-none-any.whl

dars/components/advanced/navbar.py

@@ -0,0 +1,44 @@
+from dars.core.component import Component
+from typing import Optional, Dict, Any, List
+
+class Navbar(Component):
+    """Component to create navigation bars."""
+    def __init__(
+        self,
+        *children,
+        brand: Optional[str] = None,
+        class_name: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ):
+        # Compatibilidad retro: si 'children' está en kwargs, lo usamos; si no, usamos los posicionales
+        children_kwarg = kwargs.pop('children', None)
+        from dars.core.component import Component
+        if children_kwarg is not None:
+            children_final = children_kwarg
+        elif len(children) == 1 and isinstance(children[0], list):
+            children_final = children[0]
+        else:
+            children_final = list(children)
+        # Filtro: solo instancias válidas de Component
+        children_final = [c for c in children_final if isinstance(c, Component)]
+        super().__init__(class_name=class_name, style=style, **kwargs)
+        self.brand = brand
+        for child in children_final:
+            self.add_child(child)
+
+    def render(self) -> str:
+        brand_html = f'<div class="dars-navbar-brand">{self.brand}</div>' if self.brand else ''
+        children_html = ''.join([child.render() for child in self.children])
+        
+        attrs = []
+        if self.class_name: attrs.append(f'class="dars-navbar {self.class_name}"')
+        else: attrs.append('class="dars-navbar"')
+        
+        navbar_style = 'display: flex; justify-content: space-between; align-items: center; padding: 1rem; background-color: #f8f9fa; border-bottom: 1px solid #dee2e6'
+        if self.style:
+            navbar_style += f'; {self.render_styles(self.style)}'
+        attrs.append(f'style="{navbar_style}"')
+        
+        return f'<nav {" ".join(attrs)}>{brand_html}<div class="dars-navbar-nav">{children_html}</div></nav>'
+

dars/components/advanced/table.py

@@ -0,0 +1,25 @@
+from dars.core.component import Component
+from typing import List, Dict, Any, Optional
+
+class Table(Component):
+    """
+    Component to display tabular data with columns, data, pagination, sorting, and filtering.
+    columns: List of dictionaries with keys 'title', 'field', 'sortable', 'width', etc.
+    data: List of dictionaries (each one is a row)
+    page_size: Number of rows per page (optional)
+    """
+
+    def __init__(self, columns: List[Dict[str, Any]], data: List[Dict[str, Any]], page_size: Optional[int]=None, **props):
+        super().__init__(**props)
+        self.columns = columns
+        self.data = data
+        self.page_size = page_size
+
+    def render(self) -> str:
+        # Renderiza la tabla en HTML (solo vista simple, sin JS avanzado todavía)
+        thead = '<thead><tr>' + ''.join(f'<th>{col["title"]}</th>' for col in self.columns) + '</tr></thead>'
+        rows = self.data[:self.page_size] if self.page_size else self.data
+        tbody = '<tbody>' + ''.join(
+            '<tr>' + ''.join(f'<td>{row.get(col["field"], "")}</td>' for col in self.columns) + '</tr>'
+            for row in rows) + '</tbody>'
+        return f'<table class="dars-table">{thead}{tbody}</table>'

dars/components/advanced/tabs.py

@@ -0,0 +1,31 @@
+from dars.core.component import Component
+from typing import List, Optional
+
+class Tabs(Component):
+    """
+    Tab navigation component.
+    tabs: List of tab titles
+    panels: List of components or strings (content of each tab)
+    selected: Index of the active tab (optional)
+    """
+
+    def __init__(self, tabs: List[str], panels: List[Component], selected: Optional[int]=0, minimum_logic: bool = True, **props):
+        super().__init__(**props)
+        self.tabs = tabs
+        self.panels = panels
+        self.selected = selected or 0
+        self.minimum_logic = minimum_logic
+        for panel in panels:
+            if hasattr(panel, 'render'):
+                self.add_child(panel)
+
+    def render(self) -> str:
+        tab_headers = ''.join(
+            f'<button class="dars-tab{ " dars-tab-active" if i == self.selected else "" }" data-tab="{i}">{title}</button>'
+            for i, title in enumerate(self.tabs)
+        )
+        panels_html = ''.join(
+            f'<div class="dars-tab-panel{ " dars-tab-panel-active" if i == self.selected else "" }">{panel.render() if hasattr(panel, "render") else panel}</div>'
+            for i, panel in enumerate(self.panels)
+        )
+        return f'<div class="dars-tabs"><div class="dars-tabs-header">{tab_headers}</div><div class="dars-tabs-panels">{panels_html}</div></div>'

dars/components/basic/__init__.py

@@ -0,0 +1,34 @@
+from .text import Text
+from .button import Button
+from .input import Input
+from .container import Container
+from .page import Page
+from .image import Image
+from .link import Link
+from .textarea import Textarea
+from .checkbox import Checkbox
+from .radiobutton import RadioButton
+from .select import Select, SelectOption
+from .slider import Slider
+from .datepicker import DatePicker
+
+from .progressbar import ProgressBar
+from .spinner import Spinner
+from .tooltip import Tooltip
+
+__all__ = [
+    'Text',
+    'Button', 
+    'Input',
+    'Container',
+    'Page',
+    'Image',
+    'Link',
+    'Textarea',
+    'Checkbox',
+    'RadioButton',
+    'Select',
+    'SelectOption',
+    'Slider',
+    'DatePicker'
+]

dars/components/basic/button.py

@@ -0,0 +1,55 @@
+from dars.core.component import Component
+from dars.core.properties import StyleProps
+from dars.core.events import EventTypes
+from dars.scripts.script import Script
+from typing import Optional, Union, Dict, Any, Callable
+
+class Button(Component):
+    def __init__(
+        self, 
+        text: str = "Button", 
+        id: Optional[str] = None, 
+        class_name: Optional[str] = None, 
+        style: Optional[Dict[str, Any]] = None,
+        disabled: bool = False,
+        button_type: str = "button",  # "button", "submit", "reset"
+        on_click: Optional[Callable] = None,
+        on_double_click: Optional[Callable] = None,
+        on_mouse_enter: Optional[Callable] = None,
+        on_mouse_leave: Optional[Callable] = None,
+        on_mouse_down: Optional[Callable] = None,
+        on_mouse_up: Optional[Callable] = None,
+        on_key_down: Optional[Callable] = None,
+        on_key_up: Optional[Callable] = None
+    ):
+        super().__init__(id=id, class_name=class_name, style=style)
+        self.text = text
+        self.disabled = disabled
+        self.button_type = button_type
+        
+        # Soporte para presets JS editables con dScript u otros Script
+        if on_click:
+            # Convertir a Script si es necesario
+            if not isinstance(on_click, Script) and callable(on_click):
+                from dars.scripts.dscript import dScript
+                on_click = dScript(on_click.__code__)
+            self.set_event(EventTypes.CLICK, on_click)
+        if on_double_click:
+            self.set_event(EventTypes.DOUBLE_CLICK, on_double_click)
+        if on_mouse_enter:
+            self.set_event(EventTypes.MOUSE_ENTER, on_mouse_enter)
+        if on_mouse_leave:
+            self.set_event(EventTypes.MOUSE_LEAVE, on_mouse_leave)
+        if on_mouse_down:
+            self.set_event(EventTypes.MOUSE_DOWN, on_mouse_down)
+        if on_mouse_up:
+            self.set_event(EventTypes.MOUSE_UP, on_mouse_up)
+        if on_key_down:
+            self.set_event(EventTypes.KEY_DOWN, on_key_down)
+        if on_key_up:
+            self.set_event(EventTypes.KEY_UP, on_key_up)
+
+    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/checkbox.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 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,
+        **props
+    ):
+        super().__init__(id=id, class_name=class_name, style=style, **props)
+        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,29 @@
+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,
+        *children: Component,
+        id: Optional[str] = None, 
+        class_name: Optional[str] = None, 
+        style: Optional[Dict[str, Any]] = None,
+        additional_children: Optional[List[Component]] = None,
+        **props
+    ):
+        super().__init__(id=id, class_name=class_name, style=style, **props)
+        
+        # Agregar hijos pasados como argumentos posicionales
+        for child in children:
+            self.add_child(child)
+            
+        # Agregar hijos adicionales si se proporcionan
+        if additional_children:
+            for child in additional_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):
+    """Component to display images."""
+    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,57 @@
+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,
+        on_key_down: Optional[Callable] = None,
+        on_key_up: Optional[Callable] = None,
+        **props
+    ):
+        super().__init__(id=id, class_name=class_name, style=style, **props)
+        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
+        
+        # Soporte para presets JS editables con dScript u otros Script
+        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)
+        if on_key_down:
+            self.set_event(EventTypes.KEY_DOWN, on_key_down)
+        if on_key_up:
+            self.set_event(EventTypes.KEY_UP, on_key_up)
+
+    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):
+    """Component to create links."""
+    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/markdown.py

@@ -0,0 +1,86 @@
+from typing import Optional, Dict, Any, Callable, Union
+import os
+from dars.core.component import Component
+
+class Markdown(Component):
+    def __init__(
+        self,
+        content: Optional[str] = None,
+        file_path: Optional[str] = None,
+        id: Optional[str] = None,
+        class_name: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+        dark_theme: bool = False,
+        **kwargs
+    ):
+        """
+        Markdown component that converts markdown content to HTML.
+        
+        Args:
+            content: String with markdown content
+            file_path: Path to a .md file to load content from
+            id: Component ID
+            class_name: CSS class name
+            style: CSS styles
+            dark_theme: Enable dark theme styling
+        """
+        super().__init__(id=id, class_name=class_name, style=style, **kwargs)
+        
+        if content and file_path:
+            raise ValueError("Only content or file_path can be specified, not both")
+        
+        if not content and not file_path:
+            raise ValueError("Either content or file_path must be specified")
+        
+        self.content = content
+        self.file_path = file_path
+        self.dark_theme = dark_theme
+        self.rendered_html = ""
+        
+        # Load and process markdown content
+        self._load_and_process_content()
+    
+    def _load_and_process_content(self):
+        """Load and process markdown content."""
+        if self.file_path:
+            if not os.path.exists(self.file_path):
+                raise FileNotFoundError(f"File {self.file_path} does not exist")
+            
+            if not self.file_path.endswith('.md'):
+                raise ValueError("File must have .md extension")
+            
+            with open(self.file_path, 'r', encoding='utf-8') as f:
+                self.content = f.read()
+    
+    def update_content(self, new_content: Optional[str] = None, new_file_path: Optional[str] = None):
+        """
+        Update the markdown content of the component.
+        
+        Args:
+            new_content: New markdown content as string
+            new_file_path: New markdown file path
+        """
+        if new_content and new_file_path:
+            raise ValueError("Only new_content or new_file_path can be specified, not both")
+        
+        if new_content:
+            self.content = new_content
+            self.file_path = None
+        elif new_file_path:
+            self.file_path = new_file_path
+            self.content = None
+        
+        self._load_and_process_content()
+    
+    def set_dark_theme(self, enabled: bool = True):
+        """Enable or disable dark theme"""
+        self.dark_theme = enabled
+        # Add dark theme class dynamically
+        if enabled:
+            self.class_name = f"{self.class_name or ''} dars-markdown-dark"
+        else:
+            self.class_name = self.class_name.replace("dars-markdown-dark", "") if self.class_name else ""
+    
+    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/page.py

@@ -0,0 +1,20 @@
+from dars.core.component import Component
+from typing import Optional, Dict, Any, List
+
+class Page(Component):
+    """Root component for pages in Dars multipage apps. Allows passing children as positional arguments and scripts per page."""
+    def __init__(self, *children: Component, 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.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,18 @@
+from dars.core.component import Component
+from typing import Optional
+
+class ProgressBar(Component):
+    """
+    Visual progress bar.
+    value: current value (0-100)
+    max_value: maximum value (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>'