future-framework 1.1.0__py3-none-any.whl

future/graphql/schema.py

@@ -0,0 +1,148 @@
+from textwrap import dedent
+
+import strawberry
+
+
+# Sample data
+db_users = [
+    {"id": "1", "name": "Alice", "email": "alice@example.com"},
+    {"id": "2", "name": "Bob", "email": "bob@example.com"},
+    {"id": "3", "name": "Charlie", "email": "charlie@example.com"},
+]
+
+db_posts = [
+    {"id": "101", "title": "GraphQL vs REST", "content": "GraphQL is amazing!", "author_id": "1"},
+    {"id": "102", "title": "Strawberry Rocks", "content": "Strawberry is great for Python!", "author_id": "2"},
+]
+
+
+# GraphQL queries
+queries = {
+    "GetEverything": dedent("""
+        query GetEverything {
+            users {
+                id
+                name
+                email
+            }
+            posts {
+                id
+                title
+                content
+                author {
+                    id
+                    name
+                    email
+                }
+            }
+        }
+    """),  # type: ignore[reportGeneralTypeIssues]
+    "GetAllUsers": dedent("""
+        query GetAllUsers {
+            users {
+                id
+                name
+                email
+            }
+        }
+    """),  # type: ignore[reportGeneralTypeIssues]
+    "GetAllPosts": dedent("""
+        query GetAllPosts {
+            posts {
+                id
+                title
+                content
+                author {
+                    id
+                    name
+                    email
+                }
+            }
+        }
+    """),  # type: ignore[reportGeneralTypeIssues]
+    "GetPostsWithAuthors": dedent("""
+        query GetPostsWithAuthors {
+            posts {
+                id
+                title
+                content
+                author {
+                    name
+                    email
+                }
+            }
+        }
+    """),  # type: ignore[reportGeneralTypeIssues]
+    "GetTitlesAndAuthors": dedent("""
+        query GetTitlesAndAuthors {
+            posts {
+                title
+                author {
+                    name
+                }
+            }
+        }
+    """),  # type: ignore[reportGeneralTypeIssues]
+    "GetEmails": dedent("""
+        query GetEmails {
+            users {
+                email
+            }
+        }
+    """),  # type: ignore[reportGeneralTypeIssues]
+}
+
+
+# Define GraphQL types
+class User:
+    id: str
+    name: str
+    email: str
+
+    def __init__(self, id: str, name: str, email: str):
+        self.id = id
+        self.name = name
+        self.email = email
+
+
+class Post:
+    id: str
+    title: str
+    content: str
+    author: "User"
+
+    def __init__(self, id: str, title: str, content: str, author: "User"):
+        self.id = id
+        self.title = title
+        self.content = content
+        self.author = author
+
+
+# Create Strawberry types
+UserType = strawberry.type(User)
+PostType = strawberry.type(Post)
+
+
+# Define resolvers
+async def resolve_users() -> list[UserType]:  # type: ignore[misc,valid-type]
+    return [UserType(id=u["id"], name=u["name"], email=u["email"]) for u in db_users]
+
+
+async def resolve_posts() -> list[PostType]:  # type: ignore[misc,valid-type]
+    posts = []
+    for p in db_posts:
+        author = next(u for u in db_users if u["id"] == p["author_id"])
+        user = UserType(id=author["id"], name=author["name"], email=author["email"])
+        post = PostType(id=p["id"], title=p["title"], content=p["content"], author=user)
+        posts.append(post)
+    return posts
+
+
+# Define Query type
+class Query:
+    users = strawberry.field(resolver=resolve_users)
+    posts = strawberry.field(resolver=resolve_posts)
+
+
+# NB:!!!!  schema cannot be instantiated in the controller. it breaks then.
+schema = strawberry.Schema(query=strawberry.type(Query))

future/lifespan.py

@@ -0,0 +1,70 @@
+import asyncio
+
+from typing import Any
+
+from future.logger import log
+from future.tasks.scheduler import CronScheduler, Task
+
+
+class Lifespan:
+    """ASGI application lifespan: startup / shutdown, with optional cron tasks."""
+
+    def __init__(self, startup_tasks: list[Task] | None = None, shutdown_tasks: list[Task] | None = None, cron_tasks: list[Task] | None = None) -> None:
+        self.app = None
+        self.startup_tasks = startup_tasks or []
+        self.shutdown_tasks = shutdown_tasks or []
+        self.cron_tasks = cron_tasks or []
+        self.scheduler = CronScheduler()
+        self.db = None
+        self.s3_client = None
+        self.redis_client = None
+        self.settings = None
+
+    async def __aenter__(self) -> dict[str, Any]:
+        """Application startup."""
+        async with asyncio.timeout(30):
+            log.info("Starting application...")
+            await self._run_startup_tasks()
+            await self.scheduler.start()
+            await self._register_cron_jobs()
+            log.info("Application startup complete")
+            return {
+                "db": self.db,
+                "s3_client": self.s3_client,
+                "redis_client": self.redis_client,
+                "settings": self.settings,
+            }
+
+    async def __aexit__(self, exc_type: type | None, exc_value: Exception | None, tb: Any) -> bool | None:
+        """Application shutdown."""
+        async with asyncio.timeout(30):
+            log.info("Shutting down application...")
+            await self.scheduler.stop()
+            await self._run_shutdown_tasks()
+            log.info("Shutdown complete")
+        return None
+
+    async def _run_startup_tasks(self) -> None:
+        for task in self.startup_tasks:
+            if task.func is not None:
+                if asyncio.iscoroutinefunction(task.func):
+                    await task.func(*task.args, **task.kwargs)
+                else:
+                    loop = asyncio.get_event_loop()
+                    await loop.run_in_executor(None, task.func, *task.args, **task.kwargs)
+
+    async def _run_shutdown_tasks(self) -> None:
+        for task in self.shutdown_tasks:
+            if task.func is not None:
+                if asyncio.iscoroutinefunction(task.func):
+                    await task.func(*task.args, **task.kwargs)
+                else:
+                    loop = asyncio.get_event_loop()
+                    await loop.run_in_executor(None, task.func, *task.args, **task.kwargs)
+
+    async def _register_cron_jobs(self) -> None:
+        """Register cron jobs with the scheduler."""
+        for task in self.cron_tasks:
+            self.scheduler.add_task(task)
+
+        log.info(f"Registered {len(self.scheduler.tasks)} cron jobs")

future/logger.py

@@ -0,0 +1,53 @@
+import atexit
+import logging
+import logging.config
+import logging.handlers
+
+from future.settings import LOGGING_CONFIG
+
+
+# ANSI color codes
+class ColoredFormatter(logging.Formatter):
+    """Custom formatter with colors like uvicorn"""
+
+    COLORS = {
+        "DEBUG": "\033[36m",  # Cyan
+        "INFO": "\033[32m",  # Green
+        "WARNING": "\033[33m",  # Yellow
+        "ERROR": "\033[31m",  # Red
+        "CRITICAL": "\033[35m",  # Magenta
+    }
+    RESET = "\033[0m"
+
+    def format(self, record: logging.LogRecord) -> str:
+        # Add color to levelname
+        levelname = record.levelname
+        if levelname in self.COLORS:
+            # Calculate padding based on original levelname length BEFORE adding colors
+            padding = " " * (9 - len(levelname))  # 9 is max level length (CRITICAL) + 1
+            colored_levelname = f"{self.COLORS[levelname]}{levelname}{self.RESET}"
+            return f"{colored_levelname}:{padding}{record.getMessage()}"
+        return super().format(record)
+
+
+# Configure logging using settings
+logging.config.dictConfig(LOGGING_CONFIG)
+
+log = logging.getLogger("future")
+formatter = ColoredFormatter("%(message)s")
+
+# QueueHandler itself does not format; the listener's stdout handler does.
+# Handler level NOTSET so Future's log.setLevel(APP_DEBUG) alone controls filtering.
+queue_handler = logging.getHandlerByName("queue_handler")
+if queue_handler is not None and isinstance(queue_handler, logging.handlers.QueueHandler):
+    listener = getattr(queue_handler, "listener", None)
+    if listener is not None:
+        for handler in listener.handlers:
+            handler.setFormatter(formatter)
+            handler.setLevel(logging.NOTSET)
+        listener.start()
+        atexit.register(listener.stop)
+else:
+    for handler in log.handlers:
+        handler.setFormatter(formatter)
+        handler.setLevel(logging.NOTSET)

future/middleware/Middleware.py

@@ -0,0 +1,201 @@
+from typing import Optional
+
+from future.request import Request
+from future.response import Response
+
+
+# README - a note on the use of middlewares:
+# if a middleware does not RETURN or hit any EXCEPTIONS, it means it passes (all checks ok)
+# if it however RETURNS or hits an EXCEPTION, the middleware check will deny further processing of the request.
+
+
+class Middleware:
+    name: Optional[str] = None
+    apply: bool = True
+    priority: int = 0
+
+    def __init__(self, request: Request, response: Response) -> None:
+        self.request = request
+        self.response = response
+
+    async def before(self) -> Optional[Response]:
+        return None
+
+    async def after(self) -> Optional[Response]:
+        return None
+
+
+class TestMiddlewareRequest(Middleware):
+    name = "testRequestMiddleware"
+
+    async def before(self) -> Optional[Response]:
+        if self.request.headers.get("x-interrupt") == "1":
+            return self.response.text("Request intercepted!")
+        return None
+
+
+class TestMiddlewareResponse(Middleware):
+    name = "testResponseMiddleware"
+
+    async def after(self) -> Optional[Response]:
+        if self.request.headers.get("x-interrupt-response") == "1":
+            return self.response.text("Response intercepted!")
+        return None
+
+
+class ResponseCodeConfuser(Middleware):
+    name = "response code confuser"
+
+    async def after(self) -> Optional[Response]:
+        import random
+
+        response_codes = [
+            100, 101, 102, 103, 200, 201, 202, 203, 204, 205, 206, 207, 208, 226,
+            300, 301, 302, 303, 304, 305, 306, 307, 308,
+            400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
+            415, 416, 417, 418, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451,
+            500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511,
+        ]
+        if "curl" in self.request.headers.get("user-agent", ""):
+            return self.response.empty(status=random.choice(response_codes))
+        return None
+
+
+class RateLimitMiddleware(Middleware):
+    name = "RateLimitMiddleware"
+    limit = 60
+    window_seconds = 60
+    _hits: dict[str, list[float]] = {}
+
+    async def before(self) -> Optional[Response]:
+        import time
+        client = (self.request.scope.get("client") or ("unknown", 0))[0]
+        now = time.time()
+        bucket = self._hits.setdefault(client, [])
+        cutoff = now - self.window_seconds
+        self._hits[client] = [stamp for stamp in bucket if stamp >= cutoff]
+        if len(self._hits[client]) >= self.limit:
+            return self.response.json({"error": "Too Many Requests", "status_code": 429}, status=429)
+        self._hits[client].append(now)
+        return None
+
+
+class CSRFMiddleware(Middleware):
+    name = "CSRFMiddleware"
+    cookie_name = "csrf_token"
+    header_name = "x-csrf-token"
+    safe_methods = {"GET", "HEAD", "OPTIONS"}
+
+    async def before(self) -> Optional[Response]:
+        import secrets
+        token = self.request.cookies.get(self.cookie_name)
+        if not token:
+            token = secrets.token_urlsafe(32)
+            self.request.context["csrf_token_new"] = token
+        self.request.context["csrf_token"] = token
+        if self.request.method in self.safe_methods:
+            return None
+        provided = self.request.headers.get(self.header_name) or self.request.headers.get("x-xsrf-token")
+        if not provided:
+            form = await self.request.form()
+            value = form.get("csrf_token")
+            provided = value if isinstance(value, str) else None
+        if not provided or not secrets.compare_digest(str(provided), str(token)):
+            return self.response.json({"error": "CSRF token missing or invalid", "status_code": 403}, status=403)
+        return None
+
+    async def after(self) -> Optional[Response]:
+        token = self.request.context.get("csrf_token_new") or self.request.context.get("csrf_token")
+        if token:
+            self.response.set_cookie(self.cookie_name, token, httponly=False, samesite="Strict", secure=(self.request.scheme == "https"))
+        return None
+
+
+class WebServerConfuser(Middleware):
+    pass
+
+
+class BruteforcePrevention(Middleware):
+    pass
+
+
+class SQLiConfuser(Middleware):
+    pass
+
+
+class HTAccessConfuser(Middleware):
+    pass
+
+
+class HeaderConfuser(Middleware):
+    pass
+
+
+class GZipMiddleware(Middleware):
+    name = "GZipMiddleware"
+
+    async def after(self) -> Optional[Response]:
+        accept = self.request.headers.get("accept-encoding", "")
+        if "gzip" not in accept.lower():
+            return None
+        if not self.response.body:
+            return None
+        for key, _value in self.response.headers:
+            if key.lower() == b"content-encoding":
+                return None
+        import gzip
+        compressed = gzip.compress(self.response.body)
+        self.response.body = compressed
+        self.response.headers = [pair for pair in self.response.headers if pair[0].lower() != b"content-length"]
+        self.response.headers.append([b"content-encoding", b"gzip"])
+        self.response.headers.append([b"content-length", str(len(compressed)).encode("utf-8")])
+        return None
+
+
+class CORSMiddleware(Middleware):
+    name = "CORSMiddleware"
+    allow_origin = "*"
+    allow_methods = "GET, POST, PUT, PATCH, DELETE, OPTIONS"
+    allow_headers = "origin, content-type, accept, authorization, x-xsrf-token, x-request-id"
+    allow_credentials = "false"
+
+    def _apply_headers(self) -> None:
+        self.response.headers.append([b"access-control-allow-origin", self.allow_origin.encode("utf-8")])
+        self.response.headers.append([b"access-control-allow-methods", self.allow_methods.encode("utf-8")])
+        self.response.headers.append([b"access-control-allow-headers", self.allow_headers.encode("utf-8")])
+        if self.allow_origin != "*":
+            self.response.headers.append([b"access-control-allow-credentials", self.allow_credentials.encode("utf-8")])
+
+    async def before(self) -> Optional[Response]:
+        if self.request.method == "OPTIONS":
+            self.response.empty(status=204)
+            self._apply_headers()
+            return self.response
+        return None
+
+    async def after(self) -> Optional[Response]:
+        self._apply_headers()
+        return None
+
+
+class ScopeValidationMiddleware(Middleware):
+    name = "scopeValidation"
+    priority = 10
+
+    async def before(self) -> Optional[Response]:
+        if self.request.path in ["/health", "/ping"]:
+            return None
+        route = getattr(self.request, "route", None)
+        if not route:
+            return None
+        required_scopes = getattr(route, "scopes", [])
+        if not required_scopes:
+            return None
+        user_id = self.request.context.get("user_id")
+        if not user_id:
+            return self.response.text("Unauthorized - no user ID found", status=401)
+        user_scopes = ["read:posts", "write:posts", "admin", "read:public", "read:api", "user", "debug"]
+        for required_scope in required_scopes:
+            if required_scope not in user_scopes:
+                return self.response.text("Insufficient permissions", status=403)
+        return None

future/middleware/SessionMiddleware.py

@@ -0,0 +1,77 @@
+import base64
+import hashlib
+import hmac
+import json
+
+from typing import Optional
+
+from future.middleware.Middleware import Middleware
+from future.response import Response
+from future.settings import APP_KEY
+
+SESSION_COOKIE_NAME = "session"
+SESSION_COOKIE_PATH = "/"
+SESSION_COOKIE_HTTPONLY = True
+SESSION_COOKIE_SAMESITE = "Lax"
+
+
+class SessionMiddleware(Middleware):
+    name = "session"
+
+    def _secret(self) -> str:
+        app = self.request.scope.get("app")
+        if app is not None and getattr(app, "config", None):
+            return str(app.config.get("APP_KEY") or APP_KEY)
+        return str(APP_KEY)
+
+    def _sign(self, payload: bytes) -> str:
+        digest = hmac.new(self._secret().encode("utf-8"), payload, hashlib.sha256).hexdigest()
+        return base64.urlsafe_b64encode(payload).decode("ascii") + "." + digest
+
+    def _unsign(self, raw: str) -> dict:
+        body_b64, digest = raw.rsplit(".", 1)
+        payload = base64.urlsafe_b64decode(body_b64.encode("ascii"))
+        expected = hmac.new(self._secret().encode("utf-8"), payload, hashlib.sha256).hexdigest()
+        if not hmac.compare_digest(digest, expected):
+            raise ValueError("invalid session signature")
+        data = json.loads(payload.decode("utf-8"))
+        if not isinstance(data, dict):
+            raise ValueError("invalid session payload")
+        return data
+
+    async def before(self) -> Optional[Response]:
+        raw = self.request.cookies.get(SESSION_COOKIE_NAME)
+        if not raw:
+            return None
+        try:
+            if "." in raw:
+                self.request.session = self._unsign(raw)
+            else:
+                # Legacy unsigned base64 JSON sessions
+                payload = base64.urlsafe_b64decode(raw.encode("ascii"))
+                data = json.loads(payload.decode("utf-8"))
+                self.request.session = data if isinstance(data, dict) else {}
+        except Exception:
+            self.request.session = {}
+        return None
+
+    async def after(self) -> Optional[Response]:
+        if not self.request.session:
+            self.response.delete_cookie(SESSION_COOKIE_NAME, path=SESSION_COOKIE_PATH)
+            return None
+        payload = json.dumps(
+            self.request.session,
+            default=str,
+            ensure_ascii=False,
+            separators=(",", ":"),
+        ).encode("utf-8")
+        value = self._sign(payload)
+        self.response.set_cookie(
+            SESSION_COOKIE_NAME,
+            value,
+            path=SESSION_COOKIE_PATH,
+            httponly=SESSION_COOKIE_HTTPONLY,
+            samesite=SESSION_COOKIE_SAMESITE,
+            secure=(self.request.scheme == "https"),
+        )
+        return None

future/middleware/__init__.py

@@ -0,0 +1,21 @@
+from future.middleware.Middleware import (
+    CORSMiddleware,
+    CSRFMiddleware,
+    GZipMiddleware,
+    Middleware,
+    RateLimitMiddleware,
+    ScopeValidationMiddleware,
+    TestMiddlewareRequest,
+    TestMiddlewareResponse,
+)
+from future.middleware.SessionMiddleware import (
+    SESSION_COOKIE_HTTPONLY,
+    SESSION_COOKIE_NAME,
+    SESSION_COOKIE_PATH,
+    SESSION_COOKIE_SAMESITE,
+    SessionMiddleware,
+)
+
+# Back-compat aliases during migration
+SessionRequestMiddleware = SessionMiddleware
+SessionResponseMiddleware = SessionMiddleware

future/migrations/Blueprint.py

@@ -0,0 +1,54 @@
+# Schema blueprint — collects portable columns; applied on context exit.
+
+
+from .Column import Column
+from future.databases.Connections import Connections
+
+
+class Blueprint:
+    def __init__(self, name, connection_name, action="create"):
+        self.name = name
+        self.connection_name = connection_name
+        self.action = action
+        self.columns = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        if exc_type is not None:
+            return False
+        connection = Connections().get_connection(self.connection_name)
+        if self.action == "create":
+            connection.schema_create(self)
+        return False
+
+    def _add(self, column):
+        self.columns.append(column)
+        return column
+
+    def id(self):
+        return self._add(Column("id", "string", length=255)).primary()
+
+    def string(self, name, length=255):
+        return self._add(Column(name, "string", length=length))
+
+    def text(self, name):
+        return self._add(Column(name, "text"))
+
+    def integer(self, name):
+        return self._add(Column(name, "integer"))
+
+    def float(self, name):
+        return self._add(Column(name, "float"))
+
+    def boolean(self, name):
+        return self._add(Column(name, "boolean"))
+
+    def datetime(self, name):
+        return self._add(Column(name, "datetime"))
+
+    def timestamps(self):
+        self.datetime("created_at").nullable()
+        self.datetime("updated_at").nullable()
+        return self

future/migrations/Column.py

@@ -0,0 +1,33 @@
+# Portable column definition for Schema blueprints (Orator/Masonite-style).
+
+
+class Column:
+    def __init__(self, name, type, length=None):
+        self.name = name
+        self.type = type
+        self.length = length
+        self.is_nullable = False
+        self.is_unique = False
+        self.is_primary = False
+        self.is_index = False
+        self.default_value = None
+
+    def nullable(self):
+        self.is_nullable = True
+        return self
+
+    def unique(self):
+        self.is_unique = True
+        return self
+
+    def primary(self):
+        self.is_primary = True
+        return self
+
+    def index(self):
+        self.is_index = True
+        return self
+
+    def default(self, value):
+        self.default_value = value
+        return self

future/migrations/Migration.py

@@ -0,0 +1,11 @@
+# Base class for migration files (Orator/Masonite-style).
+
+
+class Migration:
+    __connection__ = "default"
+
+    def up(self):
+        raise NotImplementedError
+
+    def down(self):
+        raise NotImplementedError