tina4-python 3.13.34__tar.gz → 3.13.36__tar.gz

{tina4_python-3.13.34 → tina4_python-3.13.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.13.34
+Version: 3.13.36
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.34 → tina4_python-3.13.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.34"
+version = "3.13.36"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.34 → tina4_python-3.13.36}/tina4_python/CLAUDE.md

@@ -409,9 +409,18 @@ Set `TINA4_DEBUG=true` in `.env` to enable development features:
 - **CSS hot-reload** — SCSS/CSS changes refresh stylesheets without full page reload
 - **SCSS auto-compile** — `.scss` files in `src/scss/` are compiled to `src/public/css/` on save
 - **Error overlay** — Runtime errors display a rich, syntax-highlighted overlay in the browser
-- **Route re-discovery** — `POST /__dev/api/reload` re-runs auto-discover, so new files in `src/routes/`, `src/orm/`, or `src/app/` register without a server restart. Existing modules are NOT re-imported — for code changes inside an already-loaded file, restart the server.
+- **Route re-discovery & hot-reload** — `POST /__dev/api/reload` re-runs auto-discover. New files in `src/routes/`, `src/orm/`, or `src/app/` register without a server restart, AND changed `.py` files under `src/` are re-imported in-process (mtime-tracked) so editing an existing route hot-reloads its handler live — no restart needed. The Router replaces a re-registered `(method, path)` in place, so the fresh handler wins instead of being shadowed by the stale one. Only `src/` modules are ever re-imported; framework (`tina4_python.*`) modules are never touched. Honest caveat: a symbol imported BY NAME into another *unchanged* module (e.g. `from src.orm.User import User` inside a route file that itself didn't change) or an ORM class identity captured across modules may still need a restart — the edited file re-executes, but a different module that grabbed the old reference earlier keeps it until it too re-imports.
 
-DevReload connects via WebSocket at `/__dev_reload`. No configuration needed.
+### How DevReload works (WebSocket-primary)
+
+DevReload is **WebSocket-primary** — the reload is instant, not polled:
+
+1. The `tina4` Rust CLI watches `src/`, `migrations/`, `.env` and, on a real change, POSTs `/__dev/api/reload` to the **running** server. The CLI does **not** restart the worker process.
+2. The server re-runs auto-discover — registering new `src/` files and re-importing changed ones **in-process** (mtime-tracked, `src/` only; framework modules never), so the worker keeps the same PID — then bumps its reload counter.
+3. The server **broadcasts** a JSON message `{type, file, mtime}` to every browser connected on the `/__dev_reload` WebSocket (`type` is `"css"` for stylesheet changes, else `"reload"`). The dev-toolbar client and the dev-admin dashboard both connect here and act on it instantly: CSS changes swap `<link rel=stylesheet>` hrefs with a cache-bust query; everything else does a full `location.reload()`.
+4. **Poll is fallback only.** The injected toolbar client stops polling the moment the socket connects, and only restarts the `/__dev/api/mtime` poll (every 3 s) when the socket drops — reconnecting after ~2 s. In normal operation there is no polling.
+
+The `/__dev_reload` WebSocket route is registered automatically when `TINA4_DEBUG=true`. No configuration needed. Running without the Rust CLI (e.g. Docker, `TINA4_OVERRIDE_CLIENT=true`) means no automatic reload.
 
 ## Routing
 

{tina4_python-3.13.34 → tina4_python-3.13.36}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.34"
+__version__ = "3.13.36"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.13.34 → tina4_python-3.13.36}/tina4_python/core/router.py

@@ -340,6 +340,20 @@ class Router:
             "swagger_meta": swagger_meta or options.get("swagger_meta", {}),
             "template": template or options.get("template"),
         }
+        # Replace semantics: re-registering the same (method, path) overwrites
+        # the existing entry in place rather than appending a second one.
+        # This is what makes dev hot-reload work — when a changed module is
+        # re-imported, its @get("/x") decorator runs again with a fresh handler,
+        # and ``match()`` returns the FIRST match, so a stale leftover would
+        # otherwise shadow the new handler forever. Overwriting keeps the
+        # registry free of duplicates and ensures the latest handler wins.
+        # Distinct (method, path) pairs are untouched — only an exact dup
+        # collapses onto the prior slot, preserving its position/order.
+        for i, existing in enumerate(_routes):
+            if existing["method"] == m and existing["path"] == path:
+                _routes[i] = route
+                Log.debug(f"Route replaced: {m} {path} (auth={'required' if auth_required else 'public'})")
+                return RouteRef(route)
         _routes.append(route)
         Log.debug(f"Route registered: {m} {path} (auth={'required' if auth_required else 'public'})")
         return RouteRef(route)

{tina4_python-3.13.34 → tina4_python-3.13.36}/tina4_python/core/server.py

@@ -48,12 +48,30 @@ def background(callback, interval: float = 1.0):
     _background_tasks.append({"callback": callback, "interval": interval})
 
 
+# module_name → source-file mtime at the last (re)import. Drives the
+# changed-file detection in ``_auto_discover``: a file whose mtime is newer
+# than the recorded value is re-executed in place, so editing an existing
+# route hot-reloads on /__dev/api/reload without a server restart. Files we
+# have never imported are absent from the map.
+_discovered_mtimes: dict[str, float] = {}
+
+
 def _auto_discover(root_dir: str = "src"):
     """Auto-import all .py files in ``root_dir`` to trigger route decorators.
 
-    Idempotent and re-runnable: skips modules already in ``sys.modules`` so
-    re-discovery on /__dev/api/reload is cheap. New files added after server
-    boot get picked up on the next reload signal.
+    Idempotent and re-runnable so re-discovery on /__dev/api/reload is cheap:
+
+    * **New** module (not in ``sys.modules``) → import it, record its mtime.
+    * **Changed** module (in ``sys.modules`` and its source mtime is newer than
+      the recorded value) → re-execute it (``del sys.modules`` + re-import) so
+      edits to an existing route take effect. The Router replaces same-(method,
+      path) registrations, so the re-imported handler wins instead of being
+      shadowed by the stale one.
+    * **Unchanged** module → skipped (keeps the re-runnable property cheap).
+
+    Only modules discovered under ``root_dir`` are ever re-imported — framework
+    (``tina4_python.*``) and third-party modules are never deleted/re-imported,
+    which would be catastrophic for shared singletons and class identity.
 
     Import failures are recorded to ``data/.broken/`` so /health surfaces them
     instead of swallowing them into a console line nobody reads.
@@ -62,6 +80,14 @@ def _auto_discover(root_dir: str = "src"):
     if not root.is_dir():
         return
 
+    # The package prefix every discovered module shares (e.g. "src"). The
+    # del+reimport path is gated on this so we can never evict a framework or
+    # third-party module from sys.modules even if a name somehow collides.
+    try:
+        root_pkg = root.relative_to(Path.cwd()).parts[0]
+    except (ValueError, IndexError):
+        root_pkg = root.name
+
     # Folders to skip — non-Python sub-trees inside src/.
     skip = {"public", "templates", "scss", "locales", "icons"}
     # Routes folder is special-cased so the user gets a clear warning when
@@ -91,9 +117,32 @@ def _auto_discover(root_dir: str = "src"):
         try:
             rel = py_file.relative_to(Path.cwd()).with_suffix("")
             module_name = ".".join(rel.parts)
+            try:
+                current_mtime = py_file.stat().st_mtime
+            except OSError:
+                current_mtime = 0.0
+
             if module_name not in sys.modules:
+                # New module — import and remember its mtime.
                 importlib.import_module(module_name)
+                _discovered_mtimes[module_name] = current_mtime
                 Log.debug(f"Loaded: {module_name}")
+            elif current_mtime > _discovered_mtimes.get(module_name, 0.0):
+                # Changed module — re-execute so edits to an existing route
+                # take effect in-process. Scope guard: only ever evict a module
+                # that lives under our discovery package. Deleting a
+                # tina4_python.* / third-party module would break shared
+                # singletons and class identity — never do that here.
+                if module_name == root_pkg or module_name.startswith(root_pkg + "."):
+                    del sys.modules[module_name]
+                    importlib.import_module(module_name)
+                    _discovered_mtimes[module_name] = current_mtime
+                    Log.info(f"Reloaded changed module: {module_name}")
+                else:
+                    # Out-of-scope module changed — record mtime so we don't
+                    # keep re-evaluating it, but do not re-import it.
+                    _discovered_mtimes[module_name] = current_mtime
+            # Unchanged module → skip (keeps re-discovery cheap/idempotent).
         except Exception as e:
             Log.error(f"Failed to load {py_file}: {e}")
             _record_broken_import(py_file, e)
@@ -634,6 +683,30 @@ from tina4_python.websocket import WebSocketConnection, WebSocketManager
 _ws_manager = WebSocketManager()
 
 
+async def _dev_reload_ws(connection, event, data):
+    """WebSocket handler for the dev-reload channel (/__dev_reload).
+
+    Connections are kept open and held by ``_ws_manager`` on the
+    ``/__dev_reload`` path so ``POST /__dev/api/reload`` can broadcast an
+    instant reload to every browser. The framework never pushes anything from
+    the client side — incoming frames are ignored; the open socket is the
+    whole point. This restores the documented WebSocket-primary DevReload
+    design (the dashboard SPA and the injected dev-toolbar both connect here).
+    """
+    return
+
+
+_dev_reload_ws_registered = [False]
+
+
+def _register_dev_reload_ws() -> None:
+    """Register the /__dev_reload WebSocket route once (debug mode only)."""
+    if _dev_reload_ws_registered[0]:
+        return
+    Router.websocket("/__dev_reload", _dev_reload_ws)
+    _dev_reload_ws_registered[0] = True
+
+
 async def _handle_asgi_websocket(scope: dict, receive, send):
     """Handle ASGI WebSocket connections, dispatching to registered routes."""
     path = scope.get("path", "/")
@@ -2183,8 +2256,12 @@ def run(host: str | None = None, port: int | None = None, no_browser: bool = Fal
     is_debug = is_truthy(os.environ.get("TINA4_DEBUG", ""))
 
     # File watching is handled by the Rust CLI (tina4 serve). The framework
-    # only needs to receive POST /__dev/api/reload and update the mtime counter
-    # so the browser's polling fallback triggers a refresh. No internal watcher.
+    # only needs to receive POST /__dev/api/reload, re-import the changed
+    # module in-process, and push an instant reload over the /__dev_reload
+    # WebSocket. The mtime counter at /__dev/api/mtime is the polling
+    # fallback for when that socket is down. No internal watcher.
+    if is_debug:
+        _register_dev_reload_ws()
 
     prod = None
     if not is_debug:

{tina4_python-3.13.34 → tina4_python-3.13.36}/tina4_python/dev_admin/__init__.py

@@ -485,6 +485,12 @@ def get_api_handlers() -> dict:
         # @mcp_tool decorator appear in both immediately.
         "/__dev/api/mcp/tools": ("GET", _api_mcp_tools),
         "/__dev/api/mcp/call": ("POST", _api_mcp_call),
+        # JSON-RPC + SSE surface for real MCP clients (Claude Desktop/Code).
+        # Same registry as the REST shim above; this is what makes /__dev/mcp
+        # actually reachable as an MCP server (previously defined but unmounted).
+        "/__dev/mcp": ("POST", _api_mcp_rpc),
+        "/__dev/mcp/message": ("POST", _api_mcp_rpc),
+        "/__dev/mcp/sse": ("GET", _api_mcp_sse),
         # ── Scaffold REST shim ──
         # Wraps the tina4python CLI's `generate <kind> <name>` so the
         # + Route / + Model / + Migration / + Middleware buttons work
@@ -1973,6 +1979,25 @@ async def _api_reload(request, response):
     except Exception as e:
         Log.error(f"Re-discover on reload failed: {e}")
 
+    # WebSocket-primary reload: push an instant message to every browser
+    # connected on /__dev_reload. The toolbar client (and the dev-admin
+    # dashboard) act on this immediately — the mtime poll above is only a
+    # fallback for when the socket is down. CSS changes swap stylesheets;
+    # everything else triggers a full page reload. We normalise the wire
+    # `type` to "css"/"reload" so both clients react (the dashboard only
+    # listens for reload/change/css), but the HTTP response still echoes the
+    # caller's original type. Wrapped so a broadcast failure (or zero
+    # clients) never 500s the reload endpoint.
+    ws_type = "css" if reload_type == "css" else "reload"
+    try:
+        from tina4_python.core.server import _ws_manager
+        await _ws_manager.broadcast(
+            json.dumps({"type": ws_type, "file": _reload_file[0], "mtime": _reload_mtime[0]}),
+            path="/__dev_reload",
+        )
+    except Exception as e:
+        Log.error(f"Dev-reload WebSocket broadcast failed: {e}")
+
     return response({"ok": True, "type": reload_type})
 
 
@@ -2144,16 +2169,22 @@ def render_dev_toolbar(method: str, path: str, matched_pattern: str,
 </script>
 <script>
 {'(function(){})();' if no_reload else f"""(function(){{
-    var _t4_mtime=0,_t4_css_exts=['.css','.scss'],_t4_debounce=null;
+    // WebSocket-primary dev reloader. The running server re-imports changed
+    // src/ modules in-process and pushes a {{type,file,mtime}} message over
+    // /__dev_reload — no respawn, instant refresh. The mtime poll below is a
+    // FALLBACK only, started when the socket is down and stopped on connect.
+    var _t4_css_exts=['.css','.scss'],_t4_debounce=null;
     var _t4_interval=parseInt('{poll_interval_ms}')||3000;
+    var _t4_ws=null,_t4_poll_timer=null,_t4_mtime=null;
     function _t4_apply(d){{
-        var f=d.file||'';
-        var isCss=_t4_css_exts.some(function(e){{return f.endsWith(e)}});
+        d=d||{{}};
+        var f=d.file||'',t=d.type||'';
+        var isCss=t==='css'||_t4_css_exts.some(function(e){{return f.endsWith(e)}});
         if(isCss){{
             var links=document.querySelectorAll('link[rel="stylesheet"]');
             links.forEach(function(l){{
                 var href=l.getAttribute('href');
-                if(href){{l.setAttribute('href',href.split('?')[0]+'?_t4='+d.mtime)}}
+                if(href){{l.setAttribute('href',href.split('?')[0]+'?_t4='+(d.mtime||Date.now()))}}
             }});
         }}else{{
             location.reload();
@@ -2161,15 +2192,39 @@ def render_dev_toolbar(method: str, path: str, matched_pattern: str,
     }}
     function _t4_poll(){{
         fetch('/__dev/api/mtime').then(function(r){{return r.json()}}).then(function(d){{
-            if(!_t4_mtime){{_t4_mtime=d.mtime;return;}}
-            if(d.mtime>_t4_mtime){{
+            if(_t4_mtime===null){{_t4_mtime=d.mtime;return;}}
+            if(d.mtime!==_t4_mtime){{
                 _t4_mtime=d.mtime;
                 if(_t4_debounce)clearTimeout(_t4_debounce);
                 _t4_debounce=setTimeout(function(){{_t4_apply(d);}},500);
             }}
         }}).catch(function(){{}});
     }}
-    setInterval(_t4_poll,_t4_interval);
+    function _t4_startPoll(){{
+        if(_t4_poll_timer)return;
+        _t4_mtime=null;
+        _t4_poll_timer=setInterval(_t4_poll,_t4_interval);
+    }}
+    function _t4_stopPoll(){{
+        if(_t4_poll_timer){{clearInterval(_t4_poll_timer);_t4_poll_timer=null;}}
+    }}
+    function _t4_connect(){{
+        var url=(location.protocol==='https:'?'wss':'ws')+'://'+location.host+'/__dev_reload';
+        try{{_t4_ws=new WebSocket(url);}}catch(_){{_t4_startPoll();return;}}
+        _t4_ws.addEventListener('open',function(){{_t4_stopPoll();}});
+        _t4_ws.addEventListener('message',function(ev){{
+            var d=null;
+            try{{d=typeof ev.data==='string'?JSON.parse(ev.data):null;}}catch(_){{}}
+            if(!d)return;
+            if(d.type==='reload'||d.type==='change'||d.type==='css'){{
+                if(_t4_debounce)clearTimeout(_t4_debounce);
+                _t4_debounce=setTimeout(function(){{_t4_apply(d);}},150);
+            }}
+        }});
+        _t4_ws.addEventListener('close',function(){{_t4_ws=null;_t4_startPoll();setTimeout(_t4_connect,2000);}});
+        _t4_ws.addEventListener('error',function(){{try{{_t4_ws&&_t4_ws.close();}}catch(_){{}}}});
+    }}
+    _t4_connect();
 }})();"""}
 function tina4VersionModal(){{
     var m=document.getElementById('tina4-ver-modal');
@@ -2861,6 +2916,46 @@ async def _api_mcp_call(request, response):
         return response({"ok": False, "name": name, "error": str(exc)}, 500)
 
 
+# ─── MCP JSON-RPC + SSE endpoint ───────────────────────────────────
+#
+# The protocol surface real MCP clients (Claude Desktop/Code) speak —
+# JSON-RPC 2.0 over the HTTP+SSE transport. Mounted on the running dev
+# server so each `tina4 serve`d project exposes its OWN endpoint, giving
+# an AI agent live access scoped to that project. Shares the same
+# `_default_server` tool registry as the REST shim above, so every
+# @mcp_tool shows up on both surfaces.
+
+async def _api_mcp_rpc(request, response):
+    """POST — the JSON-RPC endpoint. Mounted at /__dev/mcp and
+    /__dev/mcp/message. Forwards to the default MCP server's
+    handle_message() and returns the JSON-RPC response; notifications
+    (no id) yield an empty 204.
+    """
+    import json as _json
+    from tina4_python.mcp import _get_default_server, is_enabled
+    if not is_enabled():
+        return response({"error": "MCP disabled"}, 404)
+    server = _get_default_server()
+    body = request.body
+    raw = body if isinstance(body, (dict, str)) else str(body)
+    result = server.handle_message(raw)
+    if not result:
+        return response("", 204)
+    return response(_json.loads(result))
+
+
+async def _api_mcp_sse(request, response):
+    """GET — SSE handshake. Emits the `endpoint` event telling the client
+    where to POST JSON-RPC messages, per the MCP HTTP+SSE transport.
+    """
+    from tina4_python.mcp import is_enabled
+    if not is_enabled():
+        return response({"error": "MCP disabled"}, 404)
+    base = request.path.rsplit("/sse", 1)[0]
+    sse = f"event: endpoint\ndata: {base}/message\n\n"
+    return response(sse, 200, "text/event-stream")
+
+
 # ─── Scaffold REST shim ────────────────────────────────────────────
 #
 # Wraps the tina4python `generate <kind> <name>` CLI commands so the

{tina4_python-3.13.34 → tina4_python-3.13.36}/tina4_python/mcp/tools.py

@@ -259,7 +259,7 @@ def register_dev_tools(server):
         """List all registered routes with methods and paths."""
         from tina4_python.core.router import Router
         routes = []
-        for route in Router._routes:
+        for route in Router.get_routes():
             routes.append({
                 "method": route.get("method", ""),
                 "path": route.get("path", ""),