future-framework 1.1.0__py3-none-any.whl

future/response.py

@@ -0,0 +1,201 @@
+import json
+
+from collections.abc import Awaitable
+from typing import Any, Callable, Optional, Union
+
+
+class Response:
+    def __init__(self, body: Union[str, bytes] = "", status: int = 200, headers: dict[str, str] | None = None, content_type: Optional[str] = None) -> None:
+        self.status = status
+        self.context: dict[str, Any] = {}
+        self.body = b""
+        self.headers: list[list[bytes]] = []
+        if body or content_type or headers:
+            self._set(body=body, status=status, headers=headers, content_type=content_type)
+
+    def _set(self, body: Union[str, bytes] = "", status: int = 200, headers: dict[str, str] | None = None, content_type: Optional[str] = None) -> "Response":
+        self.status = status
+        if isinstance(body, str):
+            self.body = body.encode("utf-8")
+            if content_type is None:
+                content_type = "text/plain"
+        elif isinstance(body, bytes):
+            self.body = body
+            if content_type is None and body:
+                content_type = "application/octet-stream"
+        else:
+            raise TypeError(f"Response body must be str or bytes, got {type(body)}")
+        header_map = dict(headers) if headers else {}
+        if content_type and not any(key.lower() == "content-type" for key in header_map):
+            header_map["content-type"] = content_type
+        # Preserve Set-Cookie headers already appended via set_cookie
+        cookies = [pair for pair in self.headers if pair[0].lower() == b"set-cookie"]
+        self.headers = [[key.encode(), value.encode()] for key, value in header_map.items()]
+        self.headers.extend(cookies)
+        return self
+
+    def json(self, data: Any, status: int = 200, headers: dict[str, str] | None = None) -> "Response":
+        return self._set(body=json.dumps(data, default=str, ensure_ascii=False), status=status, headers=headers, content_type="application/json")
+
+    def html(self, html: str, status: int = 200, headers: dict[str, str] | None = None) -> "Response":
+        return self._set(body=html, status=status, headers=headers, content_type="text/html")
+
+    def text(self, body: str = "", status: int = 200, headers: dict[str, str] | None = None) -> "Response":
+        return self._set(body=body, status=status, headers=headers, content_type="text/plain")
+
+    def empty(self, status: int = 204, headers: dict[str, str] | None = None) -> "Response":
+        return self._set(body="", status=status, headers=headers, content_type=None)
+
+    def redirect(self, url: str, status: int = 302, headers: dict[str, str] | None = None) -> "Response":
+        final = dict(headers) if headers else {}
+        final["location"] = url
+        return self._set(body="", status=status, headers=final, content_type=None)
+
+    def file(self, body: bytes = b"", status: int = 200, headers: dict[str, str] | None = None, content_type: str = "application/octet-stream") -> "Response":
+        return self._set(body=body, status=status, headers=headers, content_type=content_type)
+
+    def image(self, body: bytes = b"", status: int = 200, headers: dict[str, str] | None = None, content_type: str = "image/png", file_path: str | None = None) -> "Response":
+        if file_path:
+            with open(file_path, "rb") as f:
+                body = f.read()
+        return self._set(body=body, status=status, headers=headers, content_type=content_type)
+
+    def set_cookie(self, name: str, value: str, path: str = "/", httponly: bool = True, samesite: str = "Lax", secure: bool = False, max_age: int | None = None, domain: str | None = None, expires: str | None = None) -> "Response":
+        cookie = f"{name}={value}; Path={path}"
+        if domain:
+            cookie += f"; Domain={domain}"
+        if max_age is not None:
+            cookie += f"; Max-Age={int(max_age)}"
+        if expires:
+            cookie += f"; Expires={expires}"
+        if httponly:
+            cookie += "; HttpOnly"
+        cookie += f"; SameSite={samesite}"
+        if secure:
+            cookie += "; Secure"
+        self.headers.append([b"set-cookie", cookie.encode("utf-8")])
+        return self
+
+    def delete_cookie(self, name: str, path: str = "/") -> "Response":
+        self.headers.append([b"set-cookie", f"{name}=; Path={path}; Max-Age=0".encode("utf-8")])
+        return self
+
+    async def __call__(self, send: Callable[[dict[str, Any]], Awaitable[None]]) -> None:
+        start_message = {
+            "type": "http.response.start",
+            "status": self.status,
+            "headers": self.headers,
+        }
+        await send(start_message)
+        body_message = {
+            "type": "http.response.body",
+            "body": self.body,
+        }
+        await send(body_message)
+
+
+class WebSocketResponse:
+    """ASGI WebSocket session: accept, send/receive loop, then exit on disconnect."""
+
+    def __init__(self, receive: Any, message: str = "") -> None:
+        self._asgi_receive = receive
+        self.message = message
+        self._send: Any = None
+
+    async def accept(self) -> None:
+        await self._send({"type": "websocket.accept"})
+
+    async def send_text(self, text: str) -> None:
+        await self._send({"type": "websocket.send", "text": text})
+
+    async def send_bytes(self, data: bytes) -> None:
+        await self._send({"type": "websocket.send", "bytes": data})
+
+    async def close(self, code: int = 1000, reason: str = "") -> None:
+        await self._send({"type": "websocket.close", "code": code, "reason": reason})
+
+    async def receive(self) -> dict[str, Any] | None:
+        while True:
+            message = await self._asgi_receive()
+            if message["type"] == "websocket.disconnect":
+                return None
+            if message["type"] == "websocket.receive":
+                return message
+
+    async def receive_text(self) -> str | None:
+        message = await self.receive()
+        if message is None:
+            return None
+        if "text" in message and message["text"] is not None:
+            return message["text"]
+        if "bytes" in message and message["bytes"] is not None:
+            return message["bytes"].decode("utf-8")
+        return None
+
+    async def __call__(self, send: Any) -> None:
+        self._send = send
+        await self.accept()
+        if self.message:
+            await self.send_text(f"Echo: {self.message}")
+        while True:
+            text = await self.receive_text()
+            if text is None:
+                break
+            await self.send_text(f"Echo: {text}")
+
+
+# Temporary wrappers for migration
+class PlainTextResponse(Response):
+    def __init__(self, body: str = "", status: int = 200, headers: dict[str, str] | None = None) -> None:
+        super().__init__()
+        self.text(body, status=status, headers=headers)
+
+
+class JSONResponse(Response):
+    def __init__(self, data: Any = None, status: int = 200, headers: dict[str, str] | None = None) -> None:
+        super().__init__()
+        self.json(data, status=status, headers=headers)
+
+
+class EmptyResponse(Response):
+    def __init__(self, status: int = 204, headers: dict[str, str] | None = None) -> None:
+        super().__init__()
+        self.empty(status=status, headers=headers)
+
+
+class HTMLResponse(Response):
+    def __init__(self, html: str = "", status: int = 200, headers: dict[str, str] | None = None) -> None:
+        super().__init__()
+        self.html(html, status=status, headers=headers)
+
+
+class PNGResponse(Response):
+    def __init__(self, body: bytes = b"", status: int = 200, headers: dict[str, str] | None = None) -> None:
+        super().__init__()
+        self.image(body, status=status, headers=headers, content_type="image/png")
+
+
+class ImageResponse(Response):
+    def __init__(
+        self, body: bytes = b"", status: int = 200, headers: dict[str, str] | None = None, image_content_type: str = "image/png", file_path: str | None = None
+    ) -> None:
+        super().__init__()
+        self.image(body, status=status, headers=headers, content_type=image_content_type, file_path=file_path)
+
+
+class RedirectResponse(Response):
+    def __init__(self, url: str = "", status: int = 302, headers: dict[str, str] | None = None) -> None:
+        super().__init__()
+        if url:
+            self.redirect(url, status=status, headers=headers)
+
+
+class FileResponse(Response):
+    def __init__(self, body: bytes = b"", status: int = 200, headers: dict[str, str] | None = None) -> None:
+        super().__init__()
+        self.file(body, status=status, headers=headers)
+
+
+class StreamingResponse(Response):
+    async def __call__(self, send: Any) -> None:
+        raise NotImplementedError("streaming is not implemented yet")

future/routing.py

@@ -0,0 +1,342 @@
+import re
+
+from typing import Any, Callable, Optional, TypedDict
+
+from future.logger import log
+from future.middleware import Middleware
+
+
+class RegexConfig(TypedDict):
+    paths: list[re.Pattern[str]]
+
+
+class RouteException(Exception):
+    pass
+
+
+class InvalidValuePatternName(RouteException):
+    def __init__(self, pattern_name: str, matched_parameter: str) -> None:
+        self.pattern_name = pattern_name
+        self.matched_parameter = matched_parameter
+        super().__init__(f"Invalid value pattern name: {pattern_name} in {matched_parameter}")
+
+
+class RouteMatch:
+    def __init__(self, route: "Route", params: Optional[dict[str, str]]) -> None:
+        self.route = route
+        self.params = params
+
+
+class Route:
+    value_patterns = {
+        "string": r"[^\/]+",
+        "str": r"[^\/]+",
+        "path": r".*",
+        "int": r"\d+",
+        "float": r"\d+(?:\.\d+)?",
+        "uuid": r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",
+    }
+
+    def __init__(
+        self,
+        methods: list[str],
+        path: str,
+        endpoint: Callable[..., Any],
+        name: str,
+        strict_slashes: bool = False,
+        middlewares: Optional[list[Middleware]] = None,
+        scopes: Optional[list[str]] = None,
+    ) -> None:
+        self.methods = methods
+        self.path = path
+        self.endpoint = endpoint
+        self.name = name
+        self.strict_slashes = strict_slashes
+        self.middlewares = middlewares or []
+        self.scopes = scopes or []
+
+    # Huge credits to BlackSheep for the code below.
+    def compile_pattern(self) -> None:
+        _route_all_rx = re.compile(b"\\*")
+        _route_param_rx = re.compile(b"/:([^/]+)")
+
+        _mustache_route_param_rx = re.compile(b"/{([^}]+)}")
+        _angle_bracket_route_param_rx = re.compile(b"/<([^>]+)>")
+
+        _named_group_rx = re.compile(b"\\?P<([^>]+)>")
+        _escaped_chars = {
+            b".",
+            b"[",
+            b"]",
+            b"(",
+            b")",
+        }
+
+        def _get_parameter_pattern_fragment(name: str, pattern: Optional[str] = None) -> bytes:
+            if pattern is None:
+                pattern = Route.value_patterns["string"]
+            return rb"/(?P<" + name.encode() + rb">" + pattern.encode() + rb")"
+
+        def _handle_rich_parameter(match: re.Match[bytes]) -> bytes:
+            matched_parameter = next(iter(match.groups()))
+            assert isinstance(matched_parameter, bytes)
+
+            if b":" in matched_parameter:
+                raw_pattern_name, parameter_name = matched_parameter.split(b":")
+                parameter_pattern_name = raw_pattern_name.decode()
+                parameter_pattern = Route.value_patterns.get(parameter_pattern_name)
+
+                if not parameter_pattern:
+                    raise InvalidValuePatternName(parameter_pattern_name, matched_parameter.decode("utf8"))
+
+                return _get_parameter_pattern_fragment(parameter_name.decode(), parameter_pattern)
+
+            return _get_parameter_pattern_fragment(matched_parameter.decode())
+
+        pattern = self.path.encode()
+        for c in _escaped_chars:
+            if c in pattern:
+                pattern = pattern.replace(c, b"\\" + c)
+
+        if b"*" in pattern:
+            if pattern.count(b"*") > 1:
+                raise RouteException("A route pattern cannot contain more than one star sign *.")
+            if b"/*" in pattern:
+                pattern = _route_all_rx.sub(rb"?(?P<tail>.*)", pattern)
+            else:
+                pattern = _route_all_rx.sub(rb"(?P<tail>.*)", pattern)
+
+        if b"<" in pattern:
+            pattern = _angle_bracket_route_param_rx.sub(_handle_rich_parameter, pattern)
+
+        if b"{" in pattern:
+            pattern = _mustache_route_param_rx.sub(_handle_rich_parameter, pattern)
+
+        if b"/:" in pattern:
+            pattern = _route_param_rx.sub(rb"/(?P<\1>[^\/]+)", pattern)
+
+        param_names = []
+        for p in _named_group_rx.finditer(pattern):
+            param_name = p.group(1).decode()
+
+            if param_name in param_names:
+                raise ValueError(f"cannot have multiple parameters with name: {param_name}")
+
+            param_names.append(param_name)
+
+        if len(pattern) > 1 and not pattern.endswith(b"*") and not self.strict_slashes:
+            pattern = pattern + b"/?"
+
+        self._rx = re.compile(b"^" + pattern + b"$", re.IGNORECASE)
+
+        self.param_names = param_names
+
+    def match(self, request_method: str, request_path: bytes) -> Optional[RouteMatch]:
+        log.debug("Matching on request type %s for path: %s using regex: %s", self.methods, request_path, self._rx)
+        # Check if the HTTP method matches the allowed methods for this route
+        if request_method not in self.methods:
+            return None
+
+        # Check if the request path matches the compiled regex pattern for this route
+        match = self._rx.match(request_path)
+        if not match:
+            return None
+
+        # Convert bytes values to strings in groupdict
+        params = None
+        if self.param_names:
+            groupdict = match.groupdict()
+            params = {key: value.decode("utf-8") if isinstance(value, bytes) else str(value) for key, value in groupdict.items()}
+
+        route_match = RouteMatch(self, params)
+        return route_match
+
+
+class Get(Route):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        name: str,
+        strict_slashes: bool = False,
+        middlewares: Optional[list[Middleware]] = None,
+        scopes: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(
+            methods=["GET"],
+            path=path,
+            endpoint=endpoint,
+            name=name,
+            strict_slashes=strict_slashes,
+            middlewares=middlewares,
+            scopes=scopes,
+        )
+
+
+class Post(Route):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        name: str,
+        strict_slashes: bool = False,
+        middlewares: Optional[list[Middleware]] = None,
+        scopes: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(
+            methods=["POST"],
+            path=path,
+            endpoint=endpoint,
+            name=name,
+            strict_slashes=strict_slashes,
+            middlewares=middlewares,
+            scopes=scopes,
+        )
+
+
+class Put(Route):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        name: str,
+        strict_slashes: bool = False,
+        middlewares: Optional[list[Middleware]] = None,
+        scopes: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(
+            methods=["PUT"],
+            path=path,
+            endpoint=endpoint,
+            name=name,
+            strict_slashes=strict_slashes,
+            middlewares=middlewares,
+            scopes=scopes,
+        )
+
+
+class Head(Route):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        name: str,
+        strict_slashes: bool = False,
+        middlewares: Optional[list[Middleware]] = None,
+        scopes: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(
+            methods=["HEAD"],
+            path=path,
+            endpoint=endpoint,
+            name=name,
+            strict_slashes=strict_slashes,
+            middlewares=middlewares,
+            scopes=scopes,
+        )
+
+
+class Options(Route):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        name: str,
+        strict_slashes: bool = False,
+        middlewares: Optional[list[Middleware]] = None,
+        scopes: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(
+            methods=["OPTIONS"],
+            path=path,
+            endpoint=endpoint,
+            name=name,
+            strict_slashes=strict_slashes,
+            middlewares=middlewares,
+            scopes=scopes,
+        )
+
+
+class Patch(Route):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        name: str,
+        strict_slashes: bool = False,
+        middlewares: Optional[list[Middleware]] = None,
+        scopes: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(
+            methods=["PATCH"],
+            path=path,
+            endpoint=endpoint,
+            name=name,
+            strict_slashes=strict_slashes,
+            middlewares=middlewares,
+            scopes=scopes,
+        )
+
+
+class Delete(Route):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        name: str,
+        strict_slashes: bool = False,
+        middlewares: Optional[list[Middleware]] = None,
+        scopes: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(
+            methods=["DELETE"],
+            path=path,
+            endpoint=endpoint,
+            name=name,
+            strict_slashes=strict_slashes,
+            middlewares=middlewares,
+            scopes=scopes,
+        )
+
+
+class WebSocket(Route):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        name: str,
+        strict_slashes: bool = False,
+        middlewares: Optional[list[Middleware]] = None,
+        scopes: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(
+            methods=["WEBSOCKET"],
+            path=path,
+            endpoint=endpoint,
+            name=name,
+            strict_slashes=strict_slashes,
+            middlewares=middlewares,
+            scopes=scopes,
+        )
+
+
+class RouteGroup:
+    def __init__(
+        self,
+        routes: list[Route],
+        name: str = "",
+        prefix: str = "",
+        subdomain: str = "",
+        middlewares: Optional[list[Middleware]] = None,
+    ) -> None:
+        self.name = name
+        self.prefix = prefix
+        self.routes = routes
+        self.subdomain = subdomain
+        self.middlewares = middlewares or []
+
+
+class EndpointConfig(TypedDict):
+    middleware_before: list[Middleware]
+    middleware_after: list[Middleware]
+    route: Route

future/seeds/SeedGenerator.py

@@ -0,0 +1,95 @@
+# Generate seeder stubs from Model annotations.
+
+
+from pathlib import Path
+from types import UnionType
+from typing import get_args, get_origin, Union
+
+from future.migrations.MigrationGenerator import MigrationGenerator
+
+
+class SeedGenerator:
+    def __init__(self, models_path="app/models", seeds_path="database/seeds"):
+        self.models_path = models_path
+        self.seeds_path = seeds_path
+
+    def find_model(self, name):
+        for model in MigrationGenerator(models_path=self.models_path).discover_models():
+            if model.__name__ == name:
+                return model
+        raise ValueError(f"Model not found: {name}")
+
+    def value_expr(self, field, annotation):
+        origin = get_origin(annotation)
+        if origin is Union or origin is UnionType:
+            args = [arg for arg in get_args(annotation) if arg is not type(None)]
+            annotation = args[0] if args else str
+        type_name = getattr(annotation, "__name__", str(annotation))
+        if field == "id":
+            return "fake.uuid4()"
+        if type_name == "datetime":
+            return "fake.date_time_this_year()"
+        if type_name == "int":
+            return "fake.random_int(1, 9999)"
+        if type_name == "float":
+            return "float(fake.pyfloat(min_value=1, max_value=100))"
+        if type_name == "bool":
+            return "fake.boolean()"
+        if field.endswith("_id"):
+            return "str(fake.random_int(1000, 9999))"
+        if "email" in field:
+            return "fake.email()"
+        if "name" in field or "username" in field:
+            return "fake.user_name()"
+        if field in ("description", "text", "body", "content") or field.endswith("_original") or field.endswith("_translated"):
+            return "fake.paragraph()"
+        return "fake.word()"
+
+    def render(self, model):
+        name = model.__name__
+        annotations = dict(getattr(model, "__annotations__", {}))
+        args = []
+        for field, annotation in annotations.items():
+            args.append(f"                {field}={self.value_expr(field, annotation)},")
+        if args:
+            construct = f"            {name}(\n" + "\n".join(args) + f"\n            ).save()"
+        else:
+            construct = f"            {name}().save()"
+        return (
+            "from faker import Faker\n"
+            "from future.seeds.Seeder import Seeder\n"
+            f"from app.models.{name} import {name}\n"
+            "\n"
+            "\n"
+            f"class {name}Seeder(Seeder):\n"
+            "    def run(self):\n"
+            "        fake = Faker()\n"
+            "        for _ in range(10):\n"
+            f"{construct}\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 model in MigrationGenerator(models_path=self.models_path).discover_models():
+            path = self.write(model, skip_existing=True)
+            if path is not None:
+                paths.append(path)
+        return paths
+
+    def write(self, model, skip_existing=False):
+        class_name = f"{model.__name__}Seeder"
+        directory = Path(self.seeds_path)
+        directory.mkdir(parents=True, exist_ok=True)
+        path = directory / f"{class_name}.py"
+        if path.exists():
+            if skip_existing:
+                return None
+            raise FileExistsError(f"File already exists: {path}")
+        path.write_text(self.render(model))
+        return str(path)

future/seeds/SeedRunner.py

@@ -0,0 +1,42 @@
+# Discovers and runs seeder classes from a seeds directory.
+
+
+import importlib.util
+from pathlib import Path
+
+from .Seeder import Seeder
+
+
+class SeedRunner:
+    def __init__(self, path):
+        self.path = path
+
+    def discover(self):
+        seeders = {}
+        directory = Path(self.path)
+        if not directory.exists():
+            return seeders
+        for file_path in sorted(directory.glob("*.py")):
+            if file_path.name.startswith("_"):
+                continue
+            module_name = f"seeder_{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, Seeder) and value is not Seeder:
+                    seeders[value.__name__] = value
+        return seeders
+
+    def run(self, name=None):
+        seeders = self.discover()
+        if name is not None:
+            if name not in seeders:
+                raise ValueError(f"Seeder not found: {name}")
+            seeders[name]().run()
+            return [name]
+        ran = []
+        for seeder_name in sorted(seeders.keys()):
+            seeders[seeder_name]().run()
+            ran.append(seeder_name)
+        return ran

future/seeds/Seeder.py

@@ -0,0 +1,9 @@
+# Base class for database seeders (Orator/Masonite-style).
+
+
+class Seeder:
+    def run(self):
+        raise NotImplementedError
+
+    def call(self, seeder_class):
+        seeder_class().run()