future-framework 2.0.0__tar.gz → 2.1.1__tar.gz

{future_framework-2.0.0 → future_framework-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: future-framework
-Version: 2.0.0
+Version: 2.1.1
 Summary: ASGI-based framework for web APIs
 License: LICENSE
 License-File: LICENSE
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Requires-Dist: aiomysql (>=0.2.0,<0.3.0)
 Requires-Dist: aiosqlite (>=0.21.0,<0.22.0)
 Requires-Dist: asynch (>=0.2.5,<0.3.0)

{future_framework-2.0.0 → future_framework-2.1.1}/future/application.py

@@ -402,7 +402,7 @@ class Future:
         try:
             host_domain = request.host.split("/")[0] if "/" in request.host else request.host
             if not self._validate_domain_access(host_domain):
-                raise HTTPException("Forbidden", 403)
+                raise HTTPException("Not Found", 404)
 
             debug = bool(self.config.get("APP_DEBUG")) if self.config else False
             route_host = host_domain.rsplit(":", 1)[0] if debug and ":" in host_domain else host_domain

{future_framework-2.0.0 → future_framework-2.1.1}/future/databases/ElasticsearchDatabase.py

@@ -42,7 +42,10 @@ class ElasticsearchDatabase(IDatabase):
             return None
         if not result or "_source" not in result:
             return None
-        return model.__class__(**result["_source"])
+        source = dict(result["_source"] or {})
+        if result.get("_id") is not None and not source.get("id"):
+            source["id"] = result["_id"]
+        return model.__class__(**source)
 
     async def all(self, model):
         if self.client is None:
@@ -51,7 +54,13 @@ class ElasticsearchDatabase(IDatabase):
             result = await self.client.search(index=model.tableize(), body={"query": {"match_all": {}}, "size": 10000})
         except Exception:
             return []
-        return [model.__class__(**hit["_source"]) for hit in result.get("hits", {}).get("hits", [])]
+        rows = []
+        for hit in result.get("hits", {}).get("hits", []):
+            source = dict(hit.get("_source") or {})
+            if hit.get("_id") is not None and not source.get("id"):
+                source["id"] = hit["_id"]
+            rows.append(model.__class__(**source))
+        return rows
 
     async def get(self, model, wheres, limit=None, orders=None):
         if self.client is None:
@@ -85,7 +94,13 @@ class ElasticsearchDatabase(IDatabase):
             result = await self.client.search(index=model.tableize(), body=body)
         except Exception:
             return []
-        return [model.__class__(**hit["_source"]) for hit in result.get("hits", {}).get("hits", [])]
+        rows = []
+        for hit in result.get("hits", {}).get("hits", []):
+            source = dict(hit.get("_source") or {})
+            if hit.get("_id") is not None and not source.get("id"):
+                source["id"] = hit["_id"]
+            rows.append(model.__class__(**source))
+        return rows
 
     async def delete(self, model):
         if self.client is None:

{future_framework-2.0.0 → future_framework-2.1.1}/future/databases/PostgresDatabase.py

@@ -1,5 +1,6 @@
 from future.interfaces.IDatabase import IDatabase
-from sqlalchemy import text
+from sqlalchemy import BigInteger, String, bindparam, text
+from sqlalchemy.dialects.postgresql import ARRAY
 from sqlalchemy.ext.asyncio import create_async_engine
 from urllib.parse import quote_plus
 
@@ -61,17 +62,21 @@ class PostgresDatabase(IDatabase):
         table = model.tableize()
         clauses = []
         params = {}
+        array_binds = {}
         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)})')
+                # One array bind avoids Postgres' ~32767 bind-variable limit.
+                key = f"v{index}"
+                clauses.append(f'"{column}" = ANY(:{key})')
+                params[key] = values
+                sample = values[0]
+                if isinstance(sample, int) and not isinstance(sample, bool):
+                    array_binds[key] = ARRAY(BigInteger)
+                else:
+                    array_binds[key] = ARRAY(String)
                 continue
             if operator == "like":
                 key = f"v{index}"
@@ -90,8 +95,11 @@ class PostgresDatabase(IDatabase):
             sql += " ORDER BY " + ", ".join(f'"{column}" {direction}' for column, direction in orders)
         if limit is not None:
             sql += f" LIMIT {int(limit)}"
+        stmt = text(sql)
+        for key, array_type in array_binds.items():
+            stmt = stmt.bindparams(bindparam(key, type_=array_type))
         async with self.client.connect() as connection:
-            rows = (await connection.execute(text(sql), params)).mappings().all()
+            rows = (await connection.execute(stmt, params)).mappings().all()
         return [model.__class__(**dict(row)) for row in rows]
 
     async def delete(self, model):

{future_framework-2.0.0 → future_framework-2.1.1}/future/response.py

@@ -30,7 +30,7 @@ class Response:
             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 = [[key.lower().encode(), value.encode()] for key, value in header_map.items()]
         self.headers.extend(cookies)
         return self
 
@@ -54,11 +54,6 @@ class Response:
     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 stream(self, chunks, status: int = 200, headers: dict[str, str] | None = None, content_type: str = "application/octet-stream") -> "StreamingResponse":
-        streamed = StreamingResponse(chunks, status=status, headers=headers, content_type=content_type)
-        streamed.headers.extend([pair for pair in self.headers if pair[0].lower() == b"set-cookie"])
-        return streamed
-
     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:
@@ -149,72 +144,33 @@ class WebSocketResponse:
             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):
     def __init__(self, body=(), status: int = 200, headers: dict[str, str] | None = None, content_type: Optional[str] = None) -> None:
         super().__init__(body=b"", status=status, headers=headers, content_type=content_type or "application/octet-stream")
         self._chunks = body
 
     async def __call__(self, send: Any) -> None:
-        await send({"type": "http.response.start", "status": self.status, "headers": self.headers})
+        await send({"type": "http.response.start", "status": int(self.status), "headers": self.headers})
         chunks = self._chunks
-        if isinstance(chunks, (bytes, str)):
+        if isinstance(chunks, (bytes, bytearray, memoryview, str)):
             chunks = [chunks]
         if hasattr(chunks, "__aiter__"):
             async for chunk in chunks:
-                await send({"type": "http.response.body", "body": chunk if isinstance(chunk, bytes) else str(chunk).encode("utf-8"), "more_body": True})
+                if isinstance(chunk, (bytes, bytearray, memoryview)):
+                    body = bytes(chunk)
+                elif isinstance(chunk, str):
+                    body = chunk.encode("utf-8")
+                else:
+                    raise TypeError(f"stream chunk must be bytes or str, got {type(chunk).__name__}")
+                await send({"type": "http.response.body", "body": body, "more_body": True})
         else:
             for chunk in chunks:
-                await send({"type": "http.response.body", "body": chunk if isinstance(chunk, bytes) else str(chunk).encode("utf-8"), "more_body": True})
+                if isinstance(chunk, (bytes, bytearray, memoryview)):
+                    body = bytes(chunk)
+                elif isinstance(chunk, str):
+                    body = chunk.encode("utf-8")
+                else:
+                    raise TypeError(f"stream chunk must be bytes or str, got {type(chunk).__name__}")
+                await send({"type": "http.response.body", "body": body, "more_body": True})
         await send({"type": "http.response.body", "body": b"", "more_body": False})
+

{future_framework-2.0.0 → future_framework-2.1.1}/future/seeder.py

@@ -65,7 +65,7 @@ class SeedGenerator:
                 return model
         raise ValueError(f"Model not found: {name}")
 
-    def value_expr(self, field, annotation):
+    def value_expr(self, field, annotation, model_name=None):
         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)]
@@ -73,10 +73,30 @@ class SeedGenerator:
         type_name = getattr(annotation, "__name__", str(annotation))
         if field == "id":
             return "fake.uuid4()"
+        if field in ("timestamp", "published_at", "generated_at", "joined_at", "trades_synced_at", "last_login_at"):
+            return 'fake.date_time_between(start_date="-1y", end_date="now")'
         if type_name == "datetime":
             return "fake.date_time_this_year()"
+        if field == "historical_trades_offset":
+            return "0"
+        if field in ("follower_count", "following_count"):
+            return "fake.random_int(0, 5000)"
+        if field == "average_hold_time":
+            return "fake.random_int(1, 365)"
+        if field == "rating":
+            return "fake.random_int(0, 5)"
+        if field == "window_hours":
+            return "fake.random_int(1, 168)"
+        if field == "unique_traders":
+            return "fake.random_int(2, 20)"
         if type_name == "int":
             return "fake.random_int(1, 9999)"
+        if field == "price":
+            return "float(fake.pyfloat(min_value=5, max_value=1500, right_digits=2))"
+        if field == "percentage_change":
+            return "float(fake.pyfloat(min_value=-25, max_value=25, right_digits=2))"
+        if field == "strength":
+            return "float(fake.pyfloat(min_value=0, max_value=100, right_digits=2))"
         if type_name == "float":
             return "float(fake.pyfloat(min_value=1, max_value=100))"
         if type_name == "bool":
@@ -85,6 +105,46 @@ class SeedGenerator:
             return "str(fake.random_int(1000, 9999))"
         if "email" in field:
             return "fake.email()"
+        if field == "firstname":
+            return "fake.first_name()"
+        if field == "lastname":
+            return "fake.last_name()"
+        if field == "instrument_name":
+            return "fake.company()"
+        if field == "symbol":
+            return 'fake.lexify(text="????").upper()'
+        if field in ("logo_url", "image_url", "avatar_uri"):
+            return "fake.image_url()"
+        if field == "url":
+            return "fake.url()"
+        if field == "currency":
+            return 'fake.random_element(elements=("NOK", "SEK", "DKK", "EUR", "USD"))'
+        if field == "language":
+            return 'fake.random_element(elements=("nb", "sv", "da", "en"))'
+        if field == "trade_type" or field == "side":
+            return 'fake.random_element(elements=("BUY", "SELL"))'
+        if field == "percentage_change_interval":
+            return 'fake.random_element(elements=("UNKNOWN", "LESS_THAN_ONE", "ONE_TO_FIVE", "FIVE_TO_TEN", "TEN_TO_TWENTY", "TWENTY_TO_THIRTY", "OVER_ONE_HUNDRED"))'
+        if field == "group_type":
+            return 'fake.random_element(elements=("COMMON_SHARE", "FND", "ETF", "WARRANT", "OTHER"))'
+        if field == "kind":
+            return 'fake.random_element(elements=("instruments", "users"))'
+        if field == "members":
+            return "fake.json()"
+        if field == "title":
+            return "fake.sentence(nb_words=8)"
+        if field in ("summary", "reason"):
+            return "fake.sentence()"
+        if field == "password_hash":
+            return "fake.sha256()"
+        if field == "name" and model_name == "NordnetInstrumentModel":
+            return 'fake.random_element(elements=("Equinor", "Nordnet Global Indeks", "DNB Teknologi A", "T1 Energy", "Aker BP"))'
+        if field == "name" and model_name == "IndexModel":
+            return 'fake.random_element(elements=("Nordic Momentum", "Top Shareville Traders", "Consensus Buys", "Long-term Winners"))'
+        if field == "country":
+            return 'fake.random_element(elements=("NO", "SE", "DK", "FI"))'
+        if field == "slug":
+            return "fake.slug()"
         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"):
@@ -103,7 +163,7 @@ class SeedGenerator:
                 current = non_null[0] if non_null else str
             if isinstance(current, type) and issubclass(current, IModel):
                 continue
-            args.append(f"                {field}={self.value_expr(field, annotation)},")
+            args.append(f"                {field}={self.value_expr(field, annotation, name)},")
         if args:
             construct = f"            await {name}(\n" + "\n".join(args) + f"\n            ).save()"
         else:

{future_framework-2.0.0 → future_framework-2.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "future-framework"
-version = "2.0.0"
+version = "2.1.1"
 description = "ASGI-based framework for web APIs"
 authors = ["nicolaipre"]
 license = "LICENSE"