panther 5.0.0b3__py3-none-any.whl → 5.0.0b5__py3-none-any.whl

panther/panel/views.py

@@ -4,22 +4,24 @@ from panther import status
 from panther.app import API, GenericAPI
 from panther.configs import config
 from panther.db.models import BaseUser
-from panther.exceptions import RedirectAPIError, AuthenticationAPIError
+from panther.exceptions import AuthenticationAPIError, RedirectAPIError
 from panther.panel.middlewares import RedirectToSlashMiddleware
-from panther.panel.utils import get_models, clean_model_schema
+from panther.panel.utils import clean_model_schema, get_models
 from panther.permissions import BasePermission
 from panther.request import Request
-from panther.response import TemplateResponse, Response, Cookie, RedirectResponse
+from panther.response import Cookie, RedirectResponse, Response, TemplateResponse
 
 logger = logging.getLogger('panther')
 
 
 class AdminPanelPermission(BasePermission):
+    """We didn't want to change AUTHENTICATION class of user, so we use permission class for this purpose."""
+
     @classmethod
     async def authorization(cls, request: Request) -> bool:
         from panther.authentications import CookieJWTAuthentication
 
-        try:  # We don't want to set AUTHENTICATION class, so we have to use permission classes
+        try:
             await CookieJWTAuthentication.authentication(request=request)
             return True
         except AuthenticationAPIError:
@@ -50,22 +52,14 @@ class LoginView(GenericAPI):
                 status_code=status.HTTP_400_BAD_REQUEST,
                 context={'error': 'Authentication Error'},
             )
-        tokens = JWTAuthentication.login(user.id)
+        tokens = await JWTAuthentication.login(user=user)
         return RedirectResponse(
             url=request.query_params.get('redirect_to', '..'),
             status_code=status.HTTP_302_FOUND,
             set_cookies=[
-                Cookie(
-                    key='access_token',
-                    value=tokens['access_token'],
-                    max_age=config.JWT_CONFIG.life_time
-                ),
-                Cookie(
-                    key='refresh_token',
-                    value=tokens['refresh_token'],
-                    max_age=config.JWT_CONFIG.refresh_life_time
-                )
-            ]
+                Cookie(key='access_token', value=tokens['access_token'], max_age=config.JWT_CONFIG.life_time),
+                Cookie(key='refresh_token', value=tokens['refresh_token'], max_age=config.JWT_CONFIG.refresh_life_time),
+            ],
         )
 
 
@@ -93,7 +87,7 @@ class TableView(GenericAPI):
                 'fields': clean_model_schema(model.schema()),
                 'tables': get_models(),
                 'records': Response.prepare_data(data),
-            }
+            },
         )
 
 
@@ -108,7 +102,7 @@ class CreateView(GenericAPI):
             context={
                 'fields': clean_model_schema(model.schema()),
                 'tables': get_models(),
-            }
+            },
         )
 
     async def post(self, request: Request, index: int):
@@ -129,10 +123,7 @@ class DetailView(GenericAPI):
         obj = await model.find_one_or_raise(id=document_id)
         return TemplateResponse(
             name='detail.html',
-            context={
-                'fields': clean_model_schema(model.schema()),
-                'data': obj.model_dump()
-            }
+            context={'fields': clean_model_schema(model.schema()), 'data': obj.model_dump()},
         )
 
     async def put(self, request: Request, index: int, document_id: str):

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,19 +82,20 @@ 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
-            Set the `max_age` to `0` if you want to delete a cookie
+        :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.pagination: Pagination | None = pagination
-        if isinstance(data, Cursor):
+        if isinstance(data, (Cursor, PantherDBCursor)):
             data = list(data)
-        self.initial_data = data
-        self.data = self.prepare_data(data=data)
-        self.status_code = self.check_status_code(status_code=status_code)
+        self.data = data
+        self.status_code = status_code
+        self.headers = {'Content-Type': self.content_type} | (headers or {})
+        self.pagination: Pagination | None = pagination
         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,78 +107,63 @@ 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
+
+    def __str__(self):
+        if len(data := str(self.data)) > 30:
+            data = f'{data:.27}...'
+        return f'Response(status_code={self.status_code}, data={data})'
+
+    __repr__ = __str__
 
     @property
     def body(self) -> bytes:
+        def default(obj: Any):
+            if isinstance(obj, BaseModel):
+                return obj.model_dump()
+            raise TypeError(f'Type {type(obj)} not serializable')
+
         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
+        return json.dumps(self.data, default=default)
 
     @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"""
-        if isinstance(data, (int | float | str | bool | bytes | NoneType)):
-            return data
-
-        elif isinstance(data, dict):
-            return {key: cls.prepare_data(value) for key, value in data.items()}
-
-        elif issubclass(type(data), BaseModel):
-            return data.model_dump()
-
-        elif isinstance(data, IterableDataTypes):
-            return [cls.prepare_data(d) for d in data]
-
-        else:
-            msg = f'Invalid Response Type: {type(data)}'
-            raise TypeError(msg)
-
-    @classmethod
-    def check_status_code(cls, status_code: Any):
-        if not isinstance(status_code, int):
-            error = f'Response `status_code` Should Be `int`. (`{status_code}` is {type(status_code)})'
-            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}...'
-        return f'Response(status_code={self.status_code}, data={data})'
-
-    __repr__ = __str__
+    async def serialize_output(self, output_model: type[BaseModel]):
+        """Serializes response data using the given output_model."""
+
+        async def handle_output(obj):
+            output = output_model(**obj) if isinstance(obj, dict) else output_model(**obj.model_dump())
+            if hasattr(output_model, 'to_response'):
+                return await output.to_response(instance=obj, data=output.model_dump())
+            return output.model_dump()
+
+        if isinstance(self.data, dict) or isinstance(self.data, BaseModel):
+            return await handle_output(self.data)
+
+        if isinstance(self.data, IterableDataTypes):
+            results = []
+            for d in self.data:
+                if isinstance(d, dict) or isinstance(d, BaseModel):
+                    results.append(await handle_output(d))
+                else:
+                    msg = 'Type of Response data is not match with `output_model`.\n*hint: You may want to remove `output_model`'
+                    raise TypeError(msg)
+            return results
+
+        msg = 'Type of Response data is not match with `output_model`.\n*hint: You may want to remove `output_model`'
+        raise TypeError(msg)
 
 
 class StreamingResponse(Response):
@@ -181,27 +178,21 @@ class StreamingResponse(Response):
         if message['type'] == 'http.disconnect':
             self.connection_closed = True
 
-    def prepare_data(self, data: any) -> AsyncGenerator:
-        if isinstance(data, AsyncGenerator):
-            return data
-        elif isinstance(data, Generator):
-            return to_async_generator(data)
-        msg = f'Invalid Response Type: {type(data)}'
-        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:
+        if not isinstance(self.data, (Generator, AsyncGenerator)):
+            raise TypeError(f'Type {type(self.data)} is not streamable, should be `Generator` or `AsyncGenerator`.')
+
+        if isinstance(self.data, Generator):
+            self.data = to_async_generator(self.data)
+
         async for chunk in self.data:
             if isinstance(chunk, bytes):
                 yield chunk
@@ -210,8 +201,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 +236,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 +259,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 +288,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,30 +200,9 @@ class ModelSerializer(metaclass=MetaModelSerializer):
                 required_fields = ['first_name', 'last_name']  # Optional
                 optional_fields = ['age']  # Optional
     """
+
     model: type[BaseModel]
     request: Request
 
-    async def create(self, validated_data: dict):
-        """
-        validated_data = ModelSerializer.model_dump()
-        """
-        return await self.model.insert_one(validated_data)
-
-    async def update(self, instance: Model, validated_data: dict):
-        """
-        instance = UpdateAPI.object()
-        validated_data = ModelSerializer.model_dump()
-        """
-        await instance.update(validated_data)
-        return instance
-
-    async def partial_update(self, instance: Model, validated_data: dict):
-        """
-        instance = UpdateAPI.object()
-        validated_data = ModelSerializer.model_dump(exclude_none=True)
-        """
-        await instance.update(validated_data)
-        return instance
-
-    async def prepare_response(self, instance: Any, data: dict) -> dict:
+    async def to_response(self, instance: Any, data: dict) -> dict:
         return data