devdb-sql 1.0.8__tar.gz → 1.0.9__tar.gz

{devdb_sql-1.0.8 → devdb_sql-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devdb-sql
-Version: 1.0.8
+Version: 1.0.9
 Summary: Lightweight SQLite SDK with a MongoDB-like developer experience
 Author: Mahadev
 License: MIT

devdb_sql-1.0.9/devdb_sql/db.py

@@ -0,0 +1,104 @@
+import sqlite3
+import threading
+from pathlib import Path
+
+from .schema import compile_schema
+from .table import Table
+
+
+class DB:
+    def __init__(self, path):
+        if not path:
+            raise ValueError("Database path is required")
+
+        self.path = path
+
+        parent = Path(path).parent
+
+        if str(parent) not in ("", "."):
+            parent.mkdir(
+                parents=True,
+                exist_ok=True,
+            )
+
+        # SQLite connection can now be accessed
+        # from different threads.
+        self.sqlite = sqlite3.connect(
+            path,
+            check_same_thread=False,
+            timeout=30,
+        )
+
+        self.sqlite.row_factory = sqlite3.Row
+
+        # RLock is important because methods like insert()
+        # acquire the lock and then call find_by_id().
+        self.lock = threading.RLock()
+
+        self._tables = {}
+
+    def create(self, name, schema):
+        if not name:
+            raise ValueError("Table name is required")
+
+        if not isinstance(schema, dict):
+            raise ValueError(
+                f'Schema is required for table "{name}"'
+            )
+
+        with self.lock:
+            if name in self._tables:
+                raise ValueError(
+                    f'Table "{name}" is already registered'
+                )
+
+            sql = compile_schema(name, schema)
+
+            self.sqlite.executescript(sql)
+            self.sqlite.commit()
+
+            table = Table(
+                self,
+                name,
+                schema,
+            )
+
+            self._tables[name] = table
+
+            return table
+
+    def drop(self, name):
+        with self.lock:
+            self.sqlite.execute(
+                f"DROP TABLE IF EXISTS {name}"
+            )
+
+            self.sqlite.commit()
+
+            self._tables.pop(name, None)
+
+            return True
+
+    def tables(self):
+        with self.lock:
+            rows = self.sqlite.execute(
+                """
+                SELECT name
+                FROM sqlite_master
+                WHERE type = 'table'
+                  AND name NOT LIKE 'sqlite_%'
+                ORDER BY name
+                """
+            ).fetchall()
+
+            return [
+                row["name"]
+                for row in rows
+            ]
+
+    def show_tables(self):
+        return self.tables()
+
+    def close(self):
+        with self.lock:
+            self.sqlite.close()

{devdb_sql-1.0.8 → devdb_sql-1.0.9}/devdb_sql/table.py

@@ -1,5 +1,4 @@
 import json
-import sqlite3
 
 from .schema import get_primary_key
 
@@ -37,6 +36,19 @@ class Table:
 
         return value
 
+    def _serialize_query_value(self, field, value):
+        field_type = self.schema[field].get("type")
+
+        if field_type == "boolean":
+            if not isinstance(value, bool):
+                raise ValueError(f"{field} must be a boolean")
+            return 1 if value else 0
+
+        if field_type == "json":
+            return json.dumps(value, separators=(",", ":"))
+
+        return value
+
     def _row_to_dict(self, row):
         if row is None:
             return None
@@ -47,7 +59,10 @@ class Table:
             if field not in result:
                 continue
 
-            if config.get("type") == "boolean" and result[field] is not None:
+            if (
+                config.get("type") == "boolean"
+                and result[field] is not None
+            ):
                 result[field] = bool(result[field])
 
         return result
@@ -66,6 +81,7 @@ class Table:
 
         columns = ", ".join(fields)
         placeholders = ", ".join("?" for _ in fields)
+
         values = [
             self._serialize_value(field, data[field])
             for field in fields
@@ -76,11 +92,12 @@ INSERT INTO {self.name} ({columns})
 VALUES ({placeholders})
 """
 
-        cursor = self.db.sqlite.execute(sql, values)
-        self.db.sqlite.commit()
+        # RLock is used because this method calls find_by_id().
+        with self.db.lock:
+            cursor = self.db.sqlite.execute(sql, values)
+            self.db.sqlite.commit()
 
-        # Preserve the JS SDK's insert -> findById behavior.
-        return self.find_by_id(cursor.lastrowid)
+            return self.find_by_id(cursor.lastrowid)
 
     def find_by_id(self, id):
         sql = f"""
@@ -90,18 +107,29 @@ WHERE {self.primary_key} = ?
 LIMIT 1
 """
 
-        row = self.db.sqlite.execute(sql, (id,)).fetchone()
-        return self._row_to_dict(row)
+        with self.db.lock:
+            row = self.db.sqlite.execute(
+                sql,
+                (id,),
+            ).fetchone()
+
+            return self._row_to_dict(row)
 
     def find_all(self):
-        rows = self.db.sqlite.execute(
-            f"SELECT * FROM {self.name}"
-        ).fetchall()
-        return [self._row_to_dict(row) for row in rows]
+        with self.db.lock:
+            rows = self.db.sqlite.execute(
+                f"SELECT * FROM {self.name}"
+            ).fetchall()
+
+            return [
+                self._row_to_dict(row)
+                for row in rows
+            ]
 
     def find(self, query=None, options=None):
         if query is None:
             query = {}
+
         if options is None:
             options = {}
 
@@ -119,46 +147,72 @@ LIMIT 1
 
             if isinstance(condition, dict):
                 for operator, value in condition.items():
+
                     if operator == "$eq":
                         conditions.append(f"{field} = ?")
-                        values.append(self._serialize_query_value(field, value))
+                        values.append(
+                            self._serialize_query_value(field, value)
+                        )
 
                     elif operator == "$ne":
                         conditions.append(f"{field} != ?")
-                        values.append(self._serialize_query_value(field, value))
+                        values.append(
+                            self._serialize_query_value(field, value)
+                        )
 
                     elif operator == "$gt":
                         conditions.append(f"{field} > ?")
-                        values.append(self._serialize_query_value(field, value))
+                        values.append(
+                            self._serialize_query_value(field, value)
+                        )
 
                     elif operator == "$gte":
                         conditions.append(f"{field} >= ?")
-                        values.append(self._serialize_query_value(field, value))
+                        values.append(
+                            self._serialize_query_value(field, value)
+                        )
 
                     elif operator == "$lt":
                         conditions.append(f"{field} < ?")
-                        values.append(self._serialize_query_value(field, value))
+                        values.append(
+                            self._serialize_query_value(field, value)
+                        )
 
                     elif operator == "$lte":
                         conditions.append(f"{field} <= ?")
-                        values.append(self._serialize_query_value(field, value))
+                        values.append(
+                            self._serialize_query_value(field, value)
+                        )
 
                     elif operator == "$in":
                         if not isinstance(value, list) or not value:
-                            raise ValueError("$in requires a non-empty array")
+                            raise ValueError(
+                                "$in requires a non-empty array"
+                            )
+
+                        placeholders = ", ".join(
+                            "?" for _ in value
+                        )
+
+                        conditions.append(
+                            f"{field} IN ({placeholders})"
+                        )
 
-                        placeholders = ", ".join("?" for _ in value)
-                        conditions.append(f"{field} IN ({placeholders})")
                         values.extend(
                             self._serialize_query_value(field, item)
                             for item in value
                         )
 
                     else:
-                        raise ValueError(f'Unsupported operator "{operator}"')
+                        raise ValueError(
+                            f'Unsupported operator "{operator}"'
+                        )
+
             else:
                 conditions.append(f"{field} = ?")
-                values.append(self._serialize_query_value(field, condition))
+                values.append(
+                    self._serialize_query_value(field, condition)
+                )
 
         sql = f"SELECT * FROM {self.name}"
 
@@ -166,35 +220,56 @@ LIMIT 1
             sql += " WHERE " + " AND ".join(conditions)
 
         order_by = options.get("orderBy")
+
         if order_by:
             self._check_field(order_by)
-            order = "DESC" if options.get("order") == "desc" else "ASC"
+
+            order = (
+                "DESC"
+                if options.get("order") == "desc"
+                else "ASC"
+            )
+
             sql += f" ORDER BY {order_by} {order}"
 
         if "limit" in options:
             limit = options["limit"]
-            if isinstance(limit, bool) or not isinstance(limit, int) or limit < 0:
-                raise ValueError("limit must be a positive integer")
+
+            if (
+                isinstance(limit, bool)
+                or not isinstance(limit, int)
+                or limit < 0
+            ):
+                raise ValueError(
+                    "limit must be a positive integer"
+                )
+
             sql += f" LIMIT {limit}"
 
         if "offset" in options:
             offset = options["offset"]
-            if isinstance(offset, bool) or not isinstance(offset, int) or offset < 0:
-                raise ValueError("offset must be a positive integer")
+
+            if (
+                isinstance(offset, bool)
+                or not isinstance(offset, int)
+                or offset < 0
+            ):
+                raise ValueError(
+                    "offset must be a positive integer"
+                )
+
             sql += f" OFFSET {offset}"
 
-        rows = self.db.sqlite.execute(sql, values).fetchall()
-        return [self._row_to_dict(row) for row in rows]
+        with self.db.lock:
+            rows = self.db.sqlite.execute(
+                sql,
+                values,
+            ).fetchall()
 
-    def _serialize_query_value(self, field, value):
-        field_type = self.schema[field].get("type")
-        if field_type == "boolean":
-            if not isinstance(value, bool):
-                raise ValueError(f"{field} must be a boolean")
-            return 1 if value else 0
-        if field_type == "json":
-            return json.dumps(value, separators=(",", ":"))
-        return value
+            return [
+                self._row_to_dict(row)
+                for row in rows
+            ]
 
     def update_by_id(self, id, data):
         if not isinstance(data, dict):
@@ -209,13 +284,20 @@ LIMIT 1
             self._check_field(field)
 
             if field == self.primary_key:
-                raise ValueError("Primary key cannot be updated")
+                raise ValueError(
+                    "Primary key cannot be updated"
+                )
+
+        set_clause = ", ".join(
+            f"{field} = ?"
+            for field in fields
+        )
 
-        set_clause = ", ".join(f"{field} = ?" for field in fields)
         values = [
             self._serialize_value(field, data[field])
             for field in fields
         ]
+
         values.append(id)
 
         sql = f"""
@@ -224,30 +306,46 @@ SET {set_clause}
 WHERE {self.primary_key} = ?
 """
 
-        cursor = self.db.sqlite.execute(sql, values)
-        self.db.sqlite.commit()
+        with self.db.lock:
+            cursor = self.db.sqlite.execute(
+                sql,
+                values,
+            )
+
+            self.db.sqlite.commit()
 
-        if cursor.rowcount == 0:
-            return None
+            if cursor.rowcount == 0:
+                return None
 
-        return self.find_by_id(id)
+            return self.find_by_id(id)
 
     def delete_by_id(self, id):
-        cursor = self.db.sqlite.execute(
-            f"DELETE FROM {self.name} WHERE {self.primary_key} = ?",
-            (id,),
-        )
-        self.db.sqlite.commit()
-        return cursor.rowcount > 0
+        with self.db.lock:
+            cursor = self.db.sqlite.execute(
+                f"""
+                DELETE FROM {self.name}
+                WHERE {self.primary_key} = ?
+                """,
+                (id,),
+            )
+
+            self.db.sqlite.commit()
+
+            return cursor.rowcount > 0
 
     def drop(self):
-        self.db.sqlite.execute(f"DROP TABLE IF EXISTS {self.name}")
-        self.db.sqlite.commit()
-        self.db._tables.pop(self.name, None)
-        return True
+        with self.db.lock:
+            self.db.sqlite.execute(
+                f"DROP TABLE IF EXISTS {self.name}"
+            )
+
+            self.db.sqlite.commit()
+            self.db._tables.pop(self.name, None)
+
+            return True
 
     # JS-compatible aliases
     findById = find_by_id
     findAll = find_all
     updateById = update_by_id
-    deleteById = delete_by_id
+    deleteById = delete_by_id

{devdb_sql-1.0.8 → devdb_sql-1.0.9}/devdb_sql.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devdb-sql
-Version: 1.0.8
+Version: 1.0.9
 Summary: Lightweight SQLite SDK with a MongoDB-like developer experience
 Author: Mahadev
 License: MIT

{devdb_sql-1.0.8 → devdb_sql-1.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devdb-sql"
-version = "1.0.8"
+version = "1.0.9"
 description = "Lightweight SQLite SDK with a MongoDB-like developer experience"
 readme = "README.md"
 requires-python = ">=3.9"

{devdb_sql-1.0.8 → devdb_sql-1.0.9}/test/test.py

@@ -1,4 +1,4 @@
-from dev_sql import DB
+from devdb_sql import DB
 
 db = DB("./data/msg.db")
 

devdb_sql-1.0.8/devdb_sql/db.py

@@ -1,61 +0,0 @@
-import sqlite3
-from pathlib import Path
-
-from .schema import compile_schema
-from .table import Table
-
-
-class DB:
-    def __init__(self, path):
-        if not path:
-            raise ValueError("Database path is required")
-
-        self.path = path
-
-        parent = Path(path).parent
-        if str(parent) not in ("", "."):
-            parent.mkdir(parents=True, exist_ok=True)
-
-        self.sqlite = sqlite3.connect(path)
-        self.sqlite.row_factory = sqlite3.Row
-        self._tables = {}
-
-    def create(self, name, schema):
-        if not name:
-            raise ValueError("Table name is required")
-
-        if not isinstance(schema, dict):
-            raise ValueError(f'Schema is required for table "{name}"')
-
-        if name in self._tables:
-            raise ValueError(f'Table "{name}" is already registered')
-
-        sql = compile_schema(name, schema)
-        self.sqlite.executescript(sql)
-        self.sqlite.commit()
-
-        table = Table(self, name, schema)
-        self._tables[name] = table
-        return table
-
-    def drop(self, name):
-        self.sqlite.execute(f"DROP TABLE IF EXISTS {name}")
-        self.sqlite.commit()
-        self._tables.pop(name, None)
-        return True
-
-    def tables(self):
-        rows = self.sqlite.execute("""
-            SELECT name
-            FROM sqlite_master
-            WHERE type = 'table'
-              AND name NOT LIKE 'sqlite_%'
-            ORDER BY name
-        """).fetchall()
-        return [row["name"] for row in rows]
-
-    def show_tables(self):
-        return self.tables()
-
-    def close(self):
-        self.sqlite.close()