future-framework 1.1.0__py3-none-any.whl

future/migrations/MigrationGenerator.py

@@ -0,0 +1,137 @@
+# Generate Schema migrations from Model annotations.
+
+
+import importlib.util
+import inflection
+from datetime import datetime
+from pathlib import Path
+from types import UnionType
+from typing import get_args, get_origin, Union
+
+from future.models import Model
+
+
+class MigrationGenerator:
+    def __init__(self, models_path="app/models", migrations_path="database/migrations"):
+        self.models_path = models_path
+        self.migrations_path = migrations_path
+
+    def find_model(self, name):
+        for model in self.discover_models():
+            if model.__name__ == name:
+                return model
+        raise ValueError(f"Model not found: {name}")
+
+    def discover_models(self):
+        directory = Path(self.models_path)
+        if not directory.exists():
+            raise FileNotFoundError(f"Models path not found: {self.models_path}")
+        models = []
+        seen = set()
+        for file_path in sorted(directory.glob("*.py")):
+            if file_path.name.startswith("_"):
+                continue
+            module_name = f"app_model_{file_path.stem}"
+            spec = importlib.util.spec_from_file_location(module_name, str(file_path))
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            for value in module.__dict__.values():
+                if not isinstance(value, type) or not issubclass(value, Model) or value is Model:
+                    continue
+                if value.__name__ in seen:
+                    continue
+                if not getattr(value, "__annotations__", None):
+                    continue
+                seen.add(value.__name__)
+                models.append(value)
+        return models
+
+    def table_name(self, model):
+        return model.__table__ or inflection.tableize(model.__name__)
+
+    def column_line(self, field, annotation):
+        nullable = False
+        origin = get_origin(annotation)
+        if origin is Union or origin is UnionType:
+            args = get_args(annotation)
+            nullable = type(None) in args
+            non_null = [arg for arg in args if arg is not type(None)]
+            annotation = non_null[0] if non_null else str
+        if field == "id":
+            return "table.id()"
+        type_name = getattr(annotation, "__name__", str(annotation))
+        if annotation is datetime or type_name == "datetime":
+            line = f'table.datetime("{field}")'
+        elif annotation is int or type_name == "int":
+            line = f'table.integer("{field}")'
+        elif annotation is float or type_name == "float":
+            line = f'table.float("{field}")'
+        elif annotation is bool or type_name == "bool":
+            line = f'table.boolean("{field}")'
+        elif field in ("description", "text", "body", "content") or field.endswith("_original") or field.endswith("_translated"):
+            line = f'table.text("{field}")'
+        else:
+            line = f'table.string("{field}")'
+        if nullable:
+            line += ".nullable()"
+        return line
+
+    def blueprint_lines(self, model):
+        annotations = dict(getattr(model, "__annotations__", {}))
+        lines = []
+        if "created_at" in annotations and "updated_at" in annotations:
+            annotations.pop("created_at")
+            annotations.pop("updated_at")
+            use_timestamps = True
+        else:
+            use_timestamps = False
+        for field, annotation in annotations.items():
+            lines.append(f"            {self.column_line(field, annotation)}")
+        if use_timestamps:
+            lines.append("            table.timestamps()")
+        return lines
+
+    def render(self, model):
+        table = self.table_name(model)
+        class_name = f"Create{inflection.camelize(table)}"
+        connection = getattr(model, "__connection__", "default")
+        columns = "\n".join(self.blueprint_lines(model))
+        return (
+            "from future.migrations.Migration import Migration\n"
+            "from future.migrations.Schema import Schema\n"
+            "\n"
+            "\n"
+            f"class {class_name}(Migration):\n"
+            f'    __connection__ = "{connection}"\n'
+            "\n"
+            "    def up(self):\n"
+            f'        with Schema.create("{table}") as table:\n'
+            f"{columns}\n"
+            "\n"
+            "    def down(self):\n"
+            f'        Schema.drop("{table}")\n'
+        )
+
+    def make(self, model_name=None):
+        if model_name is None:
+            return self.make_all()
+        model = self.find_model(model_name)
+        return [self.write(model)]
+
+    def make_all(self):
+        paths = []
+        for index, model in enumerate(self.discover_models()):
+            paths.append(self.write(model, stamp_offset=index))
+        return paths
+
+    def write(self, model, stamp_offset=0):
+        table = self.table_name(model)
+        stamp = datetime.now().strftime("%Y_%m_%d_%H%M%S")
+        if stamp_offset:
+            stamp = f"{stamp}_{stamp_offset:02d}"
+        file_name = f"{stamp}_create_{table}.py"
+        directory = Path(self.migrations_path)
+        directory.mkdir(parents=True, exist_ok=True)
+        path = directory / file_name
+        path.write_text(self.render(model))
+        return str(path)

future/migrations/Migrator.py

@@ -0,0 +1,72 @@
+# Discovers and runs migration files against Connections.
+
+
+import importlib.util
+from pathlib import Path
+
+from future.databases.Connections import Connections
+from .Migration import Migration
+from .Schema import Schema
+
+
+class Migrator:
+    def __init__(self, path):
+        self.path = path
+
+    def discover(self):
+        migrations = []
+        directory = Path(self.path)
+        if not directory.exists():
+            return migrations
+        for file_path in sorted(directory.glob("*.py")):
+            if file_path.name.startswith("_"):
+                continue
+            module_name = f"migration_{file_path.stem}"
+            spec = importlib.util.spec_from_file_location(module_name, str(file_path))
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            for value in module.__dict__.values():
+                if isinstance(value, type) and issubclass(value, Migration) and value is not Migration:
+                    migrations.append((file_path.stem, value))
+                    break
+        return migrations
+
+    def run(self):
+        applied_by_connection = {}
+        batch_by_connection = {}
+        ran = []
+        for name, migration_class in self.discover():
+            migration = migration_class()
+            connection_name = getattr(migration, "__connection__", "default")
+            connection = Connections().get_connection(connection_name)
+            if connection_name not in applied_by_connection:
+                applied_by_connection[connection_name] = set(connection.migrations_get())
+                batch_by_connection[connection_name] = connection.migrations_max_batch() + 1
+            if name in applied_by_connection[connection_name]:
+                continue
+            Schema.connection(connection_name)
+            migration.up()
+            connection.migrations_put(name, batch_by_connection[connection_name])
+            ran.append(name)
+        return ran
+
+    def rollback(self):
+        rolled = []
+        by_connection = {}
+        for name, migration_class in self.discover():
+            migration = migration_class()
+            connection_name = getattr(migration, "__connection__", "default")
+            by_connection.setdefault(connection_name, []).append((name, migration))
+        for connection_name, items in by_connection.items():
+            connection = Connections().get_connection(connection_name)
+            max_batch = connection.migrations_max_batch()
+            if max_batch == 0:
+                continue
+            for name, migration in reversed(items):
+                if connection.migrations_batch_for(name) != max_batch:
+                    continue
+                Schema.connection(connection_name)
+                migration.down()
+                connection.migrations_delete(name)
+                rolled.append(name)
+        return rolled

future/migrations/Schema.py

@@ -0,0 +1,21 @@
+# Orator/Masonite-style schema facade. Resolves connections via Connections.
+
+
+from .Blueprint import Blueprint
+from future.databases.Connections import Connections
+
+
+class SchemaMeta(type):
+    def connection(cls, name):
+        cls._connection_name = name
+        return cls
+
+    def create(cls, name):
+        return Blueprint(name, cls._connection_name, action="create")
+
+    def drop(cls, name):
+        Connections().get_connection(cls._connection_name).schema_drop(name)
+
+
+class Schema(metaclass=SchemaMeta):
+    _connection_name = "default"

future/models/__init__.py

@@ -0,0 +1 @@
+from future.models.model import Model, Query

future/models/model.py

@@ -0,0 +1,224 @@
+from future.databases.Connections import Connections
+from future.logger import log
+import inflection
+import json
+
+# Active-record base model (Masonite-style).
+# Trade.find("1"), Trade.where("user_id", "123").get(), trade.save()
+
+
+class ModelMeta(type):
+    def __getattr__(self, attribute, *args, **kwargs):
+        instantiated = self()
+        return getattr(instantiated, attribute)
+
+
+class Query:
+    def __init__(self, model):
+        self.model = model
+        self.wheres = []
+        self.orders = []
+        self.limit_value = None
+
+    def where(self, column, *args):
+        if len(args) == 1:
+            operator, value = "=", args[0]
+        else:
+            operator, value = args[0], args[1]
+        self.wheres.append((column, operator, value))
+        return self
+
+    def order_by(self, column, direction="asc"):
+        self.orders.append((column, direction))
+        return self
+
+    def limit(self, value):
+        self.limit_value = value
+        return self
+
+    def get(self):
+        return self.model.connection().get(self.model, self.wheres, limit=self.limit_value, orders=self.orders)
+
+    def first(self):
+        results = self.model.connection().get(self.model, self.wheres, limit=1, orders=self.orders)
+        return results[0] if results else None
+
+    def __repr__(self):
+        return "<Query; call .get() or .first() to execute>"
+
+    def __len__(self):
+        raise TypeError("Query has no len(); call .get() or .first() first")
+
+    def __iter__(self):
+        raise TypeError("Query is not iterable; call .get() or .first() first")
+
+
+class Model(metaclass=ModelMeta):
+    __table__ = None
+    __connection__ = "default"
+
+    def __init__(self, **attributes):
+        for key, value in attributes.items():
+            setattr(self, key, value)
+
+    # Why do we use __getattr__ for find and all, but not for save, delete, update?
+    # ModelMeta.__getattr__ turns Trade.find into “make an empty instance, then get find from it.” The instance __getattr__ then returns the callable. That lets class-level calls work without @classmethod (which this codebase forbids).
+    def __getattr__(self, attribute):
+        if attribute == "find":
+            def find(id):
+                return self.connection().find(self, id)
+            return find
+        if attribute == "all":
+            def all():
+                return self.connection().all(self)
+            return all
+        if attribute == "where":
+            def where(*args):
+                return Query(self).where(*args)
+            return where
+        if attribute == "order_by":
+            def order_by(*args):
+                return Query(self).order_by(*args)
+            return order_by
+        if attribute == "transaction":
+            def transaction():
+                return self.connection().transaction()
+            return transaction
+        if attribute == "eager_load":
+            def eager_load(models, name, related, foreign_key=None, kind="belongs_to"):
+                if not models:
+                    return models
+                if kind == "belongs_to":
+                    key = foreign_key or (inflection.underscore(related.__name__) + "_id")
+                    ids = list({getattr(model, key, None) for model in models if getattr(model, key, None) is not None})
+                    related_map = {}
+                    if ids:
+                        for row in related.where("id", "in", ids).get():
+                            related_map[getattr(row, "id")] = row
+                    for model in models:
+                        setattr(model, name, related_map.get(getattr(model, key, None)))
+                    return models
+                key = foreign_key or (inflection.underscore(models[0].__class__.__name__) + "_id")
+                parent_ids = [getattr(model, "id") for model in models if getattr(model, "id", None) is not None]
+                children = related.where(key, "in", parent_ids).get() if parent_ids else []
+                grouped = {}
+                for child in children:
+                    grouped.setdefault(getattr(child, key), []).append(child)
+                for model in models:
+                    setattr(model, name, grouped.get(getattr(model, "id"), []))
+                return models
+            return eager_load
+        raise AttributeError(attribute)
+
+    def tableize(self):
+        return self.__table__ or inflection.tableize(self.__class__.__name__)
+
+    def connection(self):
+        name = self.__connection__
+        if name == "default":
+            name = Connections._default
+        connection = Connections().get_connection(self.__connection__)
+        log.debug("%s using database connection %s (%s)", self.__class__.__name__, name, type(connection).__name__)
+        table_exists = getattr(connection, "table_exists", None)
+        if table_exists is not None:
+            table = self.tableize()
+            if not table_exists(table):
+                message = f'Table "{table}" does not exist on connection {name}. Run: future migrate'
+                log.warning(message)
+                raise RuntimeError(message)
+        return connection
+
+    def to_dict(self):
+        return dict(self.__dict__)
+
+    def to_json(self):
+        return json.dumps(self.to_dict())
+
+    def openapi_schema(self):
+        from datetime import date, datetime
+        from typing import get_args, get_origin, Union
+        import types
+        properties = {}
+        required = []
+        annotations = {}
+        for cls in reversed(type(self).__mro__):
+            if cls is object:
+                continue
+            annotations.update(getattr(cls, "__annotations__", {}))
+        for name, annotation in annotations.items():
+            if name.startswith("_"):
+                continue
+            optional = False
+            current = annotation
+            origin = get_origin(current)
+            args = get_args(current)
+            if origin is Union or isinstance(current, types.UnionType) or origin is types.UnionType:
+                non_none = [item for item in args if item is not type(None)]
+                if type(None) in args and len(non_none) == 1:
+                    optional = True
+                    current = non_none[0]
+                    origin = get_origin(current)
+                    args = get_args(current)
+            if origin is list:
+                item = args[0] if args else str
+                if isinstance(item, type) and issubclass(item, Model):
+                    item_schema = {"$ref": f"#/components/schemas/{item.__name__}"}
+                elif item is int:
+                    item_schema = {"type": "integer"}
+                elif item is float:
+                    item_schema = {"type": "number"}
+                elif item is bool:
+                    item_schema = {"type": "boolean"}
+                elif item in (datetime, date):
+                    item_schema = {"type": "string", "format": "date-time" if item is datetime else "date"}
+                else:
+                    item_schema = {"type": "string"}
+                properties[name] = {"type": "array", "items": item_schema}
+            elif isinstance(current, type) and issubclass(current, Model):
+                properties[name] = {"$ref": f"#/components/schemas/{current.__name__}"}
+            elif current is int:
+                properties[name] = {"type": "integer"}
+            elif current is float:
+                properties[name] = {"type": "number"}
+            elif current is bool:
+                properties[name] = {"type": "boolean"}
+            elif current is datetime:
+                properties[name] = {"type": "string", "format": "date-time"}
+            elif current is date:
+                properties[name] = {"type": "string", "format": "date"}
+            elif current is dict:
+                properties[name] = {"type": "object"}
+            else:
+                properties[name] = {"type": "string"}
+            if not optional:
+                required.append(name)
+        schema = {"type": "object", "properties": properties}
+        if required:
+            schema["required"] = required
+        return schema
+
+    def __repr__(self):
+        return str(self.to_dict())
+
+    def save(self):
+        return self.connection().save(self)
+
+    def delete(self):
+        return self.connection().delete(self)
+
+    def update(self, **changes):
+        for key, value in changes.items():
+            setattr(self, key, value)
+        self.connection().update(self, changes)
+        return self
+
+    def belongs_to(self, related, foreign_key=None):
+        key = foreign_key or (inflection.underscore(related.__name__) + "_id")
+        related_id = getattr(self, key, None)
+        if related_id is None:
+            return None
+        return related.find(related_id)
+
+    def has_many(self, related, foreign_key=None):
+        key = foreign_key or (inflection.underscore(self.__class__.__name__) + "_id")
+        return related.where(key, getattr(self, "id")).get()