violit 0.0.5__py3-none-any.whl → 0.0.6__py3-none-any.whl

violit/widgets/text_widgets.py

@@ -6,82 +6,98 @@ from ..context import rendering_ctx
 
 
 class TextWidgetsMixin:
-    def write(self, *args, tag: Optional[str] = "div", unsafe_allow_html: bool = False, **props):
-        """Display content with automatic type detection"""
-        from ..state import State
-        import re
-        import json
-        import html as html_lib
+    def write(self, *args, **kwargs):
+        """Magic write: displays arguments based on their type
         
-        cid = self._get_next_cid("comp")
+        Supported types:
+        - Strings, Numbers, State: Rendered as Markdown text
+        - Pandas DataFrame/Series: Rendered as interactive table
+        - Dict/List: Rendered as JSON tree
+        - Matplotlib/Plotly Figures: Rendered as charts
+        - Exceptions: Rendered as error trace
+        """
+        from ..state import State, ComputedState
         
-        def builder():
-            def _has_markdown(text: str) -> bool:
-                """Check if text contains markdown syntax"""
-                markdown_patterns = [
-                    r'^#{1,6}\s',           # Headers: # ## ###
-                    r'\*\*[^*]+\*\*',       # Bold: **text**
-                    r'(?<!\*)\*[^*\n]+\*',  # Italic: *text*
-                    r'`[^`]+`',             # Code: `text`
-                    r'\[.+?\]\(.+?\)',      # Links: [text](url)
-                    r'^[-*]\s',             # Lists: - or *
-                    r'^\d+\.\s',            # Numbered lists: 1. 2.
-                ]
-                for pattern in markdown_patterns:
-                    if re.search(pattern, text, re.MULTILINE):
-                        return True
-                return False
+        # Buffer for text-like arguments
+        text_buffer = []
+        
+        def flush_buffer():
+            if text_buffer:
+                self.markdown(*text_buffer)
+                text_buffer.clear()
+        
+        for arg in args:
+            # Unwrap state for type checking ONLY
+            check_val = arg.value if isinstance(arg, (State, ComputedState)) else arg
             
-            # Set rendering context once for entire builder
-            token = rendering_ctx.set(cid)
-            parts = []
+            # 1. Pandas DataFrame / Series
+            is_df = False
+            try:
+                import pandas as pd
+                if isinstance(check_val, (pd.DataFrame, pd.Series, pd.Index)):
+                    is_df = True
+            except ImportError: pass
             
+            if is_df:
+                flush_buffer()
+                if hasattr(self, 'dataframe'):
+                    self.dataframe(arg)
+                else:
+                    self.markdown(str(arg))
+                continue
+                
+            # 2. Matplotlib Figure
+            is_pyplot = False
             try:
-                for arg in args:
-                    current_value = arg
-                    
-                    # State object: read value (registers dependency)
-                    if isinstance(arg, State):
-                        current_value = arg.value
-                    
-                    # Callable/Lambda: execute (registers dependency)
-                    elif callable(arg):
-                        current_value = arg()
-                    
-                    # DataFrame (pandas)
-                    try:
-                        import pandas as pd
-                        if isinstance(current_value, pd.DataFrame):
-                            parts.append(self._render_dataframe_html(current_value))
-                            continue
-                    except (ImportError, AttributeError):
-                        pass
-                    
-                    # Dict or List → JSON
-                    if isinstance(current_value, (dict, list, tuple)):
-                        json_str = json.dumps(current_value, indent=2, ensure_ascii=False)
-                        parts.append(f'<pre style="background:var(--sl-bg-card);padding:1rem;border-radius:0.5rem;border:1px solid var(--sl-border);overflow-x:auto;"><code style="color:var(--sl-text);font-family:monospace;">{html_lib.escape(json_str)}</code></pre>')
-                        continue
-                    
-                    # String with markdown → render as markdown
-                    text = str(current_value)
-                    if _has_markdown(text):
-                        parts.append(self._render_markdown(text))
-                    else:
-                        # Plain text
-                        parts.append(text)
+                import matplotlib.figure
+                if isinstance(check_val, matplotlib.figure.Figure):
+                    is_pyplot = True
+            except ImportError: pass
+            
+            if is_pyplot:
+                flush_buffer()
+                if hasattr(self, 'pyplot'):
+                    self.pyplot(arg)
+                continue
                 
-                # Join all parts
-                content = " ".join(parts)
+            # 3. Plotly Figure
+            is_plotly = False
+            try:
+                if hasattr(check_val, 'to_plotly_json'):
+                    is_plotly = True
+            except ImportError: pass
+            
+            if is_plotly:
+                flush_buffer()
+                if hasattr(self, 'plotly_chart'):
+                    self.plotly_chart(arg)
+                continue
+                
+            # 4. Dict / List (JSON)
+            if isinstance(check_val, (dict, list)):
+                flush_buffer()
+                if hasattr(self, 'json'):
+                    self.json(arg)
+                else:
+                    # Fallback if json widget logic is missing for State
+                    # But wait, we need to fix json widget too.
+                    self.json(arg)
+                continue
                 
-                # Check if any HTML in content
-                has_html = '<' in content and '>' in content
-                return Component(tag, id=cid, content=content, escape_content=not (has_html or unsafe_allow_html), **props)
+            # 5. Exception
+            if isinstance(check_val, Exception):
+                flush_buffer()
+                if hasattr(self, 'exception'):
+                    self.exception(arg)
+                else:
+                    self.error(str(arg))
+                continue
             
-            finally:
-                rendering_ctx.reset(token)
-        
-        self._register_component(cid, builder)
+            # Default: Text-like (str, int, float, State, ComputedState)
+            text_buffer.append(arg)
+            
+        # Flush remaining text
+        flush_buffer()
     
     def _render_markdown(self, text: str) -> str:
         """Render markdown to HTML (internal helper)"""
@@ -191,20 +207,25 @@ class TextWidgetsMixin:
         '''
         return styled_html
 
-    def heading(self, text, level: int = 1, divider: bool = False):
+    def heading(self, *args, level: int = 1, divider: bool = False):
         """Display heading (h1-h6)"""
-        from ..state import State
+        from ..state import State, ComputedState
         import html as html_lib
         
         cid = self._get_next_cid("heading")
         def builder():
             token = rendering_ctx.set(cid)
-            if isinstance(text, State):
-                content = text.value
-            elif callable(text):
-                content = text()
-            else:
-                content = text
+            
+            parts = []
+            for arg in args:
+                if isinstance(arg, (State, ComputedState)):
+                    parts.append(str(arg.value))
+                elif callable(arg):
+                    parts.append(str(arg()))
+                else:
+                    parts.append(str(arg))
+            
+            content = " ".join(parts)
             rendering_ctx.reset(token)
             
             # XSS protection: escape content
@@ -216,48 +237,71 @@ class TextWidgetsMixin:
             return Component("div", id=cid, content=html_output)
         self._register_component(cid, builder)
 
-    def title(self, text: Union[str, Callable]):
+    def title(self, *args):
         """Display title (h1 with gradient)"""
-        self.heading(text, level=1, divider=False)
+        self.heading(*args, level=1, divider=False)
     
-    def header(self, text: Union[str, Callable], divider: bool = True):
+    def header(self, *args, divider: bool = True):
         """Display header (h2)"""
-        self.heading(text, level=2, divider=divider)
+        self.heading(*args, level=2, divider=divider)
     
-    def subheader(self, text: Union[str, Callable], divider: bool = False):
+    def subheader(self, *args, divider: bool = False):
         """Display subheader (h3)"""
-        self.heading(text, level=3, divider=divider)
+        self.heading(*args, level=3, divider=divider)
 
-    def text(self, content, size: str = "medium", muted: bool = False):
-        """Display text paragraph"""
-        from ..state import State
+    def text(self, *args, size: str = "medium", muted: bool = False):
+        """Display text paragraph
+        
+        Supports multiple arguments which will be joined by spaces.
+        """
+        from ..state import State, ComputedState
         
         cid = self._get_next_cid("text")
         def builder():
             token = rendering_ctx.set(cid)
-            if isinstance(content, State):
-                val = content.value
-            elif callable(content):
-                val = content()
-            else:
-                val = content
+            
+            parts = []
+            for arg in args:
+                if isinstance(arg, (State, ComputedState)):
+                    parts.append(str(arg.value))
+                elif callable(arg):
+                    parts.append(str(arg()))
+                else:
+                    parts.append(str(arg))
+            
+            val = " ".join(parts)
             rendering_ctx.reset(token)
+            
             cls = f"text-{size} {'text-muted' if muted else ''}"
             # XSS protection: enable content escaping
             return Component("p", id=cid, content=val, escape_content=True, class_=cls)
         self._register_component(cid, builder)
     
-    def caption(self, text: Union[str, Callable]):
+    def caption(self, *args):
         """Display caption text (small, muted)"""
-        self.text(text, size="small", muted=True)
+        self.text(*args, size="small", muted=True)
 
-    def markdown(self, text: Union[str, Callable], **props):
-        """Display markdown-formatted text"""
+    def markdown(self, *args, **props):
+        """Display markdown-formatted text
+        
+        Supports multiple arguments which will be joined by spaces.
+        """
         cid = self._get_next_cid("markdown")
         def builder():
             token = rendering_ctx.set(cid)
-            content = text() if callable(text) else text
+            from ..state import State, ComputedState
+            
+            parts = []
+            for arg in args:
+                if isinstance(arg, (State, ComputedState)):
+                    parts.append(str(arg.value))
+                elif callable(arg):
+                    parts.append(str(arg()))
+                else:
+                    parts.append(str(arg))
             
+            content = " ".join(parts)
+                
             # Enhanced markdown conversion - line-by-line processing
             import re
             lines = content.split('\n')
@@ -332,19 +376,30 @@ class TextWidgetsMixin:
             return Component("div", id=cid, content=html, class_="markdown", **props)
         self._register_component(cid, builder)
     
-    def html(self, html_content: Union[str, Callable], **props):
+    def html(self, *args, **props):
         """Display raw HTML content
         
         Use this when you need to render HTML directly without markdown processing.
         For markdown formatting, use app.markdown() instead.
         
         Example:
-            app.html('<div class="custom">Hello</div>')
+            app.html('<div class="custom">', count, '</div>')
         """
         cid = self._get_next_cid("html")
         def builder():
+            from ..state import State, ComputedState
             token = rendering_ctx.set(cid)
-            content = html_content() if callable(html_content) else html_content
+            
+            parts = []
+            for arg in args:
+                if isinstance(arg, (State, ComputedState)):
+                    parts.append(str(arg.value))
+                elif callable(arg):
+                    parts.append(str(arg()))
+                else:
+                    parts.append(str(arg))
+            
+            content = " ".join(parts)
             rendering_ctx.reset(token)
             return Component("div", id=cid, content=content, **props)
         self._register_component(cid, builder)
@@ -371,16 +426,6 @@ class TextWidgetsMixin:
             return Component("div", id=cid, content=html_output, **props)
         self._register_component(cid, builder)
 
-    def html(self, html_content: Union[str, Callable], **props):
-        """Render raw HTML"""
-        cid = self._get_next_cid("html")
-        def builder():
-            token = rendering_ctx.set(cid)
-            content = html_content() if callable(html_content) else html_content
-            rendering_ctx.reset(token)
-            return Component("div", id=cid, content=content, **props)
-        self._register_component(cid, builder)
-
     def divider(self):
         """Display horizontal divider"""
         cid = self._get_next_cid("divider")

{violit-0.0.5.dist-info → violit-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violit
-Version: 0.0.5
+Version: 0.0.6
 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.dist-info → violit-0.0.6.dist-info}/RECORD

@@ -2,25 +2,25 @@ violit/__init__.py,sha256=mD8FeVW-LQ8yLpW2Unc-K885T507BgRfSI7mmObpPK0,88
 violit/app.py,sha256=G_li1AU8vH25T1VryG6kb7jrYV_zUucBdbg_goA_Q98,102272
 violit/broadcast.py,sha256=IIRQR15Wr7cqHh0nSH86QdWN_Wd_GHNfVrtWCATGElc,24293
 violit/broadcast_primitives.py,sha256=G4Nx9BZscidPAjUc9janwIJ0zUi6DAnNFeJS67Uvs9I,5739
-violit/component.py,sha256=zH-ln8CVrkqfgB-_SPUmCL8dqQv-8RbKb2p9gtYqlqI,1445
+violit/component.py,sha256=HBh72unqjNUri05UAK_TnQVsPJULot2hgAQK8HKqQLM,1483
 violit/context.py,sha256=oai3FiBFwZbAK-ONHCPzItITHjXeZ3zXNya_BmPlX8I,517
 violit/engine.py,sha256=oH3C04vhVgZFgy0HSaI9vPOkBEZBQBz40zs1Y1my9vw,1829
-violit/state.py,sha256=KcsgqYvn7yTr8RGxxXZNzDPwCTmW9CE4P2EEx6DVfNY,3712
+violit/state.py,sha256=oxIVCa-nencMjQXAs9ZMwfeTuz4w0LAeKDvBv_lvzhQ,12721
 violit/theme.py,sha256=1Ht2DariRADxGU1GTtUFJaIXZXi9XuhnucT2d04cwhs,30781
 violit/widgets/__init__.py,sha256=DdNdPahOIxEGKnV-MP-amA3jKGnE8GCUxKrtKN2sR9o,877
 violit/widgets/card_widgets.py,sha256=rRGuY-7pArbneILQ8cLkBgiE820S6RCe1a2EZq0ZA3k,23112
-violit/widgets/chart_widgets.py,sha256=swFvpfQ4A6ObXcBs90Pe5pIlIUzsZ4x97veWsMR4UFs,10428
+violit/widgets/chart_widgets.py,sha256=WtPRunw_2t45RTPtIHuvEkBd8miTJUL6HOYlVlvHE9k,10681
 violit/widgets/chat_widgets.py,sha256=YHNY4SDqHJhTi3Lq_5lGl01y9jsJAfbPlH4Ar0UqYC8,10899
-violit/widgets/data_widgets.py,sha256=KUhgq5_wRUGciFJX9uxHsX6w1e9Gj40__azC9Kn6gg8,22712
+violit/widgets/data_widgets.py,sha256=NhQnQ_FAD2ey4mXUxaPT67rzjen-BLKU7pZSPmcln5Y,23431
 violit/widgets/form_widgets.py,sha256=QVj-MRVpYzIM3hE8ISS5xZcX3jlTTzjRYSdzhw-K5OY,18327
-violit/widgets/input_widgets.py,sha256=tiLpfaKBwGhE2CdOL9s950bLVz2WhMP4Y-1yRM0qIAY,32023
+violit/widgets/input_widgets.py,sha256=FjuSzNg00PnoQFyQDt6b6pWWrqofVcQeHHJX4L42voU,32768
 violit/widgets/layout_widgets.py,sha256=--2vxZAxVfPCrLz74OBE5RM4x1RoOfMR3w1w79kXUFg,17606
 violit/widgets/list_widgets.py,sha256=2-FWluNGfdBBN24ZyHOC2a8O93-NzGYHZlVYARX4FpI,3836
 violit/widgets/media_widgets.py,sha256=FIMjaE1CIfqnsdMHbbCromjwxoWPfvFKmL0_qd6nDL4,7386
-violit/widgets/status_widgets.py,sha256=HXfS2F_PhEnwHrKNEMFv9JTgmeXgpfspoqq_jJZRPEQ,11140
-violit/widgets/text_widgets.py,sha256=r2QOsi5qOPMEHhVXNBd2g_U_f5-en_4xHBh1udenCSA,17422
-violit-0.0.5.dist-info/licenses/LICENSE,sha256=dMxDVLF-GU5ZhQ-GmpL_eY4j7Wn1c4CtmRU8cOnR7Hw,1093
-violit-0.0.5.dist-info/METADATA,sha256=ZdOykMhsRYHrtJgLPt3mb-yAxnatabXPWfM0crvX9cU,12599
-violit-0.0.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-violit-0.0.5.dist-info/top_level.txt,sha256=VormCSpHvTyMyZQ17MwgiPegDJev8HQCN5HUUcxUcE0,7
-violit-0.0.5.dist-info/RECORD,,
+violit/widgets/status_widgets.py,sha256=ImA8vunM2Vk30-eECyl0eGiN75Nj7qtciwHgwgrymAs,13447
+violit/widgets/text_widgets.py,sha256=yFlcDrJYTQTB25X562xiVZWS0Lz3-tljFxJcGRtAlb4,17867
+violit-0.0.6.dist-info/licenses/LICENSE,sha256=dMxDVLF-GU5ZhQ-GmpL_eY4j7Wn1c4CtmRU8cOnR7Hw,1093
+violit-0.0.6.dist-info/METADATA,sha256=nh6AXUz9720pCMLFxxYNjwITb2rD5_4PDQGxHXtAY2o,12599
+violit-0.0.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+violit-0.0.6.dist-info/top_level.txt,sha256=VormCSpHvTyMyZQ17MwgiPegDJev8HQCN5HUUcxUcE0,7
+violit-0.0.6.dist-info/RECORD,,