violit 0.0.5__tar.gz → 0.0.7__tar.gz

{violit-0.0.5/src/violit.egg-info → violit-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violit
-Version: 0.0.5
+Version: 0.0.7
 Summary: Violit: Faster than Light, Beautiful as Violet. The High-Performance Python Web Framework (Streamlit Alternative with Zero Rerun).
 Author-email: Violit Team <violit.company@gmail.com>
 License: MIT

{violit-0.0.5 → violit-0.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "violit"
-version = "0.0.5"
+version = "0.0.7"
 description = "Violit: Faster than Light, Beautiful as Violet. The High-Performance Python Web Framework (Streamlit Alternative with Zero Rerun)."
 readme = "README.md"
 requires-python = ">=3.10"

{violit-0.0.5 → violit-0.0.7}/src/violit/component.py

@@ -1,38 +1,38 @@
-from typing import Any, Optional
-import html
-
-class Component:
-    def __init__(self, tag: Optional[str], id: str, escape_content: bool = False, **props):
-        self.tag = tag
-        self.id = id
-        self.escape_content = escape_content  # XSS protection
-        self.props = props
-
-    def render(self) -> str:
-        if self.tag is None:
-            content = str(self.props.get('content', ''))
-            # Escape content if enabled
-            return html.escape(content) if self.escape_content else content
-            
-        attrs = []
-        for k, v in self.props.items():
-            if k == 'content': continue
-            clean_k = k.replace('_', '-') if not k.startswith('on') else k
-            if clean_k.startswith('on'):
-                attrs.append(f'{clean_k}="{v}"')
-            else:
-                if v is True: attrs.append(clean_k)
-                elif v is False or v is None: continue
-                else: 
-                    # Escape attribute values for XSS protection
-                    escaped_v = html.escape(str(v), quote=True)
-                    attrs.append(f'{clean_k}="{escaped_v}"')
-        
-        props_str = " ".join(attrs)
-        content = self.props.get('content', '')
-        
-        # Escape content if enabled
-        if self.escape_content:
-            content = html.escape(str(content))
-        
-        return f"<{self.tag} id=\"{self.id}\" {props_str}>{content}</{self.tag}>"
+from typing import Any, Optional
+import html
+
+class Component:
+    def __init__(self, tag: Optional[str], id: str, escape_content: bool = False, **props):
+        self.tag = tag
+        self.id = id
+        self.escape_content = escape_content  # XSS protection
+        self.props = props
+
+    def render(self) -> str:
+        if self.tag is None:
+            content = str(self.props.get('content', ''))
+            # Escape content if enabled
+            return html.escape(content) if self.escape_content else content
+            
+        attrs = []
+        for k, v in self.props.items():
+            if k == 'content': continue
+            clean_k = k.replace('_', '-') if not k.startswith('on') else k
+            if clean_k.startswith('on'):
+                attrs.append(f'{clean_k}="{v}"')
+            else:
+                if v is True: attrs.append(clean_k)
+                elif v is False or v is None: continue
+                else: 
+                    # Escape attribute values for XSS protection
+                    escaped_v = html.escape(str(v), quote=True)
+                    attrs.append(f'{clean_k}="{escaped_v}"')
+        
+        props_str = " ".join(attrs)
+        content = self.props.get('content', '')
+        
+        # Escape content if enabled
+        if self.escape_content:
+            content = html.escape(str(content))
+        
+        return f"<{self.tag} id=\"{self.id}\" {props_str}>{content}</{self.tag}>"

violit-0.0.7/src/violit/state.py

@@ -0,0 +1,310 @@
+from typing import Any, Dict, Set
+from cachetools import TTLCache
+from .context import session_ctx, rendering_ctx, app_instance_ref
+from .theme import Theme
+
+class DependencyTracker:
+    def __init__(self):
+        self.subscribers: Dict[str, Set[str]] = {}
+    
+    def register_dependency(self, state_name: str, component_id: str):
+        if state_name not in self.subscribers:
+            self.subscribers[state_name] = set()
+        self.subscribers[state_name].add(component_id)
+
+    def get_dirty_components(self, state_name: str) -> Set[str]:
+        return self.subscribers.get(state_name, set())
+
+GLOBAL_STORE = TTLCache(maxsize=1000, ttl=1800)
+
+def get_session_store():
+    sid = session_ctx.get()
+    if sid not in GLOBAL_STORE:
+        initial_theme = 'light'
+        if app_instance_ref[0]:
+            initial_theme = app_instance_ref[0].theme_manager.preset_name
+            
+        GLOBAL_STORE[sid] = {
+            'states': {}, 
+            'tracker': DependencyTracker(),
+            'builders': {},
+            'actions': {},
+            'component_count': 0,
+            'fragment_components': {},
+            'order': [],
+            'sidebar_order': [],
+            'theme': Theme(initial_theme)
+        }
+    return GLOBAL_STORE[sid]
+
+class State:
+    def __init__(self, name: str, default_value: Any):
+        object.__setattr__(self, 'name', name)
+        object.__setattr__(self, 'default_value', default_value)
+
+    @property
+    def value(self):
+        store = get_session_store()
+        current_comp_id = rendering_ctx.get()
+        if current_comp_id:
+            store['tracker'].register_dependency(self.name, current_comp_id)
+        return store['states'].get(self.name, self.default_value)
+    
+    @value.setter
+    def value(self, new_value: Any):
+        self.set(new_value)
+
+    def set(self, new_value: Any):
+        store = get_session_store()
+        store['states'][self.name] = new_value
+        if 'dirty_states' not in store: store['dirty_states'] = set()
+        store['dirty_states'].add(self.name)
+    
+    def __setattr__(self, attr: str, val: Any):
+        if attr == 'value':
+            self.set(val)
+        else:
+            object.__setattr__(self, attr, val)
+
+    def __str__(self):
+        return str(self.value)
+    
+    def __call__(self):
+        return self.value
+    
+    def __repr__(self):
+        return f"State({self.name}, {self.value})"
+
+    # Reactive Comparison Operators
+    def __eq__(self, other): return ComputedState(lambda: self.value == other)
+    def __ne__(self, other): return ComputedState(lambda: self.value != other)
+    def __lt__(self, other): return ComputedState(lambda: self.value < other)
+    def __le__(self, other): return ComputedState(lambda: self.value <= other)
+    def __gt__(self, other): return ComputedState(lambda: self.value > other)
+    def __ge__(self, other): return ComputedState(lambda: self.value >= other)
+
+    # Reactive Arithmetic Operators
+    def __add__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        def compute():
+            self_val = self.value
+            # If either is a string, concatenate as strings
+            if isinstance(self_val, str) or isinstance(other_val, str):
+                return str(self_val) + str(other_val)
+            else:
+                return self_val + other_val
+        return ComputedState(compute)
+    
+    def __radd__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        def compute():
+            self_val = self.value
+            # If either is a string, concatenate as strings
+            if isinstance(self_val, str) or isinstance(other_val, str):
+                return str(other_val) + str(self_val)
+            else:
+                return other_val + self_val
+        return ComputedState(compute)
+    
+    def __sub__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: self.value - other_val)
+    
+    def __rsub__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: other_val - self.value)
+    
+    def __mul__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        def compute():
+            self_val = self.value
+            # String repetition: "ab" * 3 or 3 * "ab"
+            if isinstance(self_val, str) or isinstance(other_val, str):
+                # One must be int for string repetition to work
+                if isinstance(self_val, str) and isinstance(other_val, int):
+                    return self_val * other_val
+                elif isinstance(other_val, str) and isinstance(self_val, int):
+                    return self_val * other_val
+                else:
+                    # Both strings? Convert to numeric or error
+                    return self_val * other_val
+            else:
+                return self_val * other_val
+        return ComputedState(compute)
+    
+    def __rmul__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        def compute():
+            self_val = self.value
+            # String repetition: "ab" * 3 or 3 * "ab"
+            if isinstance(self_val, str) or isinstance(other_val, str):
+                if isinstance(other_val, str) and isinstance(self_val, int):
+                    return other_val * self_val
+                elif isinstance(self_val, str) and isinstance(other_val, int):
+                    return other_val * self_val
+                else:
+                    return other_val * self_val
+            else:
+                return other_val * self_val
+        return ComputedState(compute)
+    
+    def __truediv__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: self.value / other_val)
+    
+    def __rtruediv__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: other_val / self.value)
+    
+    def __floordiv__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: self.value // other_val)
+    
+    def __rfloordiv__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: other_val // self.value)
+    
+    def __mod__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: self.value % other_val)
+    
+    def __rmod__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: other_val % self.value)
+    
+    def __pow__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: self.value ** other_val)
+    
+    def __rpow__(self, other): 
+        other_val = other.value if isinstance(other, (State, ComputedState)) else other
+        return ComputedState(lambda: other_val ** self.value)
+    
+    # String formatting support
+    def __format__(self, format_spec):
+        """Support for f-string formatting: f'{state:03d}'"""
+        return format(self.value, format_spec)
+
+
+class ComputedState:
+    """A state derived from other states (e.g. expressions)"""
+    def __init__(self, func):
+        self.func = func
+
+    @property
+    def value(self):
+        return self.func()
+
+    def __bool__(self):
+        return bool(self.value)
+    
+    def __call__(self):
+        return self.value
+
+    # Logical operators for chaining
+    def __and__(self, other):
+        val_other = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: self.value and val_other)
+    
+    def __or__(self, other):
+        val_other = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: self.value or val_other)
+
+    # Reactive Arithmetic Operators (Mirroring State)
+    def __add__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        def compute():
+            self_val = self.value
+            # If either is a string, concatenate as strings
+            if isinstance(self_val, str) or isinstance(other_val, str):
+                return str(self_val) + str(other_val)
+            else:
+                return self_val + other_val
+        return ComputedState(compute)
+    
+    def __radd__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        def compute():
+            self_val = self.value
+            # If either is a string, concatenate as strings
+            if isinstance(self_val, str) or isinstance(other_val, str):
+                return str(other_val) + str(self_val)
+            else:
+                return other_val + self_val
+        return ComputedState(compute)
+    
+    def __sub__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: self.value - other_val)
+    
+    def __rsub__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: other_val - self.value)
+    
+    def __mul__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        def compute():
+            self_val = self.value
+            # String repetition: "ab" * 3 or 3 * "ab"
+            if isinstance(self_val, str) or isinstance(other_val, str):
+                if isinstance(self_val, str) and isinstance(other_val, int):
+                    return self_val * other_val
+                elif isinstance(other_val, str) and isinstance(self_val, int):
+                    return self_val * other_val
+                else:
+                    return self_val * other_val
+            else:
+                return self_val * other_val
+        return ComputedState(compute)
+    
+    def __rmul__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        def compute():
+            self_val = self.value
+            # String repetition: "ab" * 3 or 3 * "ab"
+            if isinstance(self_val, str) or isinstance(other_val, str):
+                if isinstance(other_val, str) and isinstance(self_val, int):
+                    return other_val * self_val
+                elif isinstance(self_val, str) and isinstance(other_val, int):
+                    return other_val * self_val
+                else:
+                    return other_val * self_val
+            else:
+                return other_val * self_val
+        return ComputedState(compute)
+    
+    def __truediv__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: self.value / other_val)
+    
+    def __rtruediv__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: other_val / self.value)
+    
+    def __floordiv__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: self.value // other_val)
+    
+    def __rfloordiv__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: other_val // self.value)
+    
+    def __mod__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: self.value % other_val)
+    
+    def __rmod__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: other_val % self.value)
+    
+    def __pow__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: self.value ** other_val)
+    
+    def __rpow__(self, other): 
+        other_val = other.value if hasattr(other, 'value') else other
+        return ComputedState(lambda: other_val ** self.value)
+    
+    # String formatting support
+    def __format__(self, format_spec):
+        return format(self.value, format_spec)

{violit-0.0.5 → violit-0.0.7}/src/violit/theme.py

@@ -713,6 +713,171 @@ class Theme:
                     -webkit-text-fill-color: transparent !important;
                 }
             """
+        },
+        'violit_light': {
+            'mode': 'light',
+            'primary': '#7C3AED', 
+            'secondary': '#8B5CF6',
+            'success': '#10B981',
+            'warning': '#F59E0B',
+            'danger': '#EF4444',
+            'bg': '#FFFFFF',
+            'bg_card': '#FFFFFF',
+            'border': '#E4E4E7',
+            'text': '#18181B',
+            'text_muted': '#71717A',
+            'radius': '6px',
+            'input_border_radius_small': '4px',
+            'input_border_radius_medium': '6px',
+            'input_border_radius_large': '8px',
+            'extra_css': """
+                /* 
+                   THEME: Modern Luxury (Restrained)
+                   Concept: 'Silk & Glass' - Smooth, matte finishes with subtle light play.
+                   No loud gradients, no flashing flashing animations.
+                */
+
+                body {
+                    background-color: #FFFFFF;
+                    /* Very subtle ambient light, barely visible */
+                    background-image: radial-gradient(circle at 50% 0%, rgba(124, 58, 237, 0.03), transparent 40%);
+                }
+                
+                /* Cards: Clean, bordered, soft shadow */
+                .card {
+                    background: #FFFFFF !important;
+                    border: 1px solid #E4E4E7 !important;
+                    box-shadow: 0 1px 3px rgba(0,0,0,0.02) !important;
+                    border-radius: 8px !important;
+                    transition: box-shadow 0.2s ease, transform 0.2s ease;
+                }
+                .card:hover {
+                    box-shadow: 0 8px 24px rgba(0,0,0,0.04) !important;
+                    border-color: #D4D4D8 !important;
+                }
+
+                /* --- SOPHISTICATED BUTTONS --- */
+                /* Matte finish, rich color, soft colored shadow */
+                
+                sl-button::part(base) {
+                    background: #7C3AED !important; /* Solid Violet 600 */
+                    border: 1px solid transparent !important; /* Clean edges */
+                    
+                    color: white !important;
+                    font-weight: 500 !important; /* Medium weight is more premium than Bold */
+                    letter-spacing: -0.01em;
+                    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+                    
+                    border-radius: 6px !important;
+                    
+                    /* The "Luxury" Touch: A soft, colored shadow glow */
+                    box-shadow: 0 4px 12px rgba(124, 58, 237, 0.25) !important;
+                    
+                    transition: all 0.2s cubic-bezier(0.25, 1, 0.5, 1);
+                }
+
+                /* Hover: Subtle Deepening & Lift */
+                sl-button::part(base):hover {
+                    background: #6D28D9 !important; /* Violet 700 */
+                    transform: translateY(-1px);
+                    box-shadow: 0 6px 16px rgba(124, 58, 237, 0.35) !important;
+                }
+
+                /* Active: Precise Press */
+                sl-button::part(base):active {
+                    transform: translateY(0px) scale(0.98) !important;
+                    background: #5B21B6 !important; /* Violet 800 */
+                    box-shadow: 0 2px 4px rgba(124, 58, 237, 0.15) !important;
+                }
+
+                /* Remove all pseudo-element animations for cleaner look */
+                sl-button::part(base)::before,
+                sl-button::part(base)::after {
+                    display: none !important;
+                }
+
+                /* Typography: High contrast, sharp */
+                h1, h2, h3 {
+                    color: #111827;
+                    font-weight: 700;
+                    letter-spacing: -0.02em;
+                }
+            """
+        },
+        'violit_dark': {
+            'mode': 'dark',
+            'primary': '#8B5CF6',
+            'secondary': '#6D28D9',
+            'success': '#34D399',
+            'warning': '#FBBF24',
+            'danger': '#F87171',
+            'bg': '#1e1b4b',          # Ultra Deep Indigo
+            'bg_card': '#312e81',     # Deep Indigo
+            'border': '#4c1d95',      # Violet 900
+            'text': '#ede9fe',        # Violet 50
+            'text_muted': '#a78bfa',
+            'radius': '3px',
+            'input_border_radius_small': '2px',
+            'input_border_radius_medium': '3px',
+            'input_border_radius_large': '4px',
+            'extra_css': """
+                body {
+                    background: radial-gradient(circle at 50% -20%, #4c1d95 0%, #1e1b4b 50%, #0f0a20 100%);
+                }
+                
+                .card {
+                    background: rgba(49, 46, 129, 0.4) !important;
+                    backdrop-filter: blur(12px) !important;
+                    border: 1px solid rgba(139, 92, 246, 0.3) !important;
+                    box-shadow: 
+                        0 0 20px rgba(139, 92, 246, 0.05),
+                        inset 0 0 0 1px rgba(255, 255, 255, 0.05) !important;
+                }
+
+                /* Neon Facet Buttons */
+                sl-button::part(base) {
+                    background: transparent !important;
+                    border: 1px solid #8B5CF6 !important;
+                    color: #8B5CF6 !important;
+                    border-radius: 2px !important;
+                    box-shadow: 0 0 5px rgba(139, 92, 246, 0.2) !important;
+                    transition: all 0.2s ease !important;
+                    text-transform: uppercase;
+                    font-weight: 700;
+                    letter-spacing: 1px;
+                }
+
+                /* Hover: Fill with Light */
+                sl-button::part(base):hover {
+                    background: #8B5CF6 !important;
+                    color: white !important;
+                    box-shadow: 0 0 20px #8B5CF6, 0 0 40px rgba(139, 92, 246, 0.4) !important;
+                    text-shadow: 0 1px 2px rgba(0,0,0,0.2);
+                    transform: scale(1.02) !important;
+                    border-color: transparent !important;
+                }
+
+                /* Active */
+                sl-button::part(base):active {
+                    transform: scale(0.95) !important;
+                    box-shadow: 0 0 10px #8B5CF6 !important;
+                }
+
+                h1, h2, h3 {
+                   color: #ede9fe;
+                   text-shadow: 0 0 10px rgba(139, 92, 246, 0.5);
+                }
+                
+                /* Inputs */
+                sl-input::part(base) {
+                    background: rgba(0,0,0,0.3) !important;
+                    border: 1px solid #4c1d95 !important;
+                }
+                sl-input::part(base):focus-within {
+                    border-color: #8B5CF6 !important;
+                    box-shadow: 0 0 10px rgba(139, 92, 246, 0.2) !important;
+                }
+            """
         }
     }