pyflashdb 1.0.1__py3-none-any.whl

flash/filters.py

@@ -0,0 +1,140 @@
+"""
+Query filter translation utilities.
+Converts Flash's unified filter syntax to SQL WHERE clauses or MongoDB query dicts.
+"""
+
+# Mapping from Flash operators to SQL and MongoDB equivalents
+OPERATOR_MAP = {
+    ">": {"sql": ">", "mongo": "$gt"},
+    "<": {"sql": "<", "mongo": "$lt"},
+    ">=": {"sql": ">=", "mongo": "$gte"},
+    "<=": {"sql": "<=", "mongo": "$lte"},
+    "!=": {"sql": "!=", "mongo": "$ne"},
+    "=": {"sql": "=", "mongo": "$eq"},
+    "in": {"sql": "IN", "mongo": "$in"},
+    "not in": {"sql": "NOT IN", "mongo": "$nin"},
+    "like": {"sql": "LIKE", "mongo": "$regex"},
+}
+
+
+def filters_to_sql(filters: dict) -> tuple:
+    """
+    Convert Flash filter dict to SQL WHERE clause + params list.
+
+    Example:
+        filters = {"age": {">": 18}, "name": "John"}
+        -> ("age > %s AND name = %s", [18, "John"])
+
+    Returns:
+        (clause_str, params_list)
+    """
+    if not filters:
+        return "", []
+
+    clauses = []
+    params = []
+
+    for field, value in filters.items():
+        if isinstance(value, dict):
+            for op, val in value.items():
+                sql_op = OPERATOR_MAP.get(op, {}).get("sql", op)
+                if op in ("in", "not in"):
+                    placeholders = ", ".join(["%s"] * len(val))
+                    clauses.append(f"{field} {sql_op} ({placeholders})")
+                    params.extend(val)
+                else:
+                    clauses.append(f"{field} {sql_op} %s")
+                    params.append(val)
+        else:
+            clauses.append(f"{field} = %s")
+            params.append(value)
+
+    return " AND ".join(clauses), params
+
+
+def filters_to_mongo(filters: dict) -> dict:
+    """
+    Convert Flash filter dict to MongoDB query dict.
+
+    Example:
+        filters = {"age": {">": 18}, "name": "John"}
+        -> {"age": {"$gt": 18}, "name": "John"}
+    """
+    if not filters:
+        return {}
+
+    query = {}
+
+    for field, value in filters.items():
+        if isinstance(value, dict):
+            mongo_expr = {}
+            for op, val in value.items():
+                mongo_op = OPERATOR_MAP.get(op, {}).get("mongo")
+                if mongo_op:
+                    mongo_expr[mongo_op] = val
+                else:
+                    mongo_expr[op] = val
+            query[field] = mongo_expr
+        else:
+            query[field] = value
+
+    return query
+
+
+def build_update_sql(data: dict) -> tuple:
+    """
+    Build SQL SET clause from update data dict.
+
+    Returns:
+        (set_clause_str, params_list)
+    """
+    if not data:
+        return "", []
+
+    clauses = [f"{field} = %s" for field in data.keys()]
+    params = list(data.values())
+
+    return ", ".join(clauses), params
+
+
+def python_type_to_sql(type_str: str, db_type: str = "mysql") -> str:
+    """
+    Convert Flash type strings to DB-specific SQL column types.
+    """
+    type_map = {
+        "mysql": {
+            "int": "INT",
+            "integer": "INT",
+            "str": "VARCHAR(255)",
+            "string": "VARCHAR(255)",
+            "text": "TEXT",
+            "float": "FLOAT",
+            "double": "DOUBLE",
+            "bool": "TINYINT(1)",
+            "boolean": "TINYINT(1)",
+            "date": "DATE",
+            "datetime": "DATETIME",
+            "timestamp": "TIMESTAMP",
+            "json": "JSON",
+            "blob": "BLOB",
+        },
+        "postgres": {
+            "int": "INTEGER",
+            "integer": "INTEGER",
+            "str": "VARCHAR(255)",
+            "string": "VARCHAR(255)",
+            "text": "TEXT",
+            "float": "REAL",
+            "double": "DOUBLE PRECISION",
+            "bool": "BOOLEAN",
+            "boolean": "BOOLEAN",
+            "date": "DATE",
+            "datetime": "TIMESTAMP",
+            "timestamp": "TIMESTAMP",
+            "json": "JSONB",
+            "blob": "BYTEA",
+        },
+    }
+
+    db_types = type_map.get(db_type, type_map["mysql"])
+    return db_types.get(type_str.lower(), type_str.upper())

flash/triggers.py

@@ -0,0 +1,148 @@
+"""
+Trigger and hook system for Flash.
+Supports before/after hooks for insert, update, delete operations.
+"""
+
+from collections import defaultdict
+from typing import Callable, Optional
+
+
+class TriggerRegistry:
+    """
+    Registry for before/after operation hooks on collections/tables.
+    """
+
+    VALID_EVENTS = {"insert", "update", "delete", "select"}
+    VALID_TIMINGS = {"before", "after"}
+
+    def __init__(self):
+        # Structure: {timing: {event: {table: [callable, ...]}}}
+        self._hooks: dict = {
+            "before": defaultdict(lambda: defaultdict(list)),
+            "after": defaultdict(lambda: defaultdict(list)),
+        }
+
+    def register(self, timing: str, event: str, table: str, fn: Callable):
+        """Register a hook function for a given timing, event, and table."""
+        if timing not in self.VALID_TIMINGS:
+            raise ValueError(f"Invalid timing '{timing}'. Choose from: {self.VALID_TIMINGS}")
+        if event not in self.VALID_EVENTS:
+            raise ValueError(f"Invalid event '{event}'. Choose from: {self.VALID_EVENTS}")
+
+        self._hooks[timing][event][table].append(fn)
+
+    def fire(self, timing: str, event: str, table: str, data, result=None):
+        """
+        Fire all hooks for a given timing/event/table.
+
+        Args:
+            timing: 'before' or 'after'
+            event: 'insert', 'update', 'delete', 'select'
+            table: collection/table name
+            data: the payload (filter or record dict)
+            result: the query result (only for 'after' hooks)
+        """
+        hooks = self._hooks[timing][event].get(table, [])
+        for fn in hooks:
+            try:
+                if timing == "after":
+                    fn(data, result)
+                else:
+                    fn(data)
+            except Exception as e:
+                print(f"[Flash Warning] Hook '{fn.__name__}' raised an error: {e}")
+
+    def clear(self, table: Optional[str] = None):
+        """Clear all hooks, or hooks for a specific table."""
+        if table:
+            for timing in self.VALID_TIMINGS:
+                for event in self.VALID_EVENTS:
+                    self._hooks[timing][event].pop(table, None)
+        else:
+            self.__init__()
+
+    def list_hooks(self) -> dict:
+        """Return a summary of all registered hooks."""
+        summary = {}
+        for timing in self.VALID_TIMINGS:
+            for event in self.VALID_EVENTS:
+                for table, fns in self._hooks[timing][event].items():
+                    key = f"{timing}_{event}:{table}"
+                    summary[key] = [fn.__name__ for fn in fns]
+        return {k: v for k, v in summary.items() if v}
+
+
+# Singleton registry shared across a FlashDB instance
+def make_trigger_mixin():
+    """
+    Returns a mixin class providing decorator-style trigger registration.
+    Each FlashDB instance gets its own mixin with its own registry.
+    """
+
+    class TriggerMixin:
+        def _init_triggers(self):
+            self._triggers = TriggerRegistry()
+
+        # ── Decorator API ─────────────────────────────────────────────────
+        def before_insert(self, table: str):
+            def decorator(fn: Callable):
+                self._triggers.register("before", "insert", table, fn)
+                return fn
+            return decorator
+
+        def after_insert(self, table: str):
+            def decorator(fn: Callable):
+                self._triggers.register("after", "insert", table, fn)
+                return fn
+            return decorator
+
+        def before_update(self, table: str):
+            def decorator(fn: Callable):
+                self._triggers.register("before", "update", table, fn)
+                return fn
+            return decorator
+
+        def after_update(self, table: str):
+            def decorator(fn: Callable):
+                self._triggers.register("after", "update", table, fn)
+                return fn
+            return decorator
+
+        def before_delete(self, table: str):
+            def decorator(fn: Callable):
+                self._triggers.register("before", "delete", table, fn)
+                return fn
+            return decorator
+
+        def after_delete(self, table: str):
+            def decorator(fn: Callable):
+                self._triggers.register("after", "delete", table, fn)
+                return fn
+            return decorator
+
+        def before_select(self, table: str):
+            def decorator(fn: Callable):
+                self._triggers.register("before", "select", table, fn)
+                return fn
+            return decorator
+
+        def after_select(self, table: str):
+            def decorator(fn: Callable):
+                self._triggers.register("after", "select", table, fn)
+                return fn
+            return decorator
+
+        # ── Programmatic API ──────────────────────────────────────────────
+        def add_hook(self, timing: str, event: str, table: str, fn: Callable):
+            """Programmatically register a hook without decorators."""
+            self._triggers.register(timing, event, table, fn)
+
+        def list_hooks(self) -> dict:
+            """List all registered hooks."""
+            return self._triggers.list_hooks()
+
+        def clear_hooks(self, table: Optional[str] = None):
+            """Remove hooks (all, or for a specific table)."""
+            self._triggers.clear(table)
+
+    return TriggerMixin

pyflashdb-1.0.1.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: pyflashdb
+Version: 1.0.1
+Summary: A unified, trigger-aware database interface for MySQL, PostgreSQL, and MongoDB.
+Author: Flash Team
+Keywords: database mysql postgresql mongodb orm crud flash unified
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: mysql
+Requires-Dist: mysql-connector-python>=8.0; extra == "mysql"
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9; extra == "postgres"
+Provides-Extra: mongodb
+Requires-Dist: pymongo>=4.0; extra == "mongodb"
+Provides-Extra: all
+Requires-Dist: mysql-connector-python>=8.0; extra == "all"
+Requires-Dist: psycopg2-binary>=2.9; extra == "all"
+Requires-Dist: pymongo>=4.0; extra == "all"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+# flash
+A lightweight, multi-database Python library that provides simple CRUD operations, unified query syntax, and trigger hooks with minimal setup

pyflashdb-1.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+flash/__init__.py,sha256=Qp4vnw9Y0ty_khkEQo7zLMo8qU0Nzg4JOvIIY0W62RU,298
+flash/core.py,sha256=p8MVgA5B99ckz7xmBfiqGYNzpu2dfYn6zG5AppddocQ,11512
+flash/exceptions.py,sha256=WI8H95LM9CV9wbqirNVcmbbzhIKIFlAdokt5FTQsqRk,658
+flash/filters.py,sha256=GIyY1SQkQLYjJyx9Rrgna11oD60l7wnZnOtiBTq94Fc,4091
+flash/triggers.py,sha256=8RoSLd9HashQ85wAr0Xgn45BVaTaDnDaPRkbxmBYFW0,5744
+flash/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flash/adapters/mongo_adapter.py,sha256=zCZ4nzLPkcaHVTSZrr27Bt4zjOuQd_Oedi5tWUuKma4,9495
+flash/adapters/mysql_adapter.py,sha256=Brd9LAZu7JYoUyaYs-MUCWkpVjFRGhB3bVFOttTpqe8,8429
+flash/adapters/postgres_adapter.py,sha256=u6fNx2VSE18GtbNvEQMZ4PMbz8YvZbPt0GAnuJhNw7E,9061
+pyflashdb-1.0.1.dist-info/METADATA,sha256=RlH_ioWYTnA3XmyNLNTDXt0lCpzzWjx-n3o6moBN7dM,1283
+pyflashdb-1.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyflashdb-1.0.1.dist-info/top_level.txt,sha256=gPTfQwGao1M89TdHszAxa2fgqvl88iO9S3O7zmm7GoE,6
+pyflashdb-1.0.1.dist-info/RECORD,,

pyflashdb-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyflashdb-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+flash