future-framework 1.1.0__py3-none-any.whl

future/databases/Elasticsearch.py

@@ -0,0 +1,146 @@
+from future.databases.Database import Database
+from future.plugins.ElasticsearchPlugin import ElasticsearchPlugin
+
+
+class Elasticsearch(Database):
+    def __init__(self, host: str, port: int, username: str, password: str, database: str = ""):
+        super().__init__(host, port, username, password, database)
+        self.client = ElasticsearchPlugin(host=host, username=username, password=password)
+
+    def connect(self):
+        return self.client
+
+    def disconnect(self):
+        pass
+
+    def save(self, model):
+        name = model.tableize()
+        return self.client.index_document(name, model.to_dict(), document_id=getattr(model, "id", None))
+
+    def find(self, model, id):
+        result = self.client.get_document(model.tableize(), id)
+        if not result or "error" in result or "_source" not in result:
+            return None
+        return model.__class__(**result["_source"])
+
+    def all(self, model):
+        result = self.client.search_documents(model.tableize(), {"query": {"match_all": {}}, "size": 10000})
+        if not result or "error" in result:
+            return []
+        return [model.__class__(**hit["_source"]) for hit in result.get("hits", {}).get("hits", [])]
+
+    def get(self, model, wheres, limit=None, orders=None):
+        must = []
+        for column, operator, value in wheres:
+            if operator == "=":
+                must.append({"match": {column: value}})
+            elif operator == ">":
+                must.append({"range": {column: {"gt": value}}})
+            elif operator == ">=":
+                must.append({"range": {column: {"gte": value}}})
+            elif operator == "<":
+                must.append({"range": {column: {"lt": value}}})
+            elif operator == "<=":
+                must.append({"range": {column: {"lte": value}}})
+            elif operator == "!=":
+                must.append({"bool": {"must_not": [{"match": {column: value}}]}})
+            elif operator == "in":
+                must.append({"terms": {column: list(value)}})
+            elif operator == "like":
+                pattern = str(value).replace("%", "*").replace("_", "?")
+                must.append({"wildcard": {column: pattern}})
+            else:
+                raise ValueError(f"Unsupported operator: {operator}")
+        size = limit if limit is not None else 10000
+        body = {"query": {"bool": {"must": must}}, "size": size}
+        if orders:
+            body["sort"] = [{column: {"order": direction}} for column, direction in orders]
+        result = self.client.search_documents(model.tableize(), body)
+        if not result or "error" in result:
+            return []
+        return [model.__class__(**hit["_source"]) for hit in result.get("hits", {}).get("hits", [])]
+
+    def delete(self, model):
+        return self.client.delete_document(model.tableize(), getattr(model, "id", None))
+
+    def update(self, model, changes):
+        return self.client.update_document(model.tableize(), getattr(model, "id", None), changes)
+
+    def schema_create(self, blueprint):
+        properties = {}
+        for column in blueprint.columns:
+            if column.type == "string" and (column.is_primary or column.name == "id"):
+                properties[column.name] = {"type": "keyword"}
+            elif column.type == "string":
+                properties[column.name] = {"type": "text", "fields": {"keyword": {"type": "keyword", "ignore_above": 256}}}
+            elif column.type == "text":
+                properties[column.name] = {"type": "text"}
+            elif column.type == "integer":
+                properties[column.name] = {"type": "long"}
+            elif column.type == "float":
+                properties[column.name] = {"type": "double"}
+            elif column.type == "boolean":
+                properties[column.name] = {"type": "boolean"}
+            elif column.type == "datetime":
+                properties[column.name] = {"type": "date"}
+            else:
+                raise ValueError(f"Unsupported column type: {column.type}")
+        mapping = {"properties": properties}
+        if self.client.index_exists(blueprint.name):
+            return {"status": "exists", "index": blueprint.name}
+        result = self.client.create_index(blueprint.name, mapping=mapping)
+        if isinstance(result, dict) and "error" in result:
+            raise RuntimeError(result["error"])
+        return result
+
+    def schema_drop(self, name):
+        if not self.client.index_exists(name):
+            return {"status": "missing", "index": name}
+        result = self.client.delete_index(name)
+        if isinstance(result, dict) and "error" in result:
+            raise RuntimeError(result["error"])
+        return result
+
+    def _ensure_migrations_index(self):
+        if self.client.index_exists("migrations"):
+            return
+        mapping = {"properties": {"name": {"type": "keyword"}, "batch": {"type": "integer"}}}
+        result = self.client.create_index("migrations", mapping=mapping)
+        if isinstance(result, dict) and "error" in result:
+            raise RuntimeError(result["error"])
+
+    def migrations_get(self):
+        self._ensure_migrations_index()
+        result = self.client.search_documents("migrations", {"query": {"match_all": {}}, "size": 10000, "sort": [{"batch": "asc"}, {"name": "asc"}]})
+        if not result or "error" in result:
+            return []
+        return [hit["_source"]["name"] for hit in result.get("hits", {}).get("hits", [])]
+
+    def migrations_put(self, name, batch):
+        self._ensure_migrations_index()
+        result = self.client.index_document("migrations", {"name": name, "batch": batch}, document_id=name)
+        if isinstance(result, dict) and "error" in result:
+            raise RuntimeError(result["error"])
+
+    def migrations_delete(self, name):
+        self._ensure_migrations_index()
+        result = self.client.delete_document("migrations", name)
+        if isinstance(result, dict) and "error" in result:
+            raise RuntimeError(result["error"])
+
+    def migrations_max_batch(self):
+        self._ensure_migrations_index()
+        result = self.client.search_documents("migrations", {"query": {"match_all": {}}, "size": 0, "aggs": {"max_batch": {"max": {"field": "batch"}}}})
+        if not result or "error" in result:
+            return 0
+        value = result.get("aggregations", {}).get("max_batch", {}).get("value")
+        if value is None:
+            return 0
+        return int(value)
+
+    def migrations_batch_for(self, name):
+        self._ensure_migrations_index()
+        result = self.client.get_document("migrations", name)
+        if not result or "error" in result or "_source" not in result:
+            return None
+        return int(result["_source"]["batch"])

future/databases/MongoDB.py

@@ -0,0 +1,177 @@
+from future.databases.Database import Database
+import re
+
+
+class MongoDB(Database):
+    def __init__(self, host: str, port: int, username: str, password: str, database: str):
+        super().__init__(host, port, username, password, database)
+        self.client = None
+        self.db = None
+
+    def connect(self):
+        from pymongo import MongoClient
+        if self.username:
+            uri = f"mongodb://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
+        else:
+            uri = f"mongodb://{self.host}:{self.port}/{self.database}"
+        self.client = MongoClient(uri)
+        self.db = self.client[self.database]
+        return self.client
+
+    def disconnect(self):
+        if self.client is not None:
+            self.client.close()
+            self.client = None
+            self.db = None
+
+    def save(self, model):
+        if self.db is None:
+            self.connect()
+        name = model.tableize()
+        data = model.to_dict()
+        doc_id = data.get("id")
+        if doc_id is not None:
+            self.db[name].replace_one({"id": doc_id}, data, upsert=True)
+        else:
+            self.db[name].insert_one(data)
+        return {"status": "saved", "collection": name, "id": doc_id}
+
+    def find(self, model, id):
+        if self.db is None:
+            self.connect()
+        doc = self.db[model.tableize()].find_one({"id": id}, {"_id": 0})
+        if doc is None:
+            return None
+        return model.__class__(**doc)
+
+    def all(self, model):
+        if self.db is None:
+            self.connect()
+        return [model.__class__(**doc) for doc in self.db[model.tableize()].find({}, {"_id": 0})]
+
+    def get(self, model, wheres, limit=None, orders=None):
+        if self.db is None:
+            self.connect()
+        query = {}
+        for column, operator, value in wheres:
+            if operator == "=":
+                query[column] = value
+            elif operator == "in":
+                query[column] = {"$in": list(value)}
+            elif operator == ">":
+                query[column] = {"$gt": value}
+            elif operator == ">=":
+                query[column] = {"$gte": value}
+            elif operator == "<":
+                query[column] = {"$lt": value}
+            elif operator == "<=":
+                query[column] = {"$lte": value}
+            elif operator == "!=":
+                query[column] = {"$ne": value}
+            elif operator == "like":
+                parts = []
+                for char in str(value):
+                    if char == "%":
+                        parts.append(".*")
+                    elif char == "_":
+                        parts.append(".")
+                    else:
+                        parts.append(re.escape(char))
+                query[column] = {"$regex": "^" + "".join(parts) + "$"}
+            else:
+                raise ValueError(f"Unsupported operator: {operator}")
+        cursor = self.db[model.tableize()].find(query, {"_id": 0})
+        if orders:
+            cursor = cursor.sort([(column, 1 if str(direction).upper() == "ASC" else -1) for column, direction in orders])
+        if limit is not None:
+            cursor = cursor.limit(int(limit))
+        return [model.__class__(**doc) for doc in cursor]
+
+    def delete(self, model):
+        if self.db is None:
+            self.connect()
+        name = model.tableize()
+        doc_id = getattr(model, "id", None)
+        self.db[name].delete_one({"id": doc_id})
+        return {"status": "deleted", "collection": name, "id": doc_id}
+
+    def update(self, model, changes):
+        if self.db is None:
+            self.connect()
+        name = model.tableize()
+        doc_id = getattr(model, "id", None)
+        if not changes:
+            return {"status": "noop", "collection": name, "id": doc_id}
+        self.db[name].update_one({"id": doc_id}, {"$set": changes})
+        return {"status": "updated", "collection": name, "id": doc_id}
+
+    def schema_create(self, blueprint):
+        if self.db is None:
+            self.connect()
+        properties = {}
+        required = []
+        for column in blueprint.columns:
+            if column.type == "string" or column.type == "text":
+                bson_type = "string"
+            elif column.type == "integer":
+                bson_type = "long"
+            elif column.type == "float":
+                bson_type = "double"
+            elif column.type == "boolean":
+                bson_type = "bool"
+            elif column.type == "datetime":
+                bson_type = "date"
+            else:
+                raise ValueError(f"Unsupported column type: {column.type}")
+            properties[column.name] = {"bsonType": bson_type}
+            if not column.is_nullable and not column.is_primary:
+                required.append(column.name)
+        validator = {"$jsonSchema": {"bsonType": "object", "properties": properties}}
+        if required:
+            validator["$jsonSchema"]["required"] = required
+        if blueprint.name in self.db.list_collection_names():
+            return {"status": "exists", "collection": blueprint.name}
+        self.db.create_collection(blueprint.name, validator=validator)
+        for column in blueprint.columns:
+            if column.is_unique or column.is_primary:
+                self.db[blueprint.name].create_index(column.name, unique=True)
+            elif column.is_index:
+                self.db[blueprint.name].create_index(column.name)
+        return {"status": "created", "collection": blueprint.name}
+
+    def schema_drop(self, name):
+        if self.db is None:
+            self.connect()
+        self.db.drop_collection(name)
+        return {"status": "dropped", "collection": name}
+
+    def migrations_get(self):
+        if self.db is None:
+            self.connect()
+        return [doc["name"] for doc in self.db["_migrations"].find().sort([("batch", 1), ("name", 1)])]
+
+    def migrations_put(self, name, batch):
+        if self.db is None:
+            self.connect()
+        self.db["_migrations"].update_one({"name": name}, {"$set": {"name": name, "batch": batch}}, upsert=True)
+
+    def migrations_delete(self, name):
+        if self.db is None:
+            self.connect()
+        self.db["_migrations"].delete_one({"name": name})
+
+    def migrations_max_batch(self):
+        if self.db is None:
+            self.connect()
+        doc = self.db["_migrations"].find_one(sort=[("batch", -1)])
+        if doc is None:
+            return 0
+        return int(doc["batch"])
+
+    def migrations_batch_for(self, name):
+        if self.db is None:
+            self.connect()
+        doc = self.db["_migrations"].find_one({"name": name})
+        if doc is None:
+            return None
+        return int(doc["batch"])

future/databases/MySQL.py

@@ -0,0 +1,215 @@
+from future.databases.Database import Database
+from sqlalchemy import create_engine, text
+
+
+class MySQL(Database):
+    def __init__(self, host: str, port: int, username: str, password: str, database: str):
+        super().__init__(host, port, username, password, database)
+        self.client = None
+
+    def connect(self):
+        if self.database:
+            server = create_engine(f"mysql+pymysql://{self.username}:{self.password}@{self.host}:{self.port}/")
+            with server.begin() as connection:
+                connection.execute(text(f"CREATE DATABASE IF NOT EXISTS `{self.database}`"))
+            server.dispose()
+        url = f"mysql+pymysql://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
+        self.client = create_engine(url)
+        return self.client
+
+    def disconnect(self):
+        if self.client is not None:
+            self.client.dispose()
+            self.client = None
+
+    def save(self, model):
+        if self.client is None:
+            self.connect()
+        table = model.tableize()
+        data = model.to_dict()
+        col_sql = ", ".join(f"`{column}`" for column in data.keys())
+        val_sql = ", ".join(f":{column}" for column in data.keys())
+        upd_sql = ", ".join(f"`{column}`=VALUES(`{column}`)" for column in data.keys() if column != "id")
+        if not upd_sql:
+            upd_sql = "`id`=`id`"
+        insert_sql = text(f"INSERT INTO `{table}` ({col_sql}) VALUES ({val_sql}) ON DUPLICATE KEY UPDATE {upd_sql}")
+        with self.client.begin() as connection:
+            connection.execute(insert_sql, data)
+        return {"status": "saved", "table": table, "id": data.get("id")}
+
+    def find(self, model, id):
+        if self.client is None:
+            self.connect()
+        table = model.tableize()
+        sql = text(f"SELECT * FROM `{table}` WHERE `id` = :id LIMIT 1")
+        with self.client.connect() as connection:
+            row = connection.execute(sql, {"id": id}).mappings().first()
+        if row is None:
+            return None
+        return model.__class__(**dict(row))
+
+    def all(self, model):
+        if self.client is None:
+            self.connect()
+        table = model.tableize()
+        sql = text(f"SELECT * FROM `{table}`")
+        with self.client.connect() as connection:
+            rows = connection.execute(sql).mappings().all()
+        return [model.__class__(**dict(row)) for row in rows]
+
+    def get(self, model, wheres, limit=None, orders=None):
+        if self.client is None:
+            self.connect()
+        table = model.tableize()
+        clauses = []
+        params = {}
+        for index, (column, operator, value) in enumerate(wheres):
+            if operator == "in":
+                values = list(value)
+                if not values:
+                    return []
+                keys = []
+                for item_index, item in enumerate(values):
+                    key = f"v{index}_{item_index}"
+                    keys.append(f":{key}")
+                    params[key] = item
+                clauses.append(f"`{column}` IN ({', '.join(keys)})")
+                continue
+            if operator == "like":
+                key = f"v{index}"
+                clauses.append(f"`{column}` LIKE :{key}")
+                params[key] = value
+                continue
+            if operator not in ("=", ">", ">=", "<", "<=", "!="):
+                raise ValueError(f"Unsupported operator: {operator}")
+            key = f"v{index}"
+            clauses.append(f"`{column}` {operator} :{key}")
+            params[key] = value
+        sql = f"SELECT * FROM `{table}`"
+        if clauses:
+            sql += f" WHERE {' AND '.join(clauses)}"
+        if orders:
+            sql += " ORDER BY " + ", ".join(f"`{column}` {direction}" for column, direction in orders)
+        if limit is not None:
+            sql += f" LIMIT {int(limit)}"
+        with self.client.connect() as connection:
+            rows = connection.execute(text(sql), params).mappings().all()
+        return [model.__class__(**dict(row)) for row in rows]
+
+    def delete(self, model):
+        if self.client is None:
+            self.connect()
+        table = model.tableize()
+        sql = text(f"DELETE FROM `{table}` WHERE `id` = :id")
+        with self.client.begin() as connection:
+            connection.execute(sql, {"id": getattr(model, "id", None)})
+        return {"status": "deleted", "table": table, "id": getattr(model, "id", None)}
+
+    def update(self, model, changes):
+        if self.client is None:
+            self.connect()
+        table = model.tableize()
+        if not changes:
+            return {"status": "noop", "table": table}
+        set_sql = ", ".join(f"`{column}`=:{column}" for column in changes.keys())
+        params = dict(changes)
+        params["id"] = getattr(model, "id", None)
+        sql = text(f"UPDATE `{table}` SET {set_sql} WHERE `id` = :id")
+        with self.client.begin() as connection:
+            connection.execute(sql, params)
+        return {"status": "updated", "table": table, "id": params["id"]}
+
+    def schema_create(self, blueprint):
+        if self.client is None:
+            self.connect()
+        definitions = []
+        uniques = []
+        indexes = []
+        for column in blueprint.columns:
+            if column.type == "string":
+                sql_type = f"VARCHAR({column.length or 255})"
+            elif column.type == "text":
+                sql_type = "TEXT"
+            elif column.type == "integer":
+                sql_type = "BIGINT"
+            elif column.type == "float":
+                sql_type = "DOUBLE"
+            elif column.type == "boolean":
+                sql_type = "TINYINT(1)"
+            elif column.type == "datetime":
+                sql_type = "DATETIME"
+            else:
+                raise ValueError(f"Unsupported column type: {column.type}")
+            null_sql = "NULL" if column.is_nullable else "NOT NULL"
+            default_sql = ""
+            if column.default_value is not None:
+                if isinstance(column.default_value, str):
+                    default_sql = f" DEFAULT '{column.default_value}'"
+                else:
+                    default_sql = f" DEFAULT {column.default_value}"
+            primary_sql = " PRIMARY KEY" if column.is_primary else ""
+            definitions.append(f"`{column.name}` {sql_type} {null_sql}{default_sql}{primary_sql}")
+            if column.is_unique and not column.is_primary:
+                uniques.append(f"UNIQUE KEY `unique_{column.name}` (`{column.name}`)")
+            if column.is_index and not column.is_primary and not column.is_unique:
+                indexes.append(f"KEY `index_{column.name}` (`{column.name}`)")
+        parts = definitions + uniques + indexes
+        create_sql = text(f"CREATE TABLE IF NOT EXISTS `{blueprint.name}` ({', '.join(parts)})")
+        with self.client.begin() as connection:
+            connection.execute(create_sql)
+        return {"status": "created", "table": blueprint.name}
+
+    def schema_drop(self, name):
+        if self.client is None:
+            self.connect()
+        with self.client.begin() as connection:
+            connection.execute(text(f"DROP TABLE IF EXISTS `{name}`"))
+        return {"status": "dropped", "table": name}
+
+    def table_exists(self, name):
+        if self.client is None:
+            self.connect()
+        sql = text("SELECT 1 FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = :name LIMIT 1")
+        with self.client.connect() as connection:
+            return connection.execute(sql, {"name": name}).first() is not None
+
+    def _ensure_migrations_table(self):
+        if self.client is None:
+            self.connect()
+        sql = text("CREATE TABLE IF NOT EXISTS `migrations` (`name` VARCHAR(255) PRIMARY KEY, `batch` INT NOT NULL)")
+        with self.client.begin() as connection:
+            connection.execute(sql)
+
+    def migrations_get(self):
+        self._ensure_migrations_table()
+        with self.client.connect() as connection:
+            rows = connection.execute(text("SELECT `name` FROM `migrations` ORDER BY `batch`, `name`")).mappings().all()
+        return [row["name"] for row in rows]
+
+    def migrations_put(self, name, batch):
+        self._ensure_migrations_table()
+        sql = text("INSERT INTO `migrations` (`name`, `batch`) VALUES (:name, :batch)")
+        with self.client.begin() as connection:
+            connection.execute(sql, {"name": name, "batch": batch})
+
+    def migrations_delete(self, name):
+        self._ensure_migrations_table()
+        sql = text("DELETE FROM `migrations` WHERE `name` = :name")
+        with self.client.begin() as connection:
+            connection.execute(sql, {"name": name})
+
+    def migrations_max_batch(self):
+        self._ensure_migrations_table()
+        with self.client.connect() as connection:
+            row = connection.execute(text("SELECT MAX(`batch`) AS `batch` FROM `migrations`")).mappings().first()
+        if row is None or row["batch"] is None:
+            return 0
+        return int(row["batch"])
+
+    def migrations_batch_for(self, name):
+        self._ensure_migrations_table()
+        with self.client.connect() as connection:
+            row = connection.execute(text("SELECT `batch` FROM `migrations` WHERE `name` = :name"), {"name": name}).mappings().first()
+        if row is None:
+            return None
+        return int(row["batch"])