htag 2.0.0__tar.gz → 2.0.2__tar.gz

{htag-2.0.0 → htag-2.0.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: htag
-Version: 2.0.0
-Summary: A modern, state-of-the-art Python GUI framework
+Version: 2.0.2
+Summary: Python3 GUI toolkit for building 'beautiful' applications for mobile, web, and desktop from a single codebase
 Author: manatlan
 License: MIT
 Project-URL: Homepage, https://github.com/manatlan/htag
@@ -37,31 +37,46 @@ Requires-Dist: websockets>=16.0
   </a>
 </p>
 
-Here is a full rewrite of **htag 1.0.0**, using only antigravity and prompts/intentions.
+**htag** is a Python3 GUI toolkit for building "beautiful" applications for mobile, web, and desktop from a single codebase
 
-It feels very good. Currently, it's the future of htag.
+Here is a full rewrite of **htag 1.0.0**, using only antigravity and prompts/intentions. It's the future of **htag**.
 
 Currently, it works ...
 
-- For building desktop apps (ChromeApp on linux/windows)
+- For building desktop apps (ChromeApp on linux/windows/mac, or simple WebApp)
 - For building web apps (WebApp as an asgi app (for starlette/fastapi/...))
 - For building SPA HTML Page (with the PyScript runner)
 - For building android apps ([it works](examples/app_android/README.md), **but need to improve**)
 
+## Major differences between v1 and v2
+
+- A lot simpler & more reactive
+- `Tag.App` is the main app component
+- Full starlette compliant from the ground
+- Websocket communication, if fails : fallback to HTTP SSE
+- No more generic Runner
+- State object for reactivity
+- DX: errors are a lot better handled/viewable, hot-reload available
+- Better events
+- less boilerplate (kiss minded)
+- Styles can be scoped by component
+- ...
+
 
 ## Get Started
 
-Check the [Official Documentation](https://manatlan.github.io/htag/) for more information.
+Check the [Official V2 Documentation](https://manatlan.github.io/htag/) for more information. [old v1 docs](https://manatlan.github.io/htag/v1/)
+
 
 ## Install
 
 ```bash
-uv add htag
+uv add htag -U
 ```
 
 Or using pip:
 ```bash
-pip install htag
+pip install -U htag
 ```
 
 Alternatively, you can run from source:
@@ -73,35 +88,42 @@ uv run examples/main3.py
 
 ### Skill
 
-With gemini-cli, claude-code, mistral-vibe (or others), you can use this [SKILL.md](.agent/skills/htag-development/SKILL.md) to create a htag application.
+With agentic llm, you can use this [SKILL.md](.agent/skills/htag-development/SKILL.md) to create an htag application.
 
 
 ## Antigravity resumes :
 
 htag is a Python library for building web applications using HTML, CSS, and JavaScript.
 
-### Key Resiliency Features Added
+### New Features
 *   **Zero-Config Hot-Reload**: Passing `reload=True` to any runner (e.g. `ChromeApp(App).run(reload=True)`) automatically watches for Python file changes, seamlessly restarts the backend, and gracefully refreshes the frontend without losing your browser window session.
 *   **F5/Reload Robustness**: Refreshing the browser no longer kills the Python backend; the session reconstructs cleanly.
 *   **HTTP Fallback (SSE + POST)**: If WebSockets are blocked (e.g. strict proxies) or fail to connect, the client seamlessly falls back to HTTP POST for events and Server-Sent Events (SSE) for receiving UI updates.
 *   **Production Debug Mode**: Easily disable error reporting in the client by setting `debug=False` on the runner (e.g. `WebApp(App, debug=False).app`), preventing internal stacktraces from leaking to users.
 *   **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.
-
-### New API Features
 *   **`.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.
-*   **Dual Attribute Access (Dictionary Style)**: In addition to `self._class = "foo"`, you can now use `self["class"] = "foo"`. This is the preferred way to handle attributes with dashes (e.g., `self["data-id"] = 123`).
-*   **Automatic Attribute Normalization**: HTML attributes are normalized to use dashes internally. Setting `self._data_id = "123"` is strictly equivalent to setting `self["data-id"] = "123"`.
+*   **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`).
 *   **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` now support lambdas for dynamic updates. Boolean attributes (e.g. `_disabled=True`) are correctly rendered as key-only or omitted.
+*   **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.
 *   **Simplified Removal (`.remove()`)**: To remove a component from its parent, simply call `self.remove()` without arguments.
 *   **Rapid Content Replacement (`.text`)**: Use the `.text` property on any tag to quickly replace its inner text content without needing to manually clear its children first.
 *   **Recursive Statics & JS**: Components created dynamically (via lambdas) now have their `statics` (CSS) and `call_js` commands correctly collected and sent to the client.
 *   **Scoped Styles (`styles`)**: Define a `styles` class attribute on any component to get automatically scoped CSS. The framework prefixes every rule with `.htag-ClassName`, handles `@media`, `@keyframes`, pseudo-selectors, and multi-selectors.
 *   **CSS Class Helpers**: `add_class()`, `remove_class()`, `toggle_class()`, and `has_class()` for convenient class manipulation without manual string handling.
-*   **Simple Events & HashChange**: Support for passing primitive values or custom objects from JS (via `tag["onclick"] = func` or `tag._onclick = func`). Includes built-in support for `_onhashchange`.
+*   **Simple Events & HashChange**: Support for passing primitive values or custom objects from JS (via `tag["onclick"] = func`). Includes built-in support for `onhashchange`.
 *   **Fragments (`Tag()`)**: Create virtual components that group children without adding a wrapper tag to the DOM.
 *   **Advanced Tag Search (`.find_tag()`)**: Effortlessly locate any component in the tree by its internal htag ID or its manually assigned HTML `id`.
 *   **Custom ID Resilience**: Manual HTML `id` attributes are now supported without breaking htag's reactive partial updates, thanks to an automatic `data-htag-id` fallback mechanism.
 *   **Automatic Attribute Assignment**: Non-prefixed keyword arguments passed during component instantiation are automatically assigned as instance attributes, simplifying data passing to custom components.
+*   **Unified Form Handling**: When a `Tag.form` is submitted, all input fields are automatically collected into a dictionary and passed as `event.value`. You can conveniently access fields using square brackets on the event object (e.g., `e["fieldname"]`).
+
+
+## History
+
+At the beginning, there was [guy](https://github.com/manatlan/guy), which was/is the same concept as [python-eel](https://github.com/ChrisKnott/Eel), but more advanced.
+One day, I've discovered [remi](https://github.com/rawpython/remi), and asked my self, if it could be done in a *guy way*. The POC was very good, so I released
+a version of it, named [gtag](https://github.com/manatlan/gtag). It worked well despite some drawbacks, but was too difficult to maintain. So I decided to rewrite all
+from scratch, while staying away from *guy* (to separate, *rendering* and *runners*)... and [htag](https://github.com/manatlan/htag/tree/v1-legacy) was born. The codebase is very short, concepts are better implemented, and it's very easy to maintain. And now (2026) [htag v2](https://github.com/manatlan/htag) is here (a full rewrite of v1 with antigravity) !
+

{htag-2.0.0 → htag-2.0.2}/README.md

@@ -16,31 +16,46 @@
   </a>
 </p>
 
-Here is a full rewrite of **htag 1.0.0**, using only antigravity and prompts/intentions.
+**htag** is a Python3 GUI toolkit for building "beautiful" applications for mobile, web, and desktop from a single codebase
 
-It feels very good. Currently, it's the future of htag.
+Here is a full rewrite of **htag 1.0.0**, using only antigravity and prompts/intentions. It's the future of **htag**.
 
 Currently, it works ...
 
-- For building desktop apps (ChromeApp on linux/windows)
+- For building desktop apps (ChromeApp on linux/windows/mac, or simple WebApp)
 - For building web apps (WebApp as an asgi app (for starlette/fastapi/...))
 - For building SPA HTML Page (with the PyScript runner)
 - For building android apps ([it works](examples/app_android/README.md), **but need to improve**)
 
+## Major differences between v1 and v2
+
+- A lot simpler & more reactive
+- `Tag.App` is the main app component
+- Full starlette compliant from the ground
+- Websocket communication, if fails : fallback to HTTP SSE
+- No more generic Runner
+- State object for reactivity
+- DX: errors are a lot better handled/viewable, hot-reload available
+- Better events
+- less boilerplate (kiss minded)
+- Styles can be scoped by component
+- ...
+
 
 ## Get Started
 
-Check the [Official Documentation](https://manatlan.github.io/htag/) for more information.
+Check the [Official V2 Documentation](https://manatlan.github.io/htag/) for more information. [old v1 docs](https://manatlan.github.io/htag/v1/)
+
 
 ## Install
 
 ```bash
-uv add htag
+uv add htag -U
 ```
 
 Or using pip:
 ```bash
-pip install htag
+pip install -U htag
 ```
 
 Alternatively, you can run from source:
@@ -52,35 +67,42 @@ uv run examples/main3.py
 
 ### Skill
 
-With gemini-cli, claude-code, mistral-vibe (or others), you can use this [SKILL.md](.agent/skills/htag-development/SKILL.md) to create a htag application.
+With agentic llm, you can use this [SKILL.md](.agent/skills/htag-development/SKILL.md) to create an htag application.
 
 
 ## Antigravity resumes :
 
 htag is a Python library for building web applications using HTML, CSS, and JavaScript.
 
-### Key Resiliency Features Added
+### New Features
 *   **Zero-Config Hot-Reload**: Passing `reload=True` to any runner (e.g. `ChromeApp(App).run(reload=True)`) automatically watches for Python file changes, seamlessly restarts the backend, and gracefully refreshes the frontend without losing your browser window session.
 *   **F5/Reload Robustness**: Refreshing the browser no longer kills the Python backend; the session reconstructs cleanly.
 *   **HTTP Fallback (SSE + POST)**: If WebSockets are blocked (e.g. strict proxies) or fail to connect, the client seamlessly falls back to HTTP POST for events and Server-Sent Events (SSE) for receiving UI updates.
 *   **Production Debug Mode**: Easily disable error reporting in the client by setting `debug=False` on the runner (e.g. `WebApp(App, debug=False).app`), preventing internal stacktraces from leaking to users.
 *   **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.
-
-### New API Features
 *   **`.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.
-*   **Dual Attribute Access (Dictionary Style)**: In addition to `self._class = "foo"`, you can now use `self["class"] = "foo"`. This is the preferred way to handle attributes with dashes (e.g., `self["data-id"] = 123`).
-*   **Automatic Attribute Normalization**: HTML attributes are normalized to use dashes internally. Setting `self._data_id = "123"` is strictly equivalent to setting `self["data-id"] = "123"`.
+*   **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`).
 *   **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` now support lambdas for dynamic updates. Boolean attributes (e.g. `_disabled=True`) are correctly rendered as key-only or omitted.
+*   **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.
 *   **Simplified Removal (`.remove()`)**: To remove a component from its parent, simply call `self.remove()` without arguments.
 *   **Rapid Content Replacement (`.text`)**: Use the `.text` property on any tag to quickly replace its inner text content without needing to manually clear its children first.
 *   **Recursive Statics & JS**: Components created dynamically (via lambdas) now have their `statics` (CSS) and `call_js` commands correctly collected and sent to the client.
 *   **Scoped Styles (`styles`)**: Define a `styles` class attribute on any component to get automatically scoped CSS. The framework prefixes every rule with `.htag-ClassName`, handles `@media`, `@keyframes`, pseudo-selectors, and multi-selectors.
 *   **CSS Class Helpers**: `add_class()`, `remove_class()`, `toggle_class()`, and `has_class()` for convenient class manipulation without manual string handling.
-*   **Simple Events & HashChange**: Support for passing primitive values or custom objects from JS (via `tag["onclick"] = func` or `tag._onclick = func`). Includes built-in support for `_onhashchange`.
+*   **Simple Events & HashChange**: Support for passing primitive values or custom objects from JS (via `tag["onclick"] = func`). Includes built-in support for `onhashchange`.
 *   **Fragments (`Tag()`)**: Create virtual components that group children without adding a wrapper tag to the DOM.
 *   **Advanced Tag Search (`.find_tag()`)**: Effortlessly locate any component in the tree by its internal htag ID or its manually assigned HTML `id`.
 *   **Custom ID Resilience**: Manual HTML `id` attributes are now supported without breaking htag's reactive partial updates, thanks to an automatic `data-htag-id` fallback mechanism.
 *   **Automatic Attribute Assignment**: Non-prefixed keyword arguments passed during component instantiation are automatically assigned as instance attributes, simplifying data passing to custom components.
+*   **Unified Form Handling**: When a `Tag.form` is submitted, all input fields are automatically collected into a dictionary and passed as `event.value`. You can conveniently access fields using square brackets on the event object (e.g., `e["fieldname"]`).
+
+
+## History
+
+At the beginning, there was [guy](https://github.com/manatlan/guy), which was/is the same concept as [python-eel](https://github.com/ChrisKnott/Eel), but more advanced.
+One day, I've discovered [remi](https://github.com/rawpython/remi), and asked my self, if it could be done in a *guy way*. The POC was very good, so I released
+a version of it, named [gtag](https://github.com/manatlan/gtag). It worked well despite some drawbacks, but was too difficult to maintain. So I decided to rewrite all
+from scratch, while staying away from *guy* (to separate, *rendering* and *runners*)... and [htag](https://github.com/manatlan/htag/tree/v1-legacy) was born. The codebase is very short, concepts are better implemented, and it's very easy to maintain. And now (2026) [htag v2](https://github.com/manatlan/htag) is here (a full rewrite of v1 with antigravity) !
+

{htag-2.0.0 → htag-2.0.2}/htag/cli.py

@@ -176,7 +176,7 @@ version = 1.0
 source.dir = .
 source.include_exts = py,png,jpg,jpeg,svg,js,css,html
 
-requirements = android,htag,starlette,uvicorn,websockets,anyio,typing_extensions,click,httpx,h11
+requirements = android,htag>=2.0.0,starlette,uvicorn,websockets,anyio,typing_extensions,click,httpx,h11
 orientation = {orientation}
 fullscreen = {fullscreen}
 android.archs = {android_archs}

{htag-2.0.0 → htag-2.0.2}/htag/client_js.py

@@ -143,6 +143,7 @@ function init_ws() {
 
 function handle_payload(data) {
     if(data.action == "update") {
+        console.log("htag: processing payload updates:", Object.keys(data.updates || {}));
         // Apply partial DOM updates received from the server
         for(var id in data.updates) {
             var el = document.getElementById(id) || document.querySelector('[data-htag-id="' + id + '"]');
@@ -153,21 +154,46 @@ function handle_payload(data) {
         if(_error_overlay && _error_overlay.parentNode !== document.body) {
             document.body.appendChild(_error_overlay);
         }
-        // Execute any JavaScript calls emitted by the Python tags
-        if(data.js) {
-            for(var i=0; i<data.js.length; i++) eval(data.js[i]);
-        }
-        // Inject new css/js statics if they haven't been loaded yet
+        // 1. Inject new css/js statics if they haven't been loaded yet (BEFORE JS calls)
         if(data.statics) {
             data.statics.forEach(s => {
-                var div = document.createElement('div');
-                div.innerHTML = s.trim();
-                var node = div.firstChild;
-                if (node && (node.tagName === "STYLE" || node.tagName === "LINK")) {
-                    document.head.appendChild(node);
+                try {
+                    var div = document.createElement('div');
+                    div.innerHTML = s.trim();
+                    var node = div.firstChild;
+                    if (!node) return;
+                    
+                    if (node.tagName === "STYLE" || node.tagName === "LINK") {
+                        document.head.appendChild(node);
+                    } else if (node.tagName === "SCRIPT") {
+                        var script = document.createElement('script');
+                        script.async = false; // Force sequential execution for multiple dynamic scripts
+                        for (var i = 0; i < node.attributes.length; i++) {
+                            var attr = node.attributes[i];
+                            script.setAttribute(attr.name, attr.value);
+                        }
+                        if (node.textContent) script.textContent = node.textContent;
+                        document.head.appendChild(script);
+                    }
+                } catch(e) {
+                    console.error("htag: static injection error", s, e);
                 }
             });
         }
+
+        // 2. Execute any JavaScript calls emitted by the Python tags
+        if(data.js) {
+            for(var i=0; i<data.js.length; i++) {
+                try {
+                    eval(data.js[i]);
+                } catch(e) {
+                    console.error("htag: eval error for", data.js[i], e);
+                    if(_error_overlay && typeof _error_overlay.show === 'function') {
+                        _error_overlay.show("JS Eval Error", e.message + "\\nSource: " + data.js[i]);
+                    }
+                }
+            }
+        }
         // Resolve promise if a result is returned for a callback
         if(data.callback_id && window._htag_callbacks[data.callback_id]) {
             window._htag_callbacks[data.callback_id](data.result);
@@ -262,11 +288,19 @@ function htag_event(id, event_name, event) {
 
     if (event instanceof Event) {
         // Standard DOM Event
-        if (event.target) {
-            if (event.target.type === 'checkbox') {
-                data.value = event.target.checked;
+        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');
+            if (form && event_name === 'submit') {
+                // Collect all form data into value attribute (standard htag v2 pattern)
+                var formData = new FormData(form);
+                data.value = {};
+                formData.forEach((v, k) => { data.value[k] = v; });
+            } else if (target.type === 'checkbox') {
+                data.value = target.checked;
             } else {
-                data.value = event.target.value;
+                data.value = target.value;
             }
         }
         data.key = event.key;
@@ -285,7 +319,6 @@ function htag_event(id, event_name, event) {
     }
 
     var payload = {id: id, event: event_name, data: data};
-    
     window.htag_transport(payload);
 
     return new Promise(resolve => {

{htag-2.0.0 → htag-2.0.2}/htag/core.py

@@ -562,15 +562,27 @@ class GTag:  # aka "Generic Tag"
             "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)")
+            logger.warning(
+                "DEPRECATION: Setting events via underscore prefix ('%s') is deprecated. Use 'self[\"%s\"] = ...' instead.",
+                name,
+                name[1:],
+            )
             with self.__lock:
                 self.__events[name[3:]] = value
                 self.__dirty = True
         elif name.startswith("_"):
             # HTML attribute (e.g., self._class = "foo")
+            logger.warning(
+                "DEPRECATION: Setting HTML attributes via underscore prefix ('%s') is deprecated. Use 'self[\"%s\"] = ...' instead.",
+                name,
+                name[1:].replace("_", "-"),
+            )
             attr_name = name[1:].replace("_", "-")
             with self.__lock:
                 self.__attrs[attr_name] = value
@@ -580,15 +592,33 @@ class GTag:  # aka "Generic Tag"
             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:
-            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:
-                    return attrs[attr_name]
-            except AttributeError:
-                pass
+            if name.startswith("_on"):
+                event_name = name[3:]
+                events = super().__getattribute__("_GTag__events")
+                if event_name in events:
+                    logger.warning(
+                        "DEPRECATION: Accessing events via underscore prefix ('%s') is deprecated. Use 'self[\"%s\"]' instead.",
+                        name,
+                        name[1:],
+                    )
+                    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:
+                        logger.warning(
+                            "DEPRECATION: Accessing HTML attributes via underscore prefix ('%s') is deprecated. Use 'self[\"%s\"]' instead.",
+                            name,
+                            attr_name,
+                        )
+                        return attrs[attr_name]
+                except AttributeError:
+                    pass
         return super().__getattribute__(name)
 
     def __getitem__(self, name: str) -> Any:

{htag-2.0.0 → htag-2.0.2}/htag/runner.py

@@ -34,13 +34,18 @@ class Event:
         self.target = target
         self.id: str = msg.get("id", "")
         self.name: str = msg.get("event", "")
+        # The primary data payload (htag v2 pattern)
+        self.value = msg.get("data")
         # Flat access to msg['data'] (e.g., e.value, e.x, etc.)
-        data = msg.get("data", {})
-        if isinstance(data, dict):
-            for k, v in data.items():
-                setattr(self, k, v)
-        else:
-            self.value = data
+        data = self.value if isinstance(self.value, dict) else {}
+        for k, v in data.items():
+            setattr(self, k, v)
+
+    def __getitem__(self, name: str) -> Any:
+        val = getattr(self, "value", None)
+        if isinstance(val, dict) and name in val:
+            return val[name]
+        return getattr(self, name, None)
 
     def __getattr__(self, name: str) -> Any:
         return None
@@ -270,6 +275,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}")
         tag_id: str | None = msg.get("id")
         event_name: str | None = msg.get("event")
 

{htag-2.0.0 → htag-2.0.2}/htag/runners/chromeapp.py

@@ -203,7 +203,8 @@ class ChromeApp:
         def on_inst(inst: App) -> None:
             inst.exit_on_disconnect = True
             if self._cleanup_func:
-                setattr(inst, "_browser_cleanup", self._cleanup_func)
+                # Use object.__setattr__ to bypass GTag.__setattr__ and avoid deprecation warning
+                object.__setattr__(inst, "_browser_cleanup", self._cleanup_func)
 
         if not inspect.isclass(self.app):
             self.app.exit_on_disconnect = True

{htag-2.0.0 → htag-2.0.2}/htag/web.py

@@ -93,14 +93,10 @@ class WebApp:
                     token = current_request.set(request_or_ws)
                     try:
                         if inspect.isclass(self.tag_entity):
-                            if issubclass(self.tag_entity, BaseApp):
-                                self.instances[sid] = self.tag_entity()
-                            else:
-                                # Wrap plain GTag class in an App runner
-                                self.instances[sid] = AppRunner(self.tag_entity)
+                            self.instances[sid] = self.tag_entity()
                             logger.info("Created new session instance for sid: %s", sid)
                         else:
-                            # tag_entity is an App instance
+                            # tag_entity is an App instance (shared)
                             self.instances[sid] = self.tag_entity  # type: ignore
                             logger.info(
                                 "Using shared instance for session sid: %s", sid

{htag-2.0.0 → htag-2.0.2}/htag.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: htag
-Version: 2.0.0
-Summary: A modern, state-of-the-art Python GUI framework
+Version: 2.0.2
+Summary: Python3 GUI toolkit for building 'beautiful' applications for mobile, web, and desktop from a single codebase
 Author: manatlan
 License: MIT
 Project-URL: Homepage, https://github.com/manatlan/htag
@@ -37,31 +37,46 @@ Requires-Dist: websockets>=16.0
   </a>
 </p>
 
-Here is a full rewrite of **htag 1.0.0**, using only antigravity and prompts/intentions.
+**htag** is a Python3 GUI toolkit for building "beautiful" applications for mobile, web, and desktop from a single codebase
 
-It feels very good. Currently, it's the future of htag.
+Here is a full rewrite of **htag 1.0.0**, using only antigravity and prompts/intentions. It's the future of **htag**.
 
 Currently, it works ...
 
-- For building desktop apps (ChromeApp on linux/windows)
+- For building desktop apps (ChromeApp on linux/windows/mac, or simple WebApp)
 - For building web apps (WebApp as an asgi app (for starlette/fastapi/...))
 - For building SPA HTML Page (with the PyScript runner)
 - For building android apps ([it works](examples/app_android/README.md), **but need to improve**)
 
+## Major differences between v1 and v2
+
+- A lot simpler & more reactive
+- `Tag.App` is the main app component
+- Full starlette compliant from the ground
+- Websocket communication, if fails : fallback to HTTP SSE
+- No more generic Runner
+- State object for reactivity
+- DX: errors are a lot better handled/viewable, hot-reload available
+- Better events
+- less boilerplate (kiss minded)
+- Styles can be scoped by component
+- ...
+
 
 ## Get Started
 
-Check the [Official Documentation](https://manatlan.github.io/htag/) for more information.
+Check the [Official V2 Documentation](https://manatlan.github.io/htag/) for more information. [old v1 docs](https://manatlan.github.io/htag/v1/)
+
 
 ## Install
 
 ```bash
-uv add htag
+uv add htag -U
 ```
 
 Or using pip:
 ```bash
-pip install htag
+pip install -U htag
 ```
 
 Alternatively, you can run from source:
@@ -73,35 +88,42 @@ uv run examples/main3.py
 
 ### Skill
 
-With gemini-cli, claude-code, mistral-vibe (or others), you can use this [SKILL.md](.agent/skills/htag-development/SKILL.md) to create a htag application.
+With agentic llm, you can use this [SKILL.md](.agent/skills/htag-development/SKILL.md) to create an htag application.
 
 
 ## Antigravity resumes :
 
 htag is a Python library for building web applications using HTML, CSS, and JavaScript.
 
-### Key Resiliency Features Added
+### New Features
 *   **Zero-Config Hot-Reload**: Passing `reload=True` to any runner (e.g. `ChromeApp(App).run(reload=True)`) automatically watches for Python file changes, seamlessly restarts the backend, and gracefully refreshes the frontend without losing your browser window session.
 *   **F5/Reload Robustness**: Refreshing the browser no longer kills the Python backend; the session reconstructs cleanly.
 *   **HTTP Fallback (SSE + POST)**: If WebSockets are blocked (e.g. strict proxies) or fail to connect, the client seamlessly falls back to HTTP POST for events and Server-Sent Events (SSE) for receiving UI updates.
 *   **Production Debug Mode**: Easily disable error reporting in the client by setting `debug=False` on the runner (e.g. `WebApp(App, debug=False).app`), preventing internal stacktraces from leaking to users.
 *   **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.
-
-### New API Features
 *   **`.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.
-*   **Dual Attribute Access (Dictionary Style)**: In addition to `self._class = "foo"`, you can now use `self["class"] = "foo"`. This is the preferred way to handle attributes with dashes (e.g., `self["data-id"] = 123`).
-*   **Automatic Attribute Normalization**: HTML attributes are normalized to use dashes internally. Setting `self._data_id = "123"` is strictly equivalent to setting `self["data-id"] = "123"`.
+*   **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`).
 *   **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` now support lambdas for dynamic updates. Boolean attributes (e.g. `_disabled=True`) are correctly rendered as key-only or omitted.
+*   **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.
 *   **Simplified Removal (`.remove()`)**: To remove a component from its parent, simply call `self.remove()` without arguments.
 *   **Rapid Content Replacement (`.text`)**: Use the `.text` property on any tag to quickly replace its inner text content without needing to manually clear its children first.
 *   **Recursive Statics & JS**: Components created dynamically (via lambdas) now have their `statics` (CSS) and `call_js` commands correctly collected and sent to the client.
 *   **Scoped Styles (`styles`)**: Define a `styles` class attribute on any component to get automatically scoped CSS. The framework prefixes every rule with `.htag-ClassName`, handles `@media`, `@keyframes`, pseudo-selectors, and multi-selectors.
 *   **CSS Class Helpers**: `add_class()`, `remove_class()`, `toggle_class()`, and `has_class()` for convenient class manipulation without manual string handling.
-*   **Simple Events & HashChange**: Support for passing primitive values or custom objects from JS (via `tag["onclick"] = func` or `tag._onclick = func`). Includes built-in support for `_onhashchange`.
+*   **Simple Events & HashChange**: Support for passing primitive values or custom objects from JS (via `tag["onclick"] = func`). Includes built-in support for `onhashchange`.
 *   **Fragments (`Tag()`)**: Create virtual components that group children without adding a wrapper tag to the DOM.
 *   **Advanced Tag Search (`.find_tag()`)**: Effortlessly locate any component in the tree by its internal htag ID or its manually assigned HTML `id`.
 *   **Custom ID Resilience**: Manual HTML `id` attributes are now supported without breaking htag's reactive partial updates, thanks to an automatic `data-htag-id` fallback mechanism.
 *   **Automatic Attribute Assignment**: Non-prefixed keyword arguments passed during component instantiation are automatically assigned as instance attributes, simplifying data passing to custom components.
+*   **Unified Form Handling**: When a `Tag.form` is submitted, all input fields are automatically collected into a dictionary and passed as `event.value`. You can conveniently access fields using square brackets on the event object (e.g., `e["fieldname"]`).
+
+
+## History
+
+At the beginning, there was [guy](https://github.com/manatlan/guy), which was/is the same concept as [python-eel](https://github.com/ChrisKnott/Eel), but more advanced.
+One day, I've discovered [remi](https://github.com/rawpython/remi), and asked my self, if it could be done in a *guy way*. The POC was very good, so I released
+a version of it, named [gtag](https://github.com/manatlan/gtag). It worked well despite some drawbacks, but was too difficult to maintain. So I decided to rewrite all
+from scratch, while staying away from *guy* (to separate, *rendering* and *runners*)... and [htag](https://github.com/manatlan/htag/tree/v1-legacy) was born. The codebase is very short, concepts are better implemented, and it's very easy to maintain. And now (2026) [htag v2](https://github.com/manatlan/htag) is here (a full rewrite of v1 with antigravity) !
+

{htag-2.0.0 → htag-2.0.2}/htag.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ htag/runners/chromeapp.py
 htag/runners/pyscript.py
 tests/test_cmd.py
 tests/test_core.py
+tests/test_deprecation_warnings.py
 tests/test_fallback.py
 tests/test_lifecycle.py
 tests/test_memory.py

{htag-2.0.0 → htag-2.0.2}/pyproject.toml

@@ -9,8 +9,8 @@ include-package-data = true
 
 [project]
 name = "htag"
-version = "2.0.0"
-description = "A modern, state-of-the-art Python GUI framework"
+version = "2.0.2"
+description = "Python3 GUI toolkit for building 'beautiful' applications for mobile, web, and desktop from a single codebase"
 readme = "README.md"
 requires-python = ">=3.10"
 license = {text = "MIT"}
@@ -46,6 +46,7 @@ dev = [
     "pytest>=9.0.2",
     "pytest-asyncio>=1.3.0",
     "pytest-cov>=7.0.0",
+    "pytest-playwright>=0.7.2",
     "ruff>=0.15.4",
 ]
 

htag-2.0.2/tests/test_deprecation_warnings.py

@@ -0,0 +1,78 @@
+import pytest
+import logging
+from htag import Tag
+
+def test_instantiation_no_warning(caplog):
+    """
+    Ensures that underscore-prefixed attributes during instantiation
+    do NOT trigger a deprecation warning.
+    """
+    with caplog.at_level(logging.WARNING, logger="htag"):
+        t = Tag.div(_class="myclass", _onclick="alert(1)")
+        assert len(caplog.records) == 0
+        assert t["class"] == "myclass"
+        assert t["onclick"] == "alert(1)"
+
+def test_getattr_warning(caplog):
+    """
+    Ensures that accessing underscore-prefixed attributes triggers a warning.
+    """
+    t = Tag.div(_class="myclass")
+    caplog.clear()
+    with caplog.at_level(logging.WARNING, logger="htag"):
+        c = t._class
+        assert c == "myclass"
+        assert len(caplog.records) == 1
+        assert "DEPRECATION" in caplog.text
+        assert "Accessing HTML attributes via underscore prefix ('_class')" in caplog.text
+
+def test_setattr_warning(caplog):
+    """
+    Ensures that setting underscore-prefixed attributes triggers a warning.
+    """
+    t = Tag.div()
+    caplog.clear()
+    with caplog.at_level(logging.WARNING, logger="htag"):
+        t._class = "newclass"
+        assert t["class"] == "newclass"
+        assert len(caplog.records) == 1
+        assert "DEPRECATION" in caplog.text
+        assert "Setting HTML attributes via underscore prefix ('_class')" in caplog.text
+
+def test_get_event_warning(caplog):
+    """
+    Ensures that accessing underscore-prefixed events triggers a warning.
+    """
+    t = Tag.div(_onclick="alert(1)")
+    caplog.clear()
+    with caplog.at_level(logging.WARNING, logger="htag"):
+        oc = t._onclick
+        assert oc == "alert(1)"
+        assert len(caplog.records) == 1
+        assert "DEPRECATION" in caplog.text
+        assert "Accessing events via underscore prefix ('_onclick')" in caplog.text
+
+def test_set_event_warning(caplog):
+    """
+    Ensures that setting underscore-prefixed events triggers a warning.
+    """
+    t = Tag.div()
+    caplog.clear()
+    with caplog.at_level(logging.WARNING, logger="htag"):
+        t._onclick = "alert(2)"
+        assert t["onclick"] == "alert(2)"
+        assert len(caplog.records) == 1
+        assert "DEPRECATION" in caplog.text
+        assert "Setting events via underscore prefix ('_onclick')" in caplog.text
+
+def test_getattr_no_warning_on_missing(caplog):
+    """
+    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()
+    caplog.clear()
+    with caplog.at_level(logging.WARNING, logger="htag"):
+        with pytest.raises(AttributeError):
+            _ = t._non_existent
+        assert len(caplog.records) == 0

htag-2.0.2/tests/test_simple_events.py

@@ -0,0 +1,190 @@
+import pytest
+import json
+from unittest.mock import MagicMock, AsyncMock
+from htag.server import Event, AppRunner as App
+from htag import Tag
+
+@pytest.mark.asyncio
+async def test_event_simple_value():
+    target = MagicMock()
+    msg = {
+        "id": "123",
+        "event": "custom",
+        "data": "hello"
+    }
+    e = Event(target, msg)
+    assert e.value == "hello"
+
+@pytest.mark.asyncio
+async def test_event_hashchange_data():
+    target = MagicMock()
+    msg = {
+        "id": "123",
+        "event": "hashchange",
+        "data": {
+            "newURL": "http://localhost/#new",
+            "oldURL": "http://localhost/#old",
+            "callback_id": "123"
+        }
+    }
+    e = Event(target, msg)
+    assert e.newURL == "http://localhost/#new"
+    assert e.oldURL == "http://localhost/#old"
+
+@pytest.mark.asyncio
+async def test_app_handle_simple_event():
+    app = App()
+    shared = {"val": None}
+    
+    def my_cb(e):
+        shared["val"] = e.value
+        
+    # We simulate a tag that has a custom event handler
+    class MyTag(Tag.div):
+        def init(self):
+            self._oncustom = my_cb
+            
+    tag = MyTag()
+    app += tag
+    
+    ws = AsyncMock()
+    msg = {
+        "id": tag.id,
+        "event": "custom",
+        "data": "simple_value"
+    }
+    
+    await app.handle_event(msg, ws)
+    assert shared["val"] == "simple_value"
+
+@pytest.mark.asyncio
+async def test_app_handle_hashchange_event():
+    app = App()
+    shared = {"new": None, "old": None}
+    
+    def on_hash(e):
+        shared["new"] = e.newURL
+        shared["old"] = e.oldURL
+        
+    app._onhashchange = on_hash
+    
+    ws = AsyncMock()
+    msg = {
+        "id": app.id,
+        "event": "hashchange",
+        "data": {
+            "newURL": "new_url",
+            "oldURL": "old_url"
+        }
+    }
+    
+    await app.handle_event(msg, ws)
+    assert shared["new"] == "new_url"
+    assert shared["old"] == "old_url"
+
+@pytest.mark.asyncio
+async def test_event_dict_value():
+    target = MagicMock()
+    msg = {
+        "id": "123",
+        "event": "submit",
+        "data": {
+            "name": "manatlan",
+            "age": 42
+        }
+    }
+    e = Event(target, msg)
+    # Standard htag v2: data is in .value
+    assert e.value == {"name": "manatlan", "age": 42}
+    # Backward compatibility / Convenience: subscriptable access
+    assert e["name"] == "manatlan"
+    assert e["age"] == 42
+    assert e["missing"] is None
+
+@pytest.mark.asyncio
+async def test_event_getitem_fallback_to_attr():
+    target = MagicMock()
+    msg = {
+        "id": "123",
+        "event": "click",
+        "data": {
+            "pageX": 100,
+            "pageY": 200
+        }
+    }
+    e = Event(target, msg)
+    # Should find in attributes (Event sets attrs from msg['data'])
+    assert e["pageX"] == 100
+    assert e.pageX == 100
+    # Should work via __getitem__ too
+    assert e["id"] == "123"
+
+@pytest.mark.asyncio
+async def test_app_handle_form_event():
+    app = App()
+    shared = {"data": None}
+    
+    def on_submit(e):
+        shared["data"] = e.value
+        
+    class MyForm(Tag.form):
+        def init(self):
+            self._onsubmit = on_submit
+            
+    tag = MyForm()
+    app += tag
+    
+    ws = AsyncMock()
+    msg = {
+        "id": tag.id,
+        "event": "submit",
+        "data": {
+            "value": {"field1": "val1", "field2": "val2"}
+        }
+    }
+    
+    await app.handle_event(msg, ws)
+    assert shared["data"] == {"field1": "val1", "field2": "val2"}
+
+@pytest.mark.asyncio
+async def test_event_priority_collision():
+    target = MagicMock()
+    msg = {
+        "id": "real_id",
+        "event": "submit",
+        "data": {
+            "id": "form_id", # Collision with event.id
+            "name": "bob"
+        }
+    }
+    e = Event(target, msg)
+    # The form data 'id' should win in subscript access
+    assert e["id"] == "form_id"
+    # But event.id (attribute) was overwritten by the flat dict expansion in __init__
+    assert e.id == "form_id" 
+
+@pytest.mark.asyncio
+async def test_event_flat_value_subscript():
+    target = MagicMock()
+    msg = {
+        "id": "123",
+        "event": "click",
+        "data": "just_a_string"
+    }
+    e = Event(target, msg)
+    assert e.value == "just_a_string"
+    # Subscript should fall back to attributes even if value isn't a dict
+    assert e["id"] == "123"
+    assert e["missing"] is None
+
+@pytest.mark.asyncio
+async def test_event_empty_data():
+    target = MagicMock()
+    msg = {
+        "id": "123",
+        "event": "click"
+        # data is missing
+    }
+    e = Event(target, msg)
+    assert e.value is None
+    assert e["id"] == "123"

htag-2.0.0/tests/test_simple_events.py

@@ -1,83 +0,0 @@
-import pytest
-import json
-from unittest.mock import MagicMock, AsyncMock
-from htag.server import Event, AppRunner as App
-from htag import Tag
-
-@pytest.mark.asyncio
-async def test_event_simple_value():
-    target = MagicMock()
-    msg = {
-        "id": "123",
-        "event": "custom",
-        "data": "hello"
-    }
-    e = Event(target, msg)
-    assert e.value == "hello"
-
-@pytest.mark.asyncio
-async def test_event_hashchange_data():
-    target = MagicMock()
-    msg = {
-        "id": "123",
-        "event": "hashchange",
-        "data": {
-            "newURL": "http://localhost/#new",
-            "oldURL": "http://localhost/#old",
-            "callback_id": "123"
-        }
-    }
-    e = Event(target, msg)
-    assert e.newURL == "http://localhost/#new"
-    assert e.oldURL == "http://localhost/#old"
-
-@pytest.mark.asyncio
-async def test_app_handle_simple_event():
-    app = App()
-    shared = {"val": None}
-    
-    def my_cb(e):
-        shared["val"] = e.value
-        
-    # We simulate a tag that has a custom event handler
-    class MyTag(Tag.div):
-        def init(self):
-            self._oncustom = my_cb
-            
-    tag = MyTag()
-    app += tag
-    
-    ws = AsyncMock()
-    msg = {
-        "id": tag.id,
-        "event": "custom",
-        "data": "simple_value"
-    }
-    
-    await app.handle_event(msg, ws)
-    assert shared["val"] == "simple_value"
-
-@pytest.mark.asyncio
-async def test_app_handle_hashchange_event():
-    app = App()
-    shared = {"new": None, "old": None}
-    
-    def on_hash(e):
-        shared["new"] = e.newURL
-        shared["old"] = e.oldURL
-        
-    app._onhashchange = on_hash
-    
-    ws = AsyncMock()
-    msg = {
-        "id": app.id,
-        "event": "hashchange",
-        "data": {
-            "newURL": "new_url",
-            "oldURL": "old_url"
-        }
-    }
-    
-    await app.handle_event(msg, ws)
-    assert shared["new"] == "new_url"
-    assert shared["old"] == "old_url"