pyflashdb 1.0.1__py3-none-any.whl

flash/__init__.py

@@ -0,0 +1,10 @@
+"""
+Flash - A unified database interface for MySQL, PostgreSQL, and MongoDB.
+"""
+
+from .core import FlashDB
+from .exceptions import FlashError, ConnectionError, QueryError
+
+__version__ = "1.0.0"
+__author__ = "Flash Team"
+__all__ = ["FlashDB", "FlashError", "ConnectionError", "QueryError"]

flash/adapters/mongo_adapter.py

@@ -0,0 +1,247 @@
+"""
+MongoDB adapter for Flash.
+Requires: pip install pymongo
+"""
+
+from typing import Any, Dict, List, Optional
+from ..filters import filters_to_mongo
+from ..exceptions import ConnectionError, QueryError
+
+
+class MongoAdapter:
+    """
+    MongoDB backend adapter for FlashDB.
+    Uses pymongo under the hood.
+    """
+
+    def __init__(self, config: dict):
+        self.config = config
+        self.client = None
+        self.db = None
+        self._connect()
+
+    def _connect(self):
+        try:
+            from pymongo import MongoClient
+            from pymongo.errors import ConnectionFailure
+
+            uri = self.config.get("uri")
+            if uri:
+                self.client = MongoClient(uri)
+            else:
+                host = self.config.get("host", "localhost")
+                port = self.config.get("port", 27017)
+                user = self.config.get("user")
+                password = self.config.get("password")
+
+                if user and password:
+                    self.client = MongoClient(
+                        host=host, port=port, username=user, password=password
+                    )
+                else:
+                    self.client = MongoClient(host=host, port=port)
+
+            db_name = self.config.get("database", "flash_db")
+            self.db = self.client[db_name]
+
+            # Test connection
+            self.client.admin.command("ping")
+
+        except ImportError:
+            raise ConnectionError(
+                "pymongo is not installed. Run: pip install pymongo"
+            )
+        except Exception as e:
+            raise ConnectionError(f"MongoDB connection failed: {e}")
+
+    def _col(self, table: str):
+        """Return the pymongo Collection for the given table/collection name."""
+        return self.db[table]
+
+    def _clean(self, doc) -> dict:
+        """Convert ObjectId to string for clean output."""
+        if doc and "_id" in doc:
+            doc["_id"] = str(doc["_id"])
+        return doc
+
+    # ── Core CRUD ──────────────────────────────────────────────────────────
+
+    def all(self, table: str) -> List[dict]:
+        return [self._clean(d) for d in self._col(table).find()]
+
+    def select(self, table: str, fields: List[str] = None, filters: dict = None,
+               limit: int = None, offset: int = None, order_by: str = None) -> List[dict]:
+        query = filters_to_mongo(filters) if filters else {}
+        projection = {f: 1 for f in fields} if fields else None
+
+        cursor = self._col(table).find(query, projection)
+
+        if order_by:
+            # Support "field" (asc) or "-field" (desc)
+            if order_by.startswith("-"):
+                cursor = cursor.sort(order_by[1:], -1)
+            else:
+                cursor = cursor.sort(order_by, 1)
+
+        if offset:
+            cursor = cursor.skip(int(offset))
+        if limit:
+            cursor = cursor.limit(int(limit))
+
+        return [self._clean(d) for d in cursor]
+
+    def add(self, table: str, data: dict) -> str:
+        try:
+            result = self._col(table).insert_one(data.copy())
+            return str(result.inserted_id)
+        except Exception as e:
+            raise QueryError(f"MongoDB insert failed: {e}")
+
+    def bulk_insert(self, table: str, records: List[dict]) -> int:
+        if not records:
+            return 0
+        try:
+            result = self._col(table).insert_many([r.copy() for r in records])
+            return len(result.inserted_ids)
+        except Exception as e:
+            raise QueryError(f"MongoDB bulk insert failed: {e}")
+
+    def update(self, table: str, filters: dict, data: dict) -> int:
+        query = filters_to_mongo(filters)
+        try:
+            result = self._col(table).update_many(query, {"$set": data})
+            return result.modified_count
+        except Exception as e:
+            raise QueryError(f"MongoDB update failed: {e}")
+
+    def delete(self, table: str, filters: dict = None) -> int:
+        query = filters_to_mongo(filters) if filters else {}
+        try:
+            result = self._col(table).delete_many(query)
+            return result.deleted_count
+        except Exception as e:
+            raise QueryError(f"MongoDB delete failed: {e}")
+
+    # ── Schema / Collection Operations ─────────────────────────────────────
+
+    def create_table(self, table: str, schema: dict = None, primary_key: str = "id") -> bool:
+        """
+        In MongoDB, collections are created implicitly.
+        This optionally applies a JSON Schema validator.
+        """
+        if schema:
+            props = {}
+            for field, typ in schema.items():
+                bson_type = self._py_to_bson(typ)
+                props[field] = {"bsonType": bson_type}
+
+            validator = {
+                "$jsonSchema": {
+                    "bsonType": "object",
+                    "properties": props,
+                }
+            }
+            try:
+                self.db.create_collection(table, validator=validator)
+            except Exception:
+                # Collection may already exist; apply collMod instead
+                self.db.command("collMod", table, validator=validator)
+        else:
+            if table not in self.db.list_collection_names():
+                self.db.create_collection(table)
+        return True
+
+    def drop_table(self, table: str) -> bool:
+        self._col(table).drop()
+        return True
+
+    def truncate(self, table: str) -> bool:
+        self._col(table).delete_many({})
+        return True
+
+    def show_tables(self) -> List[str]:
+        return self.db.list_collection_names()
+
+    def describe(self, table: str) -> dict:
+        """Return collection stats as schema info."""
+        return self.db.command("collStats", table)
+
+    def create_index(self, table: str, field: str, unique: bool = False) -> str:
+        from pymongo import ASCENDING
+        result = self._col(table).create_index([(field, ASCENDING)], unique=unique)
+        return result
+
+    # ── Transactions (MongoDB 4.0+ with replica set) ───────────────────────
+
+    def begin(self):
+        self._session = self.client.start_session()
+        self._session.start_transaction()
+
+    def commit(self):
+        if hasattr(self, "_session"):
+            self._session.commit_transaction()
+            self._session.end_session()
+
+    def rollback(self):
+        if hasattr(self, "_session"):
+            self._session.abort_transaction()
+            self._session.end_session()
+
+    # ── Raw Query ──────────────────────────────────────────────────────────
+
+    def raw(self, command: dict, table: str = None) -> Any:
+        """
+        Execute a raw MongoDB command.
+        For collection-level ops pass table; otherwise it runs on the DB.
+        """
+        try:
+            if table:
+                return list(self._col(table).find(command))
+            return self.db.command(command)
+        except Exception as e:
+            raise QueryError(f"MongoDB raw command failed: {e}")
+
+    # ── Count ──────────────────────────────────────────────────────────────
+
+    def count(self, table: str, filters: dict = None) -> int:
+        query = filters_to_mongo(filters) if filters else {}
+        return self._col(table).count_documents(query)
+
+    # ── Aggregation ────────────────────────────────────────────────────────
+
+    def aggregate(self, table: str, pipeline: list) -> List[dict]:
+        return [self._clean(d) for d in self._col(table).aggregate(pipeline)]
+
+    # ── Lifecycle ──────────────────────────────────────────────────────────
+
+    def close(self):
+        if self.client:
+            self.client.close()
+
+    def ping(self) -> bool:
+        try:
+            self.client.admin.command("ping")
+            return True
+        except Exception:
+            return False
+
+    # ── Helpers ────────────────────────────────────────────────────────────
+
+    def _py_to_bson(self, type_str: str) -> str:
+        mapping = {
+            "int": "int",
+            "integer": "int",
+            "str": "string",
+            "string": "string",
+            "text": "string",
+            "float": "double",
+            "double": "double",
+            "bool": "bool",
+            "boolean": "bool",
+            "date": "date",
+            "datetime": "date",
+            "list": "array",
+            "dict": "object",
+            "json": "object",
+        }
+        return mapping.get(type_str.lower(), "string")

flash/adapters/mysql_adapter.py

@@ -0,0 +1,217 @@
+"""
+MySQL adapter for Flash.
+Requires: pip install mysql-connector-python
+"""
+
+from typing import Any, Dict, List, Optional
+from ..filters import filters_to_sql, build_update_sql, python_type_to_sql
+from ..exceptions import ConnectionError, QueryError, TransactionError
+
+
+class MySQLAdapter:
+    """
+    MySQL backend adapter for FlashDB.
+    Uses mysql-connector-python under the hood.
+    """
+
+    def __init__(self, config: dict):
+        self.config = config
+        self.conn = None
+        self.cursor = None
+        self._in_transaction = False
+        self._connect()
+
+    def _connect(self):
+        try:
+            import mysql.connector
+            self.conn = mysql.connector.connect(
+                host=self.config.get("host", "localhost"),
+                port=self.config.get("port", 3306),
+                user=self.config.get("user", "root"),
+                password=self.config.get("password", ""),
+                database=self.config.get("database"),
+                autocommit=True,
+            )
+            self.cursor = self.conn.cursor(dictionary=True)
+        except ImportError:
+            raise ConnectionError(
+                "mysql-connector-python is not installed. Run: pip install mysql-connector-python"
+            )
+        except Exception as e:
+            raise ConnectionError(f"MySQL connection failed: {e}")
+
+    def _execute(self, sql: str, params: list = None) -> Any:
+        try:
+            self.cursor.execute(sql, params or [])
+            return self.cursor
+        except Exception as e:
+            raise QueryError(f"MySQL query failed: {e}\nSQL: {sql}\nParams: {params}")
+
+    # ── Core CRUD ──────────────────────────────────────────────────────────
+
+    def all(self, table: str) -> List[dict]:
+        self._execute(f"SELECT * FROM `{table}`")
+        return self.cursor.fetchall()
+
+    def select(self, table: str, fields: List[str] = None, filters: dict = None,
+               limit: int = None, offset: int = None, order_by: str = None) -> List[dict]:
+        cols = ", ".join(f"`{f}`" for f in fields) if fields else "*"
+        sql = f"SELECT {cols} FROM `{table}`"
+        params = []
+
+        if filters:
+            clause, params = filters_to_sql(filters)
+            sql += f" WHERE {clause}"
+
+        if order_by:
+            sql += f" ORDER BY {order_by}"
+
+        if limit is not None:
+            sql += f" LIMIT {int(limit)}"
+            if offset is not None:
+                sql += f" OFFSET {int(offset)}"
+
+        self._execute(sql, params)
+        return self.cursor.fetchall()
+
+    def add(self, table: str, data: dict) -> int:
+        fields = ", ".join(f"`{k}`" for k in data.keys())
+        placeholders = ", ".join(["%s"] * len(data))
+        sql = f"INSERT INTO `{table}` ({fields}) VALUES ({placeholders})"
+        self._execute(sql, list(data.values()))
+        if not self._in_transaction:
+            self.conn.commit()
+        return self.cursor.lastrowid
+
+    def bulk_insert(self, table: str, records: List[dict]) -> int:
+        if not records:
+            return 0
+        fields = ", ".join(f"`{k}`" for k in records[0].keys())
+        placeholders = ", ".join(["%s"] * len(records[0]))
+        sql = f"INSERT INTO `{table}` ({fields}) VALUES ({placeholders})"
+        rows = [list(r.values()) for r in records]
+        try:
+            self.cursor.executemany(sql, rows)
+            if not self._in_transaction:
+                self.conn.commit()
+            return self.cursor.rowcount
+        except Exception as e:
+            raise QueryError(f"MySQL bulk insert failed: {e}")
+
+    def update(self, table: str, filters: dict, data: dict) -> int:
+        set_clause, set_params = build_update_sql(data)
+        where_clause, where_params = filters_to_sql(filters)
+        sql = f"UPDATE `{table}` SET {set_clause}"
+        if where_clause:
+            sql += f" WHERE {where_clause}"
+        self._execute(sql, set_params + where_params)
+        if not self._in_transaction:
+            self.conn.commit()
+        return self.cursor.rowcount
+
+    def delete(self, table: str, filters: dict = None) -> int:
+        sql = f"DELETE FROM `{table}`"
+        params = []
+        if filters:
+            clause, params = filters_to_sql(filters)
+            sql += f" WHERE {clause}"
+        self._execute(sql, params)
+        if not self._in_transaction:
+            self.conn.commit()
+        return self.cursor.rowcount
+
+    # ── Schema Operations ──────────────────────────────────────────────────
+
+    def create_table(self, table: str, schema: dict, primary_key: str = "id") -> bool:
+        col_defs = []
+        has_pk = False
+        for col, typ in schema.items():
+            sql_type = python_type_to_sql(typ, "mysql")
+            if col == primary_key:
+                col_defs.append(f"`{col}` {sql_type} AUTO_INCREMENT PRIMARY KEY")
+                has_pk = True
+            else:
+                col_defs.append(f"`{col}` {sql_type}")
+        if not has_pk:
+            col_defs.insert(0, f"`{primary_key}` INT AUTO_INCREMENT PRIMARY KEY")
+
+        sql = f"CREATE TABLE IF NOT EXISTS `{table}` ({', '.join(col_defs)})"
+        self._execute(sql)
+        return True
+
+    def drop_table(self, table: str) -> bool:
+        self._execute(f"DROP TABLE IF EXISTS `{table}`")
+        return True
+
+    def truncate(self, table: str) -> bool:
+        self._execute(f"TRUNCATE TABLE `{table}`")
+        return True
+
+    def show_tables(self) -> List[str]:
+        self._execute("SHOW TABLES")
+        rows = self.cursor.fetchall()
+        return [list(r.values())[0] for r in rows]
+
+    def describe(self, table: str) -> List[dict]:
+        self._execute(f"DESCRIBE `{table}`")
+        return self.cursor.fetchall()
+
+    # ── Transactions ───────────────────────────────────────────────────────
+
+    def begin(self):
+        self.conn.autocommit = False
+        self._in_transaction = True
+
+    def commit(self):
+        try:
+            self.conn.commit()
+        except Exception as e:
+            raise TransactionError(f"Commit failed: {e}")
+        finally:
+            self.conn.autocommit = True
+            self._in_transaction = False
+
+    def rollback(self):
+        try:
+            self.conn.rollback()
+        except Exception as e:
+            raise TransactionError(f"Rollback failed: {e}")
+        finally:
+            self.conn.autocommit = True
+            self._in_transaction = False
+
+    # ── Raw Query ──────────────────────────────────────────────────────────
+
+    def raw(self, sql: str, params: list = None) -> Any:
+        self._execute(sql, params)
+        try:
+            return self.cursor.fetchall()
+        except Exception:
+            return self.cursor.rowcount
+
+    # ── Count ──────────────────────────────────────────────────────────────
+
+    def count(self, table: str, filters: dict = None) -> int:
+        sql = f"SELECT COUNT(*) as cnt FROM `{table}`"
+        params = []
+        if filters:
+            clause, params = filters_to_sql(filters)
+            sql += f" WHERE {clause}"
+        self._execute(sql, params)
+        row = self.cursor.fetchone()
+        return row["cnt"] if row else 0
+
+    # ── Lifecycle ──────────────────────────────────────────────────────────
+
+    def close(self):
+        if self.cursor:
+            self.cursor.close()
+        if self.conn:
+            self.conn.close()
+
+    def ping(self) -> bool:
+        try:
+            self.conn.ping(reconnect=True)
+            return True
+        except Exception:
+            return False