tina4-python 3.10.75__tar.gz → 3.10.82__tar.gz

{tina4_python-3.10.75 → tina4_python-3.10.82}/PKG-INFO

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

{tina4_python-3.10.75 → tina4_python-3.10.82}/tina4_python/__init__.py

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

{tina4_python-3.10.75 → tina4_python-3.10.82}/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.75 → tina4_python-3.10.82}/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.75 → tina4_python-3.10.82}/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]):