tina4-python 3.10.10__tar.gz → 3.10.12__tar.gz

{tina4_python-3.10.10 → tina4_python-3.10.12}/PKG-INFO

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

{tina4_python-3.10.10 → tina4_python-3.10.12}/pyproject.toml

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

{tina4_python-3.10.10 → tina4_python-3.10.12}/tina4_python/core/server.py

@@ -966,6 +966,10 @@ async def app(scope: dict, receive, send):
                 ttl = int(os.environ.get("TINA4_SESSION_TTL", "3600"))
                 samesite = os.environ.get("TINA4_SESSION_SAMESITE", "Lax")
                 response.header("set-cookie", f"tina4_session={sid}; Path=/; HttpOnly; SameSite={samesite}; Max-Age={ttl}")
+            # Probabilistic garbage collection (~1% of requests)
+            import random
+            if random.randint(1, 100) == 1:
+                request.session.gc()
         except Exception:
             pass
 

{tina4_python-3.10.10 → tina4_python-3.10.12}/tina4_python/frond/engine.py

@@ -269,10 +269,11 @@ def _resolve(expr: str, context: dict):
     value = context
     for part in parts:
         if part.startswith("[") and part.endswith("]"):
-            idx = part[1:-1].strip("'\"")
+            raw_idx = part[1:-1].strip()
             # Slice syntax: value[1:5], value[:10], value[3:]
-            if ":" in idx:
-                slice_parts = idx.split(":", 1)
+            if ":" in raw_idx and not ((raw_idx.startswith('"') and raw_idx.endswith('"')) or (raw_idx.startswith("'") and raw_idx.endswith("'"))):
+                idx_clean = raw_idx.strip("'\"")
+                slice_parts = idx_clean.split(":", 1)
                 s_start = int(slice_parts[0]) if slice_parts[0].strip() else None
                 s_end = int(slice_parts[1]) if slice_parts[1].strip() else None
                 try:
@@ -280,10 +281,20 @@ def _resolve(expr: str, context: dict):
                 except (TypeError, IndexError):
                     return None
             else:
-                try:
-                    idx = int(idx)
-                except ValueError:
-                    pass
+                # Resolve the key: string literal, int literal, or variable
+                if (raw_idx.startswith('"') and raw_idx.endswith('"')) or \
+                   (raw_idx.startswith("'") and raw_idx.endswith("'")):
+                    # String literal: balances["9600.000"]
+                    idx = raw_idx[1:-1]
+                else:
+                    try:
+                        # Integer literal: items[0]
+                        idx = int(raw_idx)
+                    except ValueError:
+                        # Variable key: balances[k] or balances[cb.glcode]
+                        idx = _resolve(raw_idx, context)
+                        if idx is None:
+                            return None
                 try:
                     value = value[idx]
                 except (KeyError, IndexError, TypeError):

{tina4_python-3.10.10 → tina4_python-3.10.12}/tina4_python/websocket/backplane.py

@@ -100,6 +100,101 @@ class RedisBackplane(WebSocketBackplane):
         logger.info("RedisBackplane closed")
 
 
+class NATSBackplane(WebSocketBackplane):
+    """NATS pub/sub backplane.
+
+    Requires the ``nats-py`` package (``pip install nats-py``). The import is
+    deferred so the rest of Tina4 works fine without it installed.
+
+    NATS is async-native, so we run an asyncio event loop in a background
+    thread for the subscription listener.
+    """
+
+    def __init__(self, url: str | None = None):
+        try:
+            import nats  # noqa: F401
+        except ImportError:
+            raise ImportError(
+                "The 'nats-py' package is required for NATSBackplane. "
+                "Install it with: pip install nats-py"
+            )
+
+        self._url = url or os.environ.get(
+            "TINA4_WS_BACKPLANE_URL", "nats://localhost:4222"
+        )
+        self._nc = None
+        self._subs: dict[str, object] = {}
+        self._loop = None
+        self._thread = None
+        self._running = True
+        self._connect()
+        logger.info("NATSBackplane connected to %s", self._url)
+
+    def _connect(self):
+        """Connect to NATS in a background event loop."""
+        import asyncio
+        import nats
+
+        self._loop = asyncio.new_event_loop()
+
+        async def _do_connect():
+            self._nc = await nats.connect(self._url)
+
+        self._loop.run_until_complete(_do_connect())
+
+        # Run the event loop in a background thread for subscriptions
+        self._thread = threading.Thread(
+            target=self._loop.run_forever, daemon=True
+        )
+        self._thread.start()
+
+    def publish(self, channel: str, message: str) -> None:
+        import asyncio
+
+        async def _pub():
+            await self._nc.publish(channel, message.encode())
+
+        asyncio.run_coroutine_threadsafe(_pub(), self._loop).result(timeout=5)
+
+    def subscribe(self, channel: str, callback) -> None:
+        import asyncio
+
+        async def _sub():
+            async def handler(msg):
+                callback(msg.data.decode())
+
+            sub = await self._nc.subscribe(channel, cb=handler)
+            self._subs[channel] = sub
+
+        asyncio.run_coroutine_threadsafe(_sub(), self._loop).result(timeout=5)
+        logger.info("NATSBackplane subscribed to channel '%s'", channel)
+
+    def unsubscribe(self, channel: str) -> None:
+        import asyncio
+
+        sub = self._subs.pop(channel, None)
+        if sub:
+            asyncio.run_coroutine_threadsafe(
+                sub.unsubscribe(), self._loop
+            ).result(timeout=5)
+        logger.info("NATSBackplane unsubscribed from channel '%s'", channel)
+
+    def close(self) -> None:
+        import asyncio
+
+        self._running = False
+        if self._nc:
+            asyncio.run_coroutine_threadsafe(
+                self._nc.close(), self._loop
+            ).result(timeout=5)
+        if self._loop:
+            self._loop.call_soon_threadsafe(self._loop.stop)
+        if self._thread:
+            self._thread.join(timeout=2)
+        self._subs.clear()
+        logger.info("NATSBackplane closed")
+
+
 def create_backplane(url: str | None = None) -> WebSocketBackplane | None:
     """Factory that reads TINA4_WS_BACKPLANE and returns the appropriate
     backplane instance, or *None* if no backplane is configured.
@@ -112,9 +207,7 @@ def create_backplane(url: str | None = None) -> WebSocketBackplane | None:
     if backend == "redis":
         return RedisBackplane(url=url)
     elif backend == "nats":
-        raise NotImplementedError(
-            "NATS backplane is on the roadmap but not yet implemented."
-        )
+        return NATSBackplane(url=url)
     elif backend == "":
         return None
     else: