htag 2.0.3__tar.gz → 2.0.5__tar.gz

{htag-2.0.3 → htag-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htag
-Version: 2.0.3
+Version: 2.0.5
 Summary: Python3 GUI toolkit for building 'beautiful' applications for mobile, web, and desktop from a single codebase
 Author: manatlan
 License: MIT
@@ -103,7 +103,7 @@ htag is a Python library for building web applications using HTML, CSS, and Java
 *   **Parano Mode (Payload Obfuscation)**: By initializing `WebApp(App, parano=True)`, all data exchanged between the frontend and backend is automatically obfuscated using a dynamic XOR cipher and Base64 wrapping, making network traffic unreadable to MITM proxies.
 *   **`.root`, `.parent`, and `.childs` properties**: Every `GTag` exposes its position in the component tree. `.root` references the main `Tag` instance, `.parent` references the direct parent component, and `.childs` is a list of its children. This allows components to easily navigate the DOM tree and trigger app-level actions.
 *   **Declarative UI with Context Managers (`with`)**: You can now build component trees visually using `with` blocks (e.g., `with Tag.div(): Tag.h1("Hello")`), removing the need for `self <= ...` boilerplate.
-*   **Modern Attribute Access (Dictionary Style)**: In addition to `Tag.div(_class="foo")` in constructors, you should now use `self["class"] = "foo"` for dynamic property management. This is the preferred way to handle all attributes, including those with dashes (e.g., `self["data-id"] = 123`).
+*   **Modern Attribute Access (Dictionary Style)**: In addition to `Tag.div(_class="foo")` in constructors, you must now use `self["class"] = "foo"` for dynamic property management after instantiation. This is the only way to handle all attributes, including those with dashes (e.g., `self["data-id"] = 123`).
 *   **Reactive State Management (`State`)**: Introducing `State(value)` for automatic UI reactivity. `State` acts as a transparent **Proxy**: you can use comparison/arithmetic operators directly (`if self.count > 0: ...`), mutate nested structures (including `lists`, `dicts`, `sets`, and `tuples`), and delegate attribute assignments seamlessly.
 *   **Iterative & Attribute Reactivity**: Iterating over a `State` now yields proxies, meaning mutations like `for item in self.list: item.active = True` trigger re-renders. Attribute assignments (e.g. `self.user.name = "Bob"`) are automatically delegated to the underlying object and notified.
 *   **Reactive & Boolean Attributes**: Attributes like `_class`, `_style`, or `_disabled` in constructors now support lambdas for dynamic updates. Boolean attributes (e.g. `_disabled=True`) are correctly rendered as key-only or omitted.

{htag-2.0.3 → htag-2.0.5}/README.md

@@ -82,7 +82,7 @@ htag is a Python library for building web applications using HTML, CSS, and Java
 *   **Parano Mode (Payload Obfuscation)**: By initializing `WebApp(App, parano=True)`, all data exchanged between the frontend and backend is automatically obfuscated using a dynamic XOR cipher and Base64 wrapping, making network traffic unreadable to MITM proxies.
 *   **`.root`, `.parent`, and `.childs` properties**: Every `GTag` exposes its position in the component tree. `.root` references the main `Tag` instance, `.parent` references the direct parent component, and `.childs` is a list of its children. This allows components to easily navigate the DOM tree and trigger app-level actions.
 *   **Declarative UI with Context Managers (`with`)**: You can now build component trees visually using `with` blocks (e.g., `with Tag.div(): Tag.h1("Hello")`), removing the need for `self <= ...` boilerplate.
-*   **Modern Attribute Access (Dictionary Style)**: In addition to `Tag.div(_class="foo")` in constructors, you should now use `self["class"] = "foo"` for dynamic property management. This is the preferred way to handle all attributes, including those with dashes (e.g., `self["data-id"] = 123`).
+*   **Modern Attribute Access (Dictionary Style)**: In addition to `Tag.div(_class="foo")` in constructors, you must now use `self["class"] = "foo"` for dynamic property management after instantiation. This is the only way to handle all attributes, including those with dashes (e.g., `self["data-id"] = 123`).
 *   **Reactive State Management (`State`)**: Introducing `State(value)` for automatic UI reactivity. `State` acts as a transparent **Proxy**: you can use comparison/arithmetic operators directly (`if self.count > 0: ...`), mutate nested structures (including `lists`, `dicts`, `sets`, and `tuples`), and delegate attribute assignments seamlessly.
 *   **Iterative & Attribute Reactivity**: Iterating over a `State` now yields proxies, meaning mutations like `for item in self.list: item.active = True` trigger re-renders. Attribute assignments (e.g. `self.user.name = "Bob"`) are automatically delegated to the underlying object and notified.
 *   **Reactive & Boolean Attributes**: Attributes like `_class`, `_style`, or `_disabled` in constructors now support lambdas for dynamic updates. Boolean attributes (e.g. `_disabled=True`) are correctly rendered as key-only or omitted.

{htag-2.0.3 → htag-2.0.5}/htag/client_js.py

@@ -5,18 +5,17 @@ var use_fallback = false;
 var sse;
 var _base_path = window.location.pathname.endsWith("/") ? window.location.pathname : window.location.pathname + "/";
 window._htag_callbacks = {}; // Store promise resolvers
-var _interacting = 0;
-function _inc_interacting() {
-    _interacting++;
-    document.body.classList.add("interacting");
-}
-function _dec_interacting() {
-    _interacting--;
-    if(_interacting <= 0) {
-        _interacting = 0;
+function _sync_interacting() {
+    if(Object.keys(window._htag_callbacks).length > 0) {
+        document.body.classList.add("interacting");
+    } else {
         document.body.classList.remove("interacting");
     }
 }
+function _dec_interacting(callback_id) {
+    if(callback_id) delete window._htag_callbacks[callback_id];
+    _sync_interacting();
+}
 
 // --- htag-error Web Component (Shadow DOM for style isolation) ---
 class HtagError extends HTMLElement {
@@ -215,15 +214,15 @@ function handle_payload(data) {
     }
     // Resolve promise if a result is returned for a callback (even for errors)
     if(data.callback_id && window._htag_callbacks[data.callback_id]) {
-        _dec_interacting();
-        window._htag_callbacks[data.callback_id](data.result);
-        delete window._htag_callbacks[data.callback_id];
+        var resolve = window._htag_callbacks[data.callback_id];
+        _dec_interacting(data.callback_id);
+        resolve(data.result);
     }
 }
 
 function fallback() {
-    _interacting = 0;
-    document.body.classList.remove("interacting");
+    window._htag_callbacks = {};
+    _sync_interacting();
     if (use_fallback) return; 
     use_fallback = true;
     if(ws) ws.close(); // Ensure ws is torn down
@@ -286,13 +285,13 @@ window.htag_transport = window.htag_transport || function(payload) {
         }).then(response => {
 
             if (!response.ok) {
-                _dec_interacting();
+                _dec_interacting(payload.data.callback_id);
                 if(_error_overlay && typeof _error_overlay.show === 'function') {
                     _error_overlay.show("HTTP Error", `Server returned status: ${response.status}`);
                 }
             }
         }).catch(err => {
-            _dec_interacting();
+            _dec_interacting(payload.data.callback_id);
             console.error("htag event POST error:", err);
             if(_error_overlay && typeof _error_overlay.show === 'function') {
                 _error_overlay.show("Network Error", "Could not reach server to trigger event.");
@@ -312,7 +311,8 @@ function htag_event(id, event_name, event) {
         var target = event.target;
         if (target && target.tagName) {  // Ensure target is a DOM element
             // Check if the event source is a form or inside a form
-            var form = (target.tagName === 'FORM') ? target : target.closest('form');
+            //var form = (target.tagName === 'FORM') ? target : target.closest('form');
+            var form = (target.tagName === 'FORM') ? target : null;
             if (form && event_name === 'submit') {
                 // Collect all form data into value attribute (standard htag v2 pattern)
                 var formData = new FormData(form);
@@ -327,6 +327,8 @@ function htag_event(id, event_name, event) {
         data.key = event.key;
         data.pageX = event.pageX;
         data.pageY = event.pageY;
+        data.button = event.button;
+        data.which = event.which;
         
         // HashChangeEvent specifics
         if (event.newURL) data.newURL = event.newURL;
@@ -340,11 +342,11 @@ function htag_event(id, event_name, event) {
     }
 
     var payload = {id: id, event: event_name, data: data};
-    _inc_interacting();
-    window.htag_transport(payload);
 
     return new Promise(resolve => {
         window._htag_callbacks[callback_id] = resolve;
+        _sync_interacting();
+        window.htag_transport(payload);
     });
 }
 """

{htag-2.0.3 → htag-2.0.5}/htag/core.py

@@ -338,6 +338,7 @@ class GTag:  # aka "Generic Tag"
     _alt: str
     _title: str
     _tabindex: int | str
+    __iter__ = None  # Prevent iteration via __getitem__ fallback
 
     # --- Common Events (Type hints for IDE autocompletion) ---
     _onclick: Callable | str
@@ -477,8 +478,8 @@ class GTag:  # aka "Generic Tag"
                 # We use GTag directly to create the style (GTag is already in scope)
                 style_tag = GTag("style", scoped_css)
                 existing_statics = getattr(cls, "statics", [])
-                if not isinstance(existing_statics, list):
-                    existing_statics = []
+                if not isinstance(existing_statics, (list, tuple)):
+                    existing_statics = [existing_statics]
                 setattr(cls, "statics", list(existing_statics) + [style_tag])
                 setattr(cls, "_scoped_static", True)
 
@@ -548,70 +549,15 @@ class GTag:  # aka "Generic Tag"
     def __le__(self, other: Any) -> "GTag":
         return self.add(other)
 
-    def __setattr__(self, name: str, value: Any) -> None:
-        """
-        Magic attribute handling:
-        - Internal attributes (starting with _ and containing __) are set normally.
-        - Public names (not starting with _) are set normally.
-        - Attributes starting with '_' (HTML-mapped) are treated as HTML attributes.
-        - Attributes starting with '_on' are treated as event callbacks.
-        - Setting an HTML attribute or event marks the tag as 'dirty' for client-side update.
-        """
-        if (name.startswith("_") and "__" in name) or name in (
-            "childs",
-            "parent",
-            "tag",
-            "id",
-            "_reload",
-            "_browser_cleanup",
-        ):
-            super().__setattr__(name, value)
-        elif name.startswith("_on") and (callable(value) or isinstance(value, str)):
-            # Event (e.g., self._onclick = my_callback or self._onclick = "alert(1)")
-            print(f"DEPRECATION: Setting events via underscore prefix ('{name}') is deprecated. Use 'self[\"{name[1:]}\"] = ...' instead.")
-            with self.__lock:
-                self.__events[name[3:]] = value
-                self.__dirty = True
-        elif name.startswith("_"):
-            # HTML attribute (e.g., self._class = "foo")
-            print(f"DEPRECATION: Setting HTML attributes via underscore prefix ('{name}') is deprecated. Use 'self[\"{name[1:].replace('_', '-')}\"] = ...' instead.")
-            attr_name = name[1:].replace("_", "-")
-            with self.__lock:
-                self.__attrs[attr_name] = value
-                self.__dirty = True
-        else:
-            # Regular Python attribute
-            super().__setattr__(name, value)
-
-    def __getattr__(self, name: str) -> Any:
-        if name in ("_reload", "_browser_cleanup"):
-            return super().__getattribute__(name)
-        if name.startswith("_") and "__" not in name:
-            if name.startswith("_on"):
-                event_name = name[3:]
-                events = super().__getattribute__("_GTag__events")
-                if event_name in events:
-                    print(f"DEPRECATION: Accessing events via underscore prefix ('{name}') is deprecated. Use 'self[\"{name[1:]}\"]' instead.")
-                    return events[event_name]
-            else:
-                try:
-                    # Use super().__getattribute__ to avoid recursion loop with __getattr__
-                    attrs = super().__getattribute__("_GTag__attrs")
-                    attr_name = name[1:].replace("_", "-")
-                    if attr_name in attrs:
-                        print(f"DEPRECATION: Accessing HTML attributes via underscore prefix ('{name}') is deprecated. Use 'self[\"{attr_name}\"]' instead.")
-                        return attrs[attr_name]
-                except AttributeError:
-                    pass
-        return super().__getattribute__(name)
-
     def __getitem__(self, name: str) -> Any:
-        if name.startswith("on") and name[2:] in self.__events:
-            return self.__events[name[2:]]
-        return self.__attrs[name]
+        if isinstance(name, str):
+            if name.startswith("on") and name[2:] in self.__events:
+                return self.__events[name[2:]]
+            return self.__attrs[name]
+        raise TypeError(f"GTag indices must be strings, not {type(name).__name__}")
 
     def __setitem__(self, name: str, value: Any) -> None:
-        if name.startswith("on") and (callable(value) or isinstance(value, str)):
+        if isinstance(name, str) and name.startswith("on") and (callable(value) or isinstance(value, str)):
             with self.__lock:
                 self.__events[name[2:]] = value
                 self.__dirty = True
@@ -621,7 +567,7 @@ class GTag:  # aka "Generic Tag"
                 self.__dirty = True
 
     def __delitem__(self, name: str) -> None:
-        if name.startswith("on") and name[2:] in self.__events:
+        if isinstance(name, str) and name.startswith("on") and name[2:] in self.__events:
             with self.__lock:
                 del self.__events[name[2:]]
                 self.__dirty = True
@@ -694,7 +640,7 @@ class GTag:  # aka "Generic Tag"
         self.clear()
         self.add(str(value))
 
-    def clear(self) -> "GTag":
+    def clear(self, *content: Any) -> "GTag":
         with self.__lock:
             for child in self.childs:
                 if isinstance(child, GTag):
@@ -704,6 +650,9 @@ class GTag:  # aka "Generic Tag"
             self.childs = []
             self.__rendered_callables.clear()
             self.__dirty = True
+
+            if content:
+                self.add(*content)
         return self
 
     def _update_classes(self, fn: Callable[[list[str]], None]) -> "GTag":
@@ -786,6 +735,8 @@ class GTag:  # aka "Generic Tag"
             def collect(item: Any) -> None:
                 if isinstance(item, GTag):
                     item.parent = self
+                    if self.root is not None:
+                        item._trigger_mount()
                     tags.append(item)
                 elif isinstance(item, (list, tuple)):
                     for i in item:

{htag-2.0.3 → htag-2.0.5}/htag/runner.py

@@ -354,7 +354,7 @@ class AppRunner(BaseApp):
         self._walk_tree(tag, visitor)
 
     async def handle_event(self, msg: dict[str, Any], ws: WebSocket | None) -> None:
-        print(f"SERVERSIDE: handle_event {msg}")
+        logger.info(f"handle_event {msg}")
         tag_id: str | None = msg.get("id")
         event_name: str | None = msg.get("event")
 
@@ -406,7 +406,7 @@ class AppRunner(BaseApp):
                         res = True  # Convert to a simple truthy value
 
                     # Final broadcast after callback finishes, including the result if any
-                    await self.broadcast_updates(result=res, callback_id=callback_id)
+                    await self.broadcast_updates(result=res, callback_id=callback_id, ws=ws)
                 except Exception as e:
                     error_trace: str = traceback.format_exc()
                     error_msg: str = (
@@ -439,11 +439,19 @@ class AppRunner(BaseApp):
 
                     return
             else:
-                res = None
-                await self.broadcast_updates(result=res, callback_id=callback_id)
+                await self.broadcast_updates(result=None, callback_id=callback_id, ws=ws)
+        else:
+            # tag not found (or missing tag_id)
+            # if we have a callback_id, we MUST respond to resolve the client-side promise
+            data = msg.get("data", {})
+            callback_id = (
+                data.get("callback_id") if isinstance(data, dict) else None
+            )
+            if callback_id:
+                await self.broadcast_updates(result=None, callback_id=callback_id, ws=ws)
 
     async def broadcast_updates(
-        self, result: Any = None, callback_id: str | None = None
+        self, result: Any = None, callback_id: str | None = None, ws: WebSocket | None = None
     ) -> None:
         """
         Collects all pending updates (tags, JS calls, statics)
@@ -475,7 +483,7 @@ class AppRunner(BaseApp):
 
             # Send to websocket clients
             dead_ws: list[WebSocket] = []
-            for client in list(self.websockets):
+            for client in list(self.websockets) + ([ws] if ws and ws not in self.websockets else []):
                 try:
                     await client.send_text(err_payload)
                 except Exception:
@@ -517,7 +525,7 @@ class AppRunner(BaseApp):
 
             # Send to websocket clients
             dead_ws_clients: list[WebSocket] = []
-            for client in list(self.websockets):
+            for client in list(self.websockets) + ([ws] if ws and ws not in self.websockets else []):
                 try:
                     await client.send_text(payload)
                 except Exception:

{htag-2.0.3 → htag-2.0.5}/htag.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htag
-Version: 2.0.3
+Version: 2.0.5
 Summary: Python3 GUI toolkit for building 'beautiful' applications for mobile, web, and desktop from a single codebase
 Author: manatlan
 License: MIT
@@ -103,7 +103,7 @@ htag is a Python library for building web applications using HTML, CSS, and Java
 *   **Parano Mode (Payload Obfuscation)**: By initializing `WebApp(App, parano=True)`, all data exchanged between the frontend and backend is automatically obfuscated using a dynamic XOR cipher and Base64 wrapping, making network traffic unreadable to MITM proxies.
 *   **`.root`, `.parent`, and `.childs` properties**: Every `GTag` exposes its position in the component tree. `.root` references the main `Tag` instance, `.parent` references the direct parent component, and `.childs` is a list of its children. This allows components to easily navigate the DOM tree and trigger app-level actions.
 *   **Declarative UI with Context Managers (`with`)**: You can now build component trees visually using `with` blocks (e.g., `with Tag.div(): Tag.h1("Hello")`), removing the need for `self <= ...` boilerplate.
-*   **Modern Attribute Access (Dictionary Style)**: In addition to `Tag.div(_class="foo")` in constructors, you should now use `self["class"] = "foo"` for dynamic property management. This is the preferred way to handle all attributes, including those with dashes (e.g., `self["data-id"] = 123`).
+*   **Modern Attribute Access (Dictionary Style)**: In addition to `Tag.div(_class="foo")` in constructors, you must now use `self["class"] = "foo"` for dynamic property management after instantiation. This is the only way to handle all attributes, including those with dashes (e.g., `self["data-id"] = 123`).
 *   **Reactive State Management (`State`)**: Introducing `State(value)` for automatic UI reactivity. `State` acts as a transparent **Proxy**: you can use comparison/arithmetic operators directly (`if self.count > 0: ...`), mutate nested structures (including `lists`, `dicts`, `sets`, and `tuples`), and delegate attribute assignments seamlessly.
 *   **Iterative & Attribute Reactivity**: Iterating over a `State` now yields proxies, meaning mutations like `for item in self.list: item.active = True` trigger re-renders. Attribute assignments (e.g. `self.user.name = "Bob"`) are automatically delegated to the underlying object and notified.
 *   **Reactive & Boolean Attributes**: Attributes like `_class`, `_style`, or `_disabled` in constructors now support lambdas for dynamic updates. Boolean attributes (e.g. `_disabled=True`) are correctly rendered as key-only or omitted.

{htag-2.0.3 → htag-2.0.5}/htag.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ tests/test_cmd.py
 tests/test_core.py
 tests/test_deprecation_warnings.py
 tests/test_fallback.py
+tests/test_interacting_robustness.py
 tests/test_lifecycle.py
 tests/test_memory.py
 tests/test_parano.py

{htag-2.0.3 → htag-2.0.5}/pyproject.toml

@@ -9,7 +9,7 @@ include-package-data = true
 
 [project]
 name = "htag"
-version = "2.0.3"
+version = "2.0.5"
 description = "Python3 GUI toolkit for building 'beautiful' applications for mobile, web, and desktop from a single codebase"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -47,6 +47,7 @@ dev = [
     "pytest-asyncio>=1.3.0",
     "pytest-cov>=7.0.0",
     "pytest-playwright>=0.7.2",
+    "pytest-timeout>=2.4.0",
     "ruff>=0.15.4",
 ]
 

{htag-2.0.3 → htag-2.0.5}/tests/test_core.py

@@ -40,25 +40,38 @@ def test_gtag_clear():
     assert len(t.childs) == 0
     assert t._GTag__dirty is True
 
-def test_gtag_attr_magic():
-    t = Tag.div(_class="foo", _data_id="123")
-    assert t._class == "foo"
-    assert t._GTag__attrs["class"] == "foo"
-    assert t._GTag__attrs["data-id"] == "123"
-    assert t.id is not None
-    
-    t._class = "bar"
-    assert t._GTag__attrs["class"] == "bar"
+    # Test clear with arguments
+    t.add("one", "two")
+    t._GTag__dirty = False
+    t.clear("three", Tag.span("four"))
+    assert len(t.childs) == 2
+    assert t.childs[0] == "three"
+    assert t.childs[1].tag == "span"
     assert t._GTag__dirty is True
+
+# def test_gtag_attr_magic():
+#     t = Tag.div(_class="foo", _data_id="123")
+    
+#     # Initialization still sets HTML attributes (via kwargs)
+#     assert t["class"] == "foo"
+#     assert t["data-id"] == "123"
+#     assert t.id is not None
+    
+#     # Setting an attribute with an underscore should now just be a regular python attribute
+#     t._class = "bar"
+#     assert getattr(t, "_class") == "bar"
     
-    # Test line 103: regular python attribute
-    t.some_var = 42
-    assert t.some_var == 42
+#     # It should not affect the HTML attribute
+#     assert t["class"] == "foo"
     
-    # Test line 96: event setter
-    def other_h(e): pass
-    t._onmouseover = other_h
-    assert "mouseover" in t._GTag__events
+#     # Regular python attribute
+#     t.some_var = 42
+#     assert t.some_var == 42
+    
+#     # Test line 96: event setter
+#     def other_h(e): pass
+#     t._onmouseover = other_h
+#     assert "mouseover" in t._GTag__events
 
 def test_gtag_render_attrs():
     t = Tag.div(_class="foo", _data_id="123")
@@ -136,11 +149,11 @@ def test_add_class():
     # Test lines 140-146
     t = Tag.div()
     t.add_class("foo")
-    assert t._class == "foo"
+    assert t["class"] == "foo"
     t.add_class("bar")
-    assert t._class == "foo bar"
+    assert t["class"] == "foo bar"
     t.add_class("foo") # already there
-    assert t._class == "foo bar"
+    assert t["class"] == "foo bar"
 
 def test_remove_class():
     t = Tag.div(_class="foo bar")
@@ -148,17 +161,17 @@ def test_remove_class():
     # Remove existing class
     class_self = t.remove_class("foo")
     assert class_self is t
-    assert t._class == "bar"
+    assert t["class"] == "bar"
     
     # Remove non-existing class
     t._GTag__dirty = False
     t.remove_class("baz")
-    assert t._class == "bar"
+    assert t["class"] == "bar"
     assert t._GTag__dirty is False # Shouldn't be marked dirty if nothing was removed
     
     # Remove last class
     t.remove_class("bar")
-    assert t._class == ""
+    assert t["class"] == ""
 
 def test_gtag_iadd():
     t = Tag.div()
@@ -289,15 +302,15 @@ def test_toggle_class():
     # Toggle off existing class
     result = t.toggle_class("foo")
     assert result is t  # Returns self (chainable)
-    assert t._class == "bar"
+    assert t["class"] == "bar"
     
     # Toggle on missing class
     t.toggle_class("baz")
-    assert t._class == "bar baz"
+    assert t["class"] == "bar baz"
     
     # Toggle off again
     t.toggle_class("baz")
-    assert t._class == "bar"
+    assert t["class"] == "bar"
 
 def test_has_class():
     t = Tag.div(_class="foo bar")
@@ -640,3 +653,140 @@ def test_state_repr_str():
     s2 = State("hello")
     assert str(s2) == "hello"
     assert repr(s2) == "'hello'"
+
+def test_state_inplace_operators():
+    s = State(10)
+    s += 5; assert s.value == 15
+    s -= 5; assert s.value == 10
+    s *= 2; assert s.value == 20
+    s /= 2; assert s.value == 10.0
+    s //= 3; assert s.value == 3.0
+    s %= 2; assert s.value == 1.0
+    s **= 2; assert s.value == 1.0
+    
+    s = State(1)
+    s <<= 1; assert s.value == 2
+    s >>= 1; assert s.value == 1
+    s &= 1; assert s.value == 1
+    s ^= 0; assert s.value == 1
+    s |= 2; assert s.value == 3
+
+def test_state_fallback_setattr():
+    class Dummy: pass
+    d = Dummy()
+    s = State(d)
+    s.foo = "bar"
+    assert d.foo == "bar"
+    
+    # Coverage for line 73: AttributeError fallback
+    s2 = State(42) # int doesn't have __dict__ generally
+    s2.not_an_attr = "val"
+    assert s2.not_an_attr == "val"
+
+def test_state_proxy_advanced():
+    s = State([1, 2])
+    proxy = s[0] # Not actually a proxy for an int, it wraps the container
+    
+    # Test with a dict
+    s = State({"a": 1})
+    proxy = s._wrap(s.value)
+    
+    # getattr / setattr / delattr on proxy
+    class Obj:
+        def method(self): return 42
+    o = Obj()
+    s_obj = State(o)
+    proxy_obj = s_obj._wrap(o)
+    assert proxy_obj.method() == 42
+    
+    proxy_obj.x = 10
+    assert o.x == 10
+    del proxy_obj.x
+    assert not hasattr(o, "x")
+    
+    # __delitem__ / __len__ / __iter__ / __contains__
+    s_list = State([10, 20])
+    p_list = s_list._wrap(s_list.value)
+    del p_list[0]
+    assert p_list() == [20]
+    assert len(p_list) == 1
+    assert list(iter(p_list)) == [20]
+    assert 20 in p_list
+    
+    # operators
+    assert p_list == [20]
+    assert p_list < [30]
+    assert p_list + [30] == [20, 30]
+    
+    # __call__ observer reg
+    t = Tag.div()
+    from htag.core import _ctx
+    _ctx.current_eval = t
+    p_list()
+    assert t in s_list._observers
+    _ctx.current_eval = None
+
+def test_gtag_edge_cases():
+    # Tag(None) -> fragment
+    t = GTag(None, "content")
+    assert t.tag is None
+    assert str(t) == "content"
+    
+    # statics as single object + styles to trigger list conversion in __init__
+    class StaticTag(GTag):
+        statics = Tag.style(".foo{}")
+        styles = ".bar {color:red}"
+    st = StaticTag()
+    # Now statics is the list [original_static, scoped_static]
+    all_statics = getattr(StaticTag, "statics")
+    assert isinstance(all_statics, list)
+    assert any(".foo{}" in str(s) for s in all_statics)
+    
+    # add(None)
+    t.add(None)
+    assert len(t.childs) == 1 # still just "content"
+    
+    # __getattr__ missing
+    try:
+        t.non_existent
+    except AttributeError:
+        pass
+    
+    # __getitem__ TypeError
+    try:
+        t[0]
+    except TypeError:
+        pass
+
+    # __delitem__ KeyError
+    try:
+        del t["missing"]
+    except KeyError:
+        pass
+
+def test_gtag_reactive_lifecycle():
+    # Test that components inside lambdas trigger lifecycle
+    c = Tag.span()
+    mounted = False
+    def on_m(): nonlocal mounted; mounted = True
+    c.on_mount = on_m
+    
+    app = Tag.App()
+    t = Tag.div(lambda: c)
+    app.add(t)
+    
+    # Trigger render
+    str(app)
+    assert c.root is app
+    assert mounted is True
+
+def test_gtag_reactive_list_none():
+    t = Tag.div(lambda: [Tag.b("1"), Tag.i("2")])
+    rendered = str(t)
+    assert "<b" in rendered
+    assert ">1</b>" in rendered
+    assert "<i" in rendered
+    assert ">2</i>" in rendered
+    
+    t2 = Tag.div(lambda: None)
+    assert str(t2).strip().endswith("></div>")

htag-2.0.5/tests/test_deprecation_warnings.py

@@ -0,0 +1,38 @@
+import pytest
+import logging
+from htag import Tag
+
+def test_instantiation_no_warning(capsys):
+    """
+    Ensures that underscore-prefixed attributes during instantiation
+    do NOT trigger a deprecation warning.
+    """
+    t = Tag.div(_class="myclass", _onclick="alert(1)")
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert t["class"] == "myclass"
+    assert t["onclick"] == "alert(1)"
+
+def test_instantiation_no_warning(capsys):
+    """
+    Ensures that underscore-prefixed attributes during instantiation
+    do NOT trigger a deprecation warning anymore AND correctly map to HTML attributes.
+    """
+    t = Tag.div(_class="myclass", _onclick="alert(1)")
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert t["class"] == "myclass"
+    assert t["onclick"] == "alert(1)"
+
+
+def test_getattr_no_warning_on_missing(capsys):
+    """
+    Accessing a non-existent underscore attribute should still raise AttributeError or return what super does,
+    but shouldn't warn if it doesn't exist in attrs/events.
+    """
+    t = Tag.div()
+    _ = capsys.readouterr() # clear
+    with pytest.raises(AttributeError):
+        _ = t._non_existent
+    captured = capsys.readouterr()
+    assert captured.out == ""

htag-2.0.5/tests/test_interacting_robustness.py

@@ -0,0 +1,65 @@
+import asyncio
+import pytest
+from htag import Tag
+from htag.runner import AppRunner
+
+class MyTag(Tag.div):
+    def init(self):
+        self.count = 0
+    def click(self):
+        self.count += 1
+        return self.count
+
+@pytest.mark.asyncio
+async def test_handle_event_invalid_tag_responds():
+    app = AppRunner(MyTag)
+    
+    # Simulate an event to a non-existent tag ID
+    msg = {
+        "id": "non-existent-id",
+        "event": "click",
+        "data": {"callback_id": "cb123"}
+    }
+    
+    responses = []
+    class MockWS:
+        async def send_text(self, text):
+            responses.append(text)
+        async def accept(self): pass
+        async def receive_text(self): pass
+        
+    await app.handle_event(msg, MockWS())
+    
+    assert len(responses) == 1
+    import json
+    from htag.utils import _obf_loads
+    resp = _obf_loads(responses[0], None)
+    assert resp["action"] == "update"
+    assert resp["callback_id"] == "cb123"
+    assert resp["result"] is None
+
+@pytest.mark.asyncio
+async def test_handle_event_missing_event_responds():
+    app = AppRunner(MyTag)
+    
+    # Tag exists but event doesn't
+    tag = MyTag()
+    app.add(tag) 
+    
+    msg = {
+        "id": tag.id,
+        "event": "unknown_event",
+        "data": {"callback_id": "cb456"}
+    }
+    
+    responses = []
+    class MockWS:
+        async def send_text(self, text):
+            responses.append(text)
+            
+    await app.handle_event(msg, MockWS())
+    
+    assert len(responses) == 1
+    from htag.utils import _obf_loads
+    resp = _obf_loads(responses[0], None)
+    assert resp["callback_id"] == "cb456"

{htag-2.0.3 → htag-2.0.5}/tests/test_parano.py

@@ -61,3 +61,22 @@ def test_webapp_parano_mode():
     assert resp_post.status_code == 200
     assert resp_post.json() == {"status": "ok"}
 
+def test_webapp_csrf_failure():
+    app_host = WebApp(MyApp)
+    client = TestClient(app_host.app)
+    
+    # Get session
+    response = client.get("/")
+    cookies = response.cookies
+    
+    # Try to POST without X-HTAG-TOKEN
+    payload = {"id": "b1", "event": "click"}
+    resp = client.post("/event", json=payload)
+    assert resp.status_code == 403
+    assert "CSRF Token mismatch" in resp.text
+    
+    # Try with WRONG token
+    headers = {"X-HTAG-TOKEN": "wrong_token"}
+    resp = client.post("/event", json=payload, headers=headers)
+    assert resp.status_code == 403
+

{htag-2.0.3 → htag-2.0.5}/tests/test_reactivity_edge_cases.py

@@ -89,7 +89,7 @@ async def test_generator_event_handler():
     app = MyApp()
     # We need to mock broadcast_updates to avoid network calls
     broadcasts = []
-    async def mock_broadcast(result=None, callback_id=None):
+    async def mock_broadcast(result=None, callback_id=None, **kwargs):
         broadcasts.append((result, callback_id))
     app.broadcast_updates = mock_broadcast
     
@@ -122,7 +122,7 @@ async def test_async_generator_event_handler():
 
     app = MyApp()
     broadcasts = []
-    async def mock_broadcast(result=None, callback_id=None):
+    async def mock_broadcast(result=None, callback_id=None, **kwargs):
         broadcasts.append((result, callback_id))
     app.broadcast_updates = mock_broadcast
     

{htag-2.0.3 → htag-2.0.5}/tests/test_server.py

@@ -153,6 +153,23 @@ async def test_app_handle_event_error():
     assert "boom" in data["traceback"]
     assert data["callback_id"] == "error1"
 
+@pytest.mark.asyncio
+async def test_app_handle_event_error_stdout(capsys):
+    app = App()
+    def fail(e):
+        raise ValueError("stdout boom")
+    
+    btn = Tag.button(_onclick=fail)
+    app += btn
+    
+    ws = AsyncMock()
+    msg = {"id": btn.id, "event": "click", "data": {}}
+    
+    await app.handle_event(msg, ws)
+    
+    captured = capsys.readouterr()
+    assert "ValueError: stdout boom" in captured.out
+
 @pytest.mark.asyncio
 async def test_app_handle_event_async_error():
     app = App()
@@ -269,7 +286,7 @@ async def test_app_handle_event_value_sync():
     ws = AsyncMock()
     msg = {"id": inp.id, "event": "input", "data": {"value": "new"}}
     await app.handle_event(msg, ws)
-    assert inp._value == "new"
+    assert inp["value"] == "new"
 
 @pytest.mark.asyncio
 async def test_app_handle_event_async_generator():

{htag-2.0.3 → htag-2.0.5}/tests/test_simple_events.py

@@ -42,7 +42,7 @@ async def test_app_handle_simple_event():
     # We simulate a tag that has a custom event handler
     class MyTag(Tag.div):
         def init(self):
-            self._oncustom = my_cb
+            self["oncustom"] = my_cb
             
     tag = MyTag()
     app += tag
@@ -66,7 +66,7 @@ async def test_app_handle_hashchange_event():
         shared["new"] = e.newURL
         shared["old"] = e.oldURL
         
-    app._onhashchange = on_hash
+    app["onhashchange"] = on_hash
     
     ws = AsyncMock()
     msg = {
@@ -129,7 +129,7 @@ async def test_app_handle_form_event():
         
     class MyForm(Tag.form):
         def init(self):
-            self._onsubmit = on_submit
+            self["onsubmit"] = on_submit
             
     tag = MyForm()
     app += tag

htag-2.0.3/tests/test_deprecation_warnings.py

@@ -1,74 +0,0 @@
-import pytest
-import logging
-from htag import Tag
-
-def test_instantiation_no_warning(capsys):
-    """
-    Ensures that underscore-prefixed attributes during instantiation
-    do NOT trigger a deprecation warning.
-    """
-    t = Tag.div(_class="myclass", _onclick="alert(1)")
-    captured = capsys.readouterr()
-    assert captured.out == ""
-    assert t["class"] == "myclass"
-    assert t["onclick"] == "alert(1)"
-
-def test_getattr_warning(capsys):
-    """
-    Ensures that accessing underscore-prefixed attributes triggers a warning.
-    """
-    t = Tag.div(_class="myclass")
-    _ = capsys.readouterr() # clear
-    c = t._class
-    assert c == "myclass"
-    captured = capsys.readouterr()
-    assert "DEPRECATION" in captured.out
-    assert "Accessing HTML attributes via underscore prefix ('_class')" in captured.out
-
-def test_setattr_warning(capsys):
-    """
-    Ensures that setting underscore-prefixed attributes triggers a warning.
-    """
-    t = Tag.div()
-    _ = capsys.readouterr() # clear
-    t._class = "newclass"
-    assert t["class"] == "newclass"
-    captured = capsys.readouterr()
-    assert "DEPRECATION" in captured.out
-    assert "Setting HTML attributes via underscore prefix ('_class')" in captured.out
-
-def test_get_event_warning(capsys):
-    """
-    Ensures that accessing underscore-prefixed events triggers a warning.
-    """
-    t = Tag.div(_onclick="alert(1)")
-    _ = capsys.readouterr() # clear
-    oc = t._onclick
-    assert oc == "alert(1)"
-    captured = capsys.readouterr()
-    assert "DEPRECATION" in captured.out
-    assert "Accessing events via underscore prefix ('_onclick')" in captured.out
-
-def test_set_event_warning(capsys):
-    """
-    Ensures that setting underscore-prefixed events triggers a warning.
-    """
-    t = Tag.div()
-    _ = capsys.readouterr() # clear
-    t._onclick = "alert(2)"
-    assert t["onclick"] == "alert(2)"
-    captured = capsys.readouterr()
-    assert "DEPRECATION" in captured.out
-    assert "Setting events via underscore prefix ('_onclick')" in captured.out
-
-def test_getattr_no_warning_on_missing(capsys):
-    """
-    Accessing a non-existent underscore attribute should still raise AttributeError or return what super does,
-    but shouldn't warn if it doesn't exist in attrs/events.
-    """
-    t = Tag.div()
-    _ = capsys.readouterr() # clear
-    with pytest.raises(AttributeError):
-        _ = t._non_existent
-    captured = capsys.readouterr()
-    assert captured.out == ""