panther 5.0.0b2__py3-none-any.whl → 5.0.0b4__py3-none-any.whl

panther/permissions.py

@@ -1,9 +1,10 @@
 from panther.request import Request
+from panther.websocket import Websocket
 
 
 class BasePermission:
     @classmethod
-    async def authorization(cls, request: Request) -> bool:
+    async def authorization(cls, request: Request | Websocket) -> bool:
         return True
 
 

panther/request.py

@@ -1,5 +1,6 @@
 import logging
-from typing import Literal, Callable
+from collections.abc import Callable
+from typing import Literal
 from urllib.parse import parse_qsl
 
 import orjson as json

panther/response.py

@@ -1,9 +1,15 @@
 import asyncio
+import logging
+from collections.abc import AsyncGenerator, Generator
 from dataclasses import dataclass
 from http import cookies
 from sys import version_info
 from types import NoneType
-from typing import Generator, AsyncGenerator, Any, Type, Literal
+from typing import Any, Literal
+
+import jinja2
+
+from panther.exceptions import APIError
 
 if version_info >= (3, 11):
     from typing import LiteralString
@@ -13,19 +19,23 @@ else:
     LiteralString = TypeVar('LiteralString')
 
 import orjson as json
+from pantherdb import Cursor as PantherDBCursor
 from pydantic import BaseModel
 
 from panther import status
-from panther.configs import config
 from panther._utils import to_async_generator
+from panther.configs import config
 from panther.db.cursor import Cursor
-from pantherdb import Cursor as PantherDBCursor
 from panther.pagination import Pagination
 
-ResponseDataTypes = list | tuple | set | Cursor | PantherDBCursor | dict | int | float | str | bool | bytes | NoneType | Type[BaseModel]
+ResponseDataTypes = (
+    list | tuple | set | Cursor | PantherDBCursor | dict | int | float | str | bool | bytes | NoneType | type[BaseModel]
+)
 IterableDataTypes = list | tuple | set | Cursor | PantherDBCursor
 StreamingDataTypes = Generator | AsyncGenerator
 
+logger = logging.getLogger('panther')
+
 
 @dataclass(slots=True)
 class Cookie:
@@ -44,6 +54,7 @@ class Cookie:
         `lax` is the default behavior if not specified.
     expires: [Deprecated] In HTTP version 1.1, `expires` was deprecated and replaced with the easier-to-use `max-age`
     """
+
     key: str
     value: str
     domain: str = None
@@ -63,7 +74,7 @@ class Response:
         status_code: int = status.HTTP_200_OK,
         headers: dict | None = None,
         pagination: Pagination | None = None,
-        set_cookies: list[Cookie] | None = None
+        set_cookies: Cookie | list[Cookie] | None = None,
     ):
         """
         :param data: should be an instance of ResponseDataTypes
@@ -71,10 +82,10 @@ class Response:
         :param headers: should be dict of headers
         :param pagination: an instance of Pagination or None
             The `pagination.template()` method will be used
-        :param set_cookies: list of cookies you want to set on the client
+        :param set_cookies: single cookie or list of cookies you want to set on the client
             Set the `max_age` to `0` if you want to delete a cookie
         """
-        headers = headers or {}
+        self.headers = {'Content-Type': self.content_type} | (headers or {})
         self.pagination: Pagination | None = pagination
         if isinstance(data, Cursor):
             data = list(data)
@@ -84,6 +95,8 @@ class Response:
         self.cookies = None
         if set_cookies:
             c = cookies.SimpleCookie()
+            if not isinstance(set_cookies, list):
+                set_cookies = [set_cookies]
             for cookie in set_cookies:
                 c[cookie.key] = cookie.value
                 c[cookie.key]['path'] = cookie.path
@@ -95,36 +108,23 @@ class Response:
                 if cookie.max_age is not None:
                     c[cookie.key]['max-age'] = cookie.max_age
             self.cookies = [(b'Set-Cookie', cookie.OutputString().encode()) for cookie in c.values()]
-        self.headers = headers
 
     @property
     def body(self) -> bytes:
         if isinstance(self.data, bytes):
             return self.data
-
         if self.data is None:
             return b''
         return json.dumps(self.data)
 
     @property
-    def headers(self) -> dict:
-        return {
-            'Content-Type': self.content_type,
-            'Content-Length': len(self.body),
-            'Access-Control-Allow-Origin': '*',
-        } | self._headers
-
-    @property
-    def bytes_headers(self) -> list[tuple[bytes]]:
-        result = [(k.encode(), str(v).encode()) for k, v in (self.headers or {}).items()]
+    def bytes_headers(self) -> list[tuple[bytes, bytes]]:
+        headers = {'Content-Length': len(self.body)} | self.headers
+        result = [(k.encode(), str(v).encode()) for k, v in headers.items()]
         if self.cookies:
-            result.extend(self.cookies)
+            result += self.cookies
         return result
 
-    @headers.setter
-    def headers(self, headers: dict):
-        self._headers = headers
-
     @classmethod
     def prepare_data(cls, data: Any):
         """Make sure the response data is only ResponseDataTypes or Iterable of ResponseDataTypes"""
@@ -151,16 +151,10 @@ class Response:
             raise TypeError(error)
         return status_code
 
-    async def send_headers(self, send, /):
+    async def send(self, send, receive):
         await send({'type': 'http.response.start', 'status': self.status_code, 'headers': self.bytes_headers})
-
-    async def send_body(self, send, receive, /):
         await send({'type': 'http.response.body', 'body': self.body, 'more_body': False})
 
-    async def send(self, send, receive, /):
-        await self.send_headers(send)
-        await self.send_body(send, receive)
-
     def __str__(self):
         if len(data := str(self.data)) > 30:
             data = f'{data:.27}...'
@@ -190,15 +184,11 @@ class StreamingResponse(Response):
         raise TypeError(msg)
 
     @property
-    def headers(self) -> dict:
-        return {
-            'Content-Type': self.content_type,
-            'Access-Control-Allow-Origin': '*',
-        } | self._headers
-
-    @headers.setter
-    def headers(self, headers: dict):
-        self._headers = headers
+    def bytes_headers(self) -> list[tuple[bytes, bytes]]:
+        result = [(k.encode(), str(v).encode()) for k, v in self.headers.items()]
+        if self.cookies:
+            result += self.cookies
+        return result
 
     @property
     async def body(self) -> AsyncGenerator:
@@ -210,8 +200,11 @@ class StreamingResponse(Response):
             else:
                 yield json.dumps(chunk)
 
-    async def send_body(self, send, receive, /):
-        asyncio.create_task(self.listen_to_disconnection(receive))
+    async def send(self, send, receive):
+        # Send Headers
+        await send({'type': 'http.response.start', 'status': self.status_code, 'headers': self.bytes_headers})
+        # Send Body as chunks
+        asyncio.create_task(self.listen_to_disconnection(receive=receive))
         async for chunk in self.body:
             if self.connection_closed:
                 break
@@ -242,13 +235,13 @@ class PlainTextResponse(Response):
 
 class TemplateResponse(HTMLResponse):
     """
-    You may want to declare `TEMPLATES_DIR` in your configs
+    You may want to declare `TEMPLATES_DIR` in your configs, default is '.'
 
     Example:
         TEMPLATES_DIR = 'templates/'
-            or
-        TEMPLATES_DIR = '.'
+
     """
+
     def __init__(
         self,
         source: str | LiteralString | NoneType = None,
@@ -265,7 +258,20 @@ class TemplateResponse(HTMLResponse):
         :param status_code: should be int
         """
         if name:
-            template = config.JINJA_ENVIRONMENT.get_template(name=name)
+            try:
+                template = config.JINJA_ENVIRONMENT.get_template(name=name)
+            except jinja2.exceptions.TemplateNotFound:
+                loaded_path = ' - '.join(
+                    ' - '.join(loader.searchpath)
+                    for loader in config.JINJA_ENVIRONMENT.loader.loaders
+                    if isinstance(loader, jinja2.loaders.FileSystemLoader)
+                )
+                error = (
+                    f'`{name}` Template Not Found.\n'
+                    f'* Make sure `TEMPLATES_DIR` in your configs is correct, Current is {loaded_path}'
+                )
+                logger.error(error)
+                raise APIError
         else:
             template = config.JINJA_ENVIRONMENT.from_string(source=source)
         super().__init__(
@@ -281,7 +287,7 @@ class RedirectResponse(Response):
         url: str,
         headers: dict | None = None,
         status_code: int = status.HTTP_307_TEMPORARY_REDIRECT,
-        set_cookies: list[Cookie] | None = None
+        set_cookies: list[Cookie] | None = None,
     ):
         headers = headers or {}
         headers['Location'] = url

panther/routings.py

@@ -1,4 +1,5 @@
 import re
+import types
 from collections import Counter
 from collections.abc import Callable, Mapping, MutableMapping
 from copy import deepcopy
@@ -37,10 +38,12 @@ def _flattening_urls(data: dict | Callable, url: str = ''):
 def _is_url_endpoint_valid(url: str, endpoint: Callable):
     if endpoint is ...:
         raise PantherError(f"URL Can't Point To Ellipsis. ('{url}' -> ...)")
-    elif endpoint is None:
+    if endpoint is None:
         raise PantherError(f"URL Can't Point To None. ('{url}' -> None)")
-    elif url and not re.match(r'^[a-zA-Z<>0-9_/-]+$', url):
+    if url and not re.match(r'^[a-zA-Z<>0-9_/-]+$', url):
         raise PantherError(f"URL Is Not Valid. --> '{url}'")
+    elif isinstance(endpoint, types.ModuleType):
+        raise PantherError(f"URL Can't Point To Module. --> '{url}'")
 
 
 def finalize_urls(urls: dict) -> dict:
@@ -64,7 +67,7 @@ def finalize_urls(urls: dict) -> dict:
     return final_urls
 
 
-def check_urls_path_variables(urls: dict, path: str = '', ) -> None:
+def check_urls_path_variables(urls: dict, path: str = '') -> None:
     middle_route_error = []
     last_route_error = []
     for key, value in urls.items():
@@ -79,13 +82,11 @@ def check_urls_path_variables(urls: dict, path: str = '', ) -> None:
 
     if len(middle_route_error) > 1:
         msg = '\n\t- ' + '\n\t- '.join(e for e in middle_route_error)
-        raise PantherError(
-            f"URLs can't have same-level path variables that point to a dict: {msg}")
+        raise PantherError(f"URLs can't have same-level path variables that point to a dict: {msg}")
 
     if len(last_route_error) > 1:
         msg = '\n\t- ' + '\n\t- '.join(e for e in last_route_error)
-        raise PantherError(
-            f"URLs can't have same-level path variables that point to an endpoint: {msg}")
+        raise PantherError(f"URLs can't have same-level path variables that point to an endpoint: {msg}")
 
 
 def _merge(destination: MutableMapping, *sources) -> MutableMapping:
@@ -185,10 +186,9 @@ def find_endpoint(path: str) -> tuple[Callable | None, str]:
         else:
             # `found` is None
             for key, value in urls.items():
-                if key.startswith('<'):
-                    if isinstance(value, dict):
-                        found_path.append(key)
-                        urls = value
-                        break
+                if key.startswith('<') and isinstance(value, dict):
+                    found_path.append(key)
+                    urls = value
+                    break
             else:
                 return ENDPOINT_NOT_FOUND

panther/serializer.py

@@ -1,8 +1,8 @@
 import typing
 from typing import Any
 
-from pydantic import create_model, BaseModel, ConfigDict
-from pydantic.fields import FieldInfo, Field
+from pydantic import BaseModel, create_model
+from pydantic.fields import Field, FieldInfo
 from pydantic_core._pydantic_core import PydanticUndefined
 
 from panther.db import Model
@@ -12,13 +12,7 @@ from panther.request import Request
 class MetaModelSerializer:
     KNOWN_CONFIGS = ['model', 'fields', 'exclude', 'required_fields', 'optional_fields']
 
-    def __new__(
-            cls,
-            cls_name: str,
-            bases: tuple[type[typing.Any], ...],
-            namespace: dict[str, typing.Any],
-            **kwargs
-    ):
+    def __new__(cls, cls_name: str, bases: tuple[type[typing.Any], ...], namespace: dict[str, typing.Any], **kwargs):
         if cls_name == 'ModelSerializer':
             # Put `model` and `request` to the main class with `create_model()`
             namespace['__annotations__'].pop('model')
@@ -45,7 +39,7 @@ class MetaModelSerializer:
             __base__=(cls.model_serializer, BaseModel),
             model=(typing.ClassVar[type[BaseModel]], config.model),
             request=(Request, Field(None, exclude=True)),
-            **field_definitions
+            **field_definitions,
         )
 
     @classmethod
@@ -108,12 +102,11 @@ class MetaModelSerializer:
                     raise AttributeError(msg) from None
 
         # Check `required_fields` and `optional_fields` together
-        if (
-                (config.optional_fields == '*' and config.required_fields != []) or
-                (config.required_fields == '*' and config.optional_fields != [])
+        if (config.optional_fields == '*' and config.required_fields != []) or (
+            config.required_fields == '*' and config.optional_fields != []
         ):
             msg = (
-                f"`{cls_name}.Config.optional_fields` and "
+                f'`{cls_name}.Config.optional_fields` and '
                 f"`{cls_name}.Config.required_fields` can't include same fields at the same time"
             )
             raise AttributeError(msg) from None
@@ -122,7 +115,7 @@ class MetaModelSerializer:
                 if optional == required:
                     msg = (
                         f"`{optional}` can't be in `{cls_name}.Config.optional_fields` and "
-                        f"`{cls_name}.Config.required_fields` at the same time"
+                        f'`{cls_name}.Config.required_fields` at the same time'
                     )
                     raise AttributeError(msg) from None
 
@@ -151,7 +144,7 @@ class MetaModelSerializer:
             for field_name in config.fields:
                 field_definitions[field_name] = (
                     config.model.model_fields[field_name].annotation,
-                    config.model.model_fields[field_name]
+                    config.model.model_fields[field_name],
                 )
 
         # Apply `exclude`
@@ -183,10 +176,15 @@ class MetaModelSerializer:
 
     @classmethod
     def collect_model_config(cls, config: typing.Callable, namespace: dict) -> dict:
-        return {
-            attr: getattr(config, attr) for attr in dir(config)
-            if not attr.startswith('__') and attr not in cls.KNOWN_CONFIGS
-        } | namespace.pop('model_config', {}) | {'arbitrary_types_allowed': True}
+        return (
+            {
+                attr: getattr(config, attr)
+                for attr in dir(config)
+                if not attr.startswith('__') and attr not in cls.KNOWN_CONFIGS
+            }
+            | namespace.pop('model_config', {})
+            | {'arbitrary_types_allowed': True}
+        )
 
 
 class ModelSerializer(metaclass=MetaModelSerializer):
@@ -202,6 +200,7 @@ class ModelSerializer(metaclass=MetaModelSerializer):
                 required_fields = ['first_name', 'last_name']  # Optional
                 optional_fields = ['age']  # Optional
     """
+
     model: type[BaseModel]
     request: Request
 

panther/test.py

@@ -4,7 +4,7 @@ from typing import Literal
 
 import orjson as json
 
-from panther.response import Response, HTMLResponse, PlainTextResponse, StreamingResponse
+from panther.response import HTMLResponse, PlainTextResponse, Response
 
 __all__ = ('APIClient', 'WebsocketClient')
 
@@ -28,12 +28,12 @@ class RequestClient:
         }
 
     async def request(
-            self,
-            path: str,
-            method: Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
-            payload: bytes | dict | None,
-            headers: dict,
-            query_params: dict,
+        self,
+        path: str,
+        method: Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+        payload: bytes | dict | None,
+        headers: dict,
+        query_params: dict,
     ) -> Response:
         headers = [(k.encode(), str(v).encode()) for k, v in headers.items()]
         if not path.startswith('/'):
@@ -56,21 +56,24 @@ class RequestClient:
             send=self.send,
         )
         response_headers = {key.decode(): value.decode() for key, value in self.header['headers']}
+        cookies = [(key, value) for key, value in self.header['headers'] if key.decode() == 'Set-Cookie']
         if response_headers['Content-Type'] == 'text/html; charset=utf-8':
             data = self.response.decode()
-            return HTMLResponse(data=data, status_code=self.header['status'], headers=response_headers)
+            response = HTMLResponse(data=data, status_code=self.header['status'], headers=response_headers)
 
         elif response_headers['Content-Type'] == 'text/plain; charset=utf-8':
             data = self.response.decode()
-            return PlainTextResponse(data=data, status_code=self.header['status'], headers=response_headers)
+            response = PlainTextResponse(data=data, status_code=self.header['status'], headers=response_headers)
 
         elif response_headers['Content-Type'] == 'application/octet-stream':
             data = self.response.decode()
-            return PlainTextResponse(data=data, status_code=self.header['status'], headers=response_headers)
+            response = PlainTextResponse(data=data, status_code=self.header['status'], headers=response_headers)
 
         else:
             data = json.loads(self.response or b'null')
-            return Response(data=data, status_code=self.header['status'], headers=response_headers)
+            response = Response(data=data, status_code=self.header['status'], headers=response_headers)
+        response.cookies = cookies
+        return response
 
 
 class APIClient:
@@ -78,27 +81,41 @@ class APIClient:
         self._app = app
 
     async def _send_request(
-            self,
-            path: str,
-            method: Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
-            payload: dict | None,
-            headers: dict,
-            query_params: dict,
+        self,
+        path: str,
+        method: Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+        payload: dict | None,
+        headers: dict,
+        query_params: dict,
     ) -> Response:
         request_client = RequestClient(app=self._app)
         return await request_client.request(
-                path=path,
-                method=method,
-                payload=payload,
-                headers=headers,
-                query_params=query_params or {},
-            )
+            path=path,
+            method=method,
+            payload=payload,
+            headers=headers,
+            query_params=query_params or {},
+        )
+
+    async def options(
+        self,
+        path: str,
+        headers: dict | None = None,
+        query_params: dict | None = None,
+    ) -> Response:
+        return await self._send_request(
+            path=path,
+            method='OPTIONS',
+            payload=None,
+            headers=headers or {},
+            query_params=query_params or {},
+        )
 
     async def get(
-            self,
-            path: str,
-            headers: dict | None = None,
-            query_params: dict | None = None,
+        self,
+        path: str,
+        headers: dict | None = None,
+        query_params: dict | None = None,
     ) -> Response:
         return await self._send_request(
             path=path,
@@ -109,12 +126,12 @@ class APIClient:
         )
 
     async def post(
-            self,
-            path: str,
-            payload: bytes | dict | None = None,
-            headers: dict | None = None,
-            query_params: dict | None = None,
-            content_type: str = 'application/json',
+        self,
+        path: str,
+        payload: bytes | dict | None = None,
+        headers: dict | None = None,
+        query_params: dict | None = None,
+        content_type: str = 'application/json',
     ) -> Response:
         headers = {'content-type': content_type} | (headers or {})
         return await self._send_request(
@@ -126,12 +143,12 @@ class APIClient:
         )
 
     async def put(
-            self,
-            path: str,
-            payload: bytes | dict | None = None,
-            headers: dict | None = None,
-            query_params: dict | None = None,
-            content_type: Literal['application/json', 'multipart/form-data'] = 'application/json',
+        self,
+        path: str,
+        payload: bytes | dict | None = None,
+        headers: dict | None = None,
+        query_params: dict | None = None,
+        content_type: Literal['application/json', 'multipart/form-data'] = 'application/json',
     ) -> Response:
         headers = {'content-type': content_type} | (headers or {})
         return await self._send_request(
@@ -143,12 +160,12 @@ class APIClient:
         )
 
     async def patch(
-            self,
-            path: str,
-            payload: bytes | dict | None = None,
-            headers: dict | None = None,
-            query_params: dict | None = None,
-            content_type: Literal['application/json', 'multipart/form-data'] = 'application/json',
+        self,
+        path: str,
+        payload: bytes | dict | None = None,
+        headers: dict | None = None,
+        query_params: dict | None = None,
+        content_type: Literal['application/json', 'multipart/form-data'] = 'application/json',
     ) -> Response:
         headers = {'content-type': content_type} | (headers or {})
         return await self._send_request(
@@ -160,10 +177,10 @@ class APIClient:
         )
 
     async def delete(
-            self,
-            path: str,
-            headers: dict | None = None,
-            query_params: dict | None = None,
+        self,
+        path: str,
+        headers: dict | None = None,
+        query_params: dict | None = None,
     ) -> Response:
         return await self._send_request(
             path=path,
@@ -183,15 +200,13 @@ class WebsocketClient:
         self.responses.append(data)
 
     async def receive(self):
-        return {
-            'type': 'websocket.connect'
-        }
+        return {'type': 'websocket.connect'}
 
     def connect(
-            self,
-            path: str,
-            headers: dict | None = None,
-            query_params: dict | None = None,
+        self,
+        path: str,
+        headers: dict | None = None,
+        query_params: dict | None = None,
     ):
         headers = [(k.encode(), str(v).encode()) for k, v in (headers or {}).items()]
         if not path.startswith('/'):
@@ -210,13 +225,13 @@ class WebsocketClient:
             'query_string': query_params.encode(),
             'headers': headers,
             'subprotocols': [],
-            'state': {}
+            'state': {},
         }
         asyncio.run(
             self.app(
                 scope=scope,
                 receive=self.receive,
                 send=self.send,
-            )
+            ),
         )
         return self.responses