tina4-python 3.10.76__tar.gz → 3.10.83__tar.gz

{tina4_python-3.10.76 → tina4_python-3.10.83}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.10.76
+Version: 3.10.83
 Summary: Tina4 for Python — 54 built-in features, zero dependencies
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.10.76 → tina4_python-3.10.83}/tina4_python/__init__.py

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

{tina4_python-3.10.76 → tina4_python-3.10.83}/tina4_python/core/server.py

@@ -629,9 +629,24 @@ async def _handle_dev_websocket(reader, writer, headers, path):
 
 
 def _init_session(request: Request) -> None:
-    """Auto-start session from cookie. Modifies request.session in place."""
+    """Auto-start session from cookie. Modifies request.session in place.
+
+    Session creation is skipped for WebSocket upgrade requests — they don't send
+    cookies and would create orphaned session files that are never cleaned up.
+    A session is only created when:
+      - A tina4_session cookie is already present (resume existing session), OR
+      - The request is a normal HTTP request (not a WebSocket upgrade)
+    """
     if request.session is not None:
         return
+
+    # Skip session creation for WebSocket upgrade requests.
+    # WebSocket clients don't send cookies so sess.start(None) would create a
+    # new orphaned file every connection that is never cleaned up.
+    upgrade = request.headers.get("upgrade", "").lower()
+    if upgrade == "websocket":
+        return
+
     try:
         from tina4_python.session import Session
         cookie_header = request.headers.get("cookie", "")
@@ -641,8 +656,19 @@ def _init_session(request: Request) -> None:
             if part.startswith("tina4_session="):
                 sid_match = part.split("=", 1)[1]
                 break
-        sess = Session()
-        sess.start(sid_match)
+
+        # Only create a new session for HTTP requests that don't already have one.
+        # This prevents a new empty session file being written on every anonymous request.
+        if sid_match is None:
+            # Lazy session: attach a Session object but don't persist until the route
+            # explicitly writes to it. The session file is only created on first save().
+            sess = Session()
+            sess.start(None)
+            sess._is_new = True  # flag for _finalize_response to skip saving if unused
+        else:
+            sess = Session()
+            sess.start(sid_match)
+
         request.session = sess
         # Probabilistic garbage collection (1% of requests)
         import random
@@ -938,15 +964,22 @@ def _finalize_response(
         except Exception:
             pass
 
-    # Session save + cookie
+    # Session save + cookie.
+    # Skip saving if this was a brand-new session that the route never wrote to —
+    # that prevents empty orphaned session files accumulating on disk.
     if request.session is not None:
         try:
-            request.session.save()
-            sid = request.session.session_id if hasattr(request.session, 'session_id') else getattr(request.session, 'id', None)
-            if sid:
-                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}")
+            is_new_and_empty = (
+                getattr(request.session, '_is_new', False)
+                and not request.session.all()
+            )
+            if not is_new_and_empty:
+                request.session.save()
+                sid = request.session.session_id if hasattr(request.session, 'session_id') else getattr(request.session, 'id', None)
+                if sid:
+                    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}")
             import random
             if random.randint(1, 100) == 1:
                 request.session.gc()

{tina4_python-3.10.76 → tina4_python-3.10.83}/tina4_python/orm/__init__.py

@@ -12,7 +12,7 @@ Active Record ORM with SQL-first paradigm.
 
     # SQL-first — you write the SQL, ORM maps results
     users = User.select("SELECT * FROM users WHERE active = ?", [1])
-    user = User.find(1)
+    user = User.find_by_id(1)
     user.name = "Updated"
     user.save()
 """

{tina4_python-3.10.76 → tina4_python-3.10.83}/tina4_python/orm/fields.py

@@ -262,7 +262,7 @@ class BelongsToDescriptor(RelationshipDescriptor):
         fk_value = getattr(obj, fk, None)
         if fk_value is None:
             return None
-        return related_cls.find(fk_value)
+        return related_cls.find_by_id(fk_value)
 
 
 def has_many(model_name: str, foreign_key: str = None) -> HasManyDescriptor:

{tina4_python-3.10.76 → tina4_python-3.10.83}/tina4_python/orm/model.py

@@ -365,15 +365,69 @@ class ORM(metaclass=ORMMeta):
         return cls.select_one(sql, [pk_value], include=include)
 
     @classmethod
-    def find(cls, pk_value, include: list[str] = None):
-        """Alias for find_by_id()."""
-        return cls.find_by_id(pk_value, include)
+    def find(cls, filter: dict = None, limit: int = 100, offset: int = 0, order_by: str = None, include: list[str] = None):
+        """Find records by filter dict.
 
-    def load(self, sql: str, params: list = None, include: list[str] = None) -> bool:
-        """Load a record into this instance via selectOne.
+        Usage:
+            User.find({"name": "Alice"})           → [User, ...]
+            User.find({"age": 18}, limit=10)       → [User, ...]
+            User.find(order_by="name ASC")          → [User, ...]
+            User.find()                             → all records
+
+        Args:
+            filter: Dict of {column: value} pairs (AND-ed together).
+            limit: Max records to return.
+            offset: Starting offset.
+            order_by: ORDER BY clause (e.g. "name ASC").
+            include: Relationship names to eager-load.
+        """
+        db = cls._get_db()
+        table = cls._get_table()
+        conditions = []
+        params = []
+
+        if filter:
+            for key, value in filter.items():
+                col = cls.field_mapping.get(key, key)
+                conditions.append(f"{col} = ?")
+                params.append(value)
+
+        if cls.soft_delete:
+            conditions.append("deleted_at IS NULL")
+
+        sql = f"SELECT * FROM {table}"
+        if conditions:
+            sql += " WHERE " + " AND ".join(conditions)
+        if order_by:
+            sql += f" ORDER BY {order_by}"
+
+        return cls.select(sql, params, limit=limit, offset=offset, include=include)
+
+    def load(self, filter: str = None, params: list = None, include: list[str] = None) -> bool:
+        """Load a record into this instance.
+
+        Usage:
+            orm.id = 1; orm.load()          — uses PK already set
+            orm.load("id = ?", [1])         — filter with params
+            orm.load("id = 1")              — filter string
 
         Returns True if a record was found and loaded, False otherwise.
         """
+        db = self._get_db()
+        table = self._get_table()
+
+        if filter is None:
+            # No args — use the primary key value already set
+            pk = self._get_pk()
+            pk_value = getattr(self, pk, None)
+            if pk_value is None:
+                return False
+            pk_col = self.field_mapping.get(pk, self._fields[pk].column)
+            sql = f"SELECT * FROM {table} WHERE {pk_col} = ?"
+            params = [pk_value]
+        else:
+            sql = f"SELECT * FROM {table} WHERE {filter}"
+
         cls = type(self)
         result = cls.select_one(sql, params, include=include)
         if result is None:
@@ -614,7 +668,7 @@ class ORM(metaclass=ORMMeta):
         fk_value = getattr(self, fk, None)
         if fk_value is None:
             return None
-        return related_class.find(fk_value)
+        return related_class.find_by_id(fk_value)
 
     @classmethod
     def _eager_load(cls, instances: list, include: list[str]):