panther 3.8.2__py3-none-any.whl → 4.0.0__py3-none-any.whl

panther/response.py

@@ -1,11 +1,20 @@
+import asyncio
 from types import NoneType
+from typing import Generator, AsyncGenerator
 
 import orjson as json
 from pydantic import BaseModel as PydanticBaseModel
 from pydantic._internal._model_construction import ModelMetaclass
 
-ResponseDataTypes = list | tuple | set | dict | int | float | str | bool | bytes | NoneType | ModelMetaclass
-IterableDataTypes = list | tuple | set
+from panther import status
+from panther._utils import to_async_generator
+from panther.db.cursor import Cursor
+from pantherdb import Cursor as PantherDBCursor
+from panther.monitoring import Monitoring
+
+ResponseDataTypes = list | tuple | set | Cursor | PantherDBCursor | dict | int | float | str | bool | bytes | NoneType | ModelMetaclass
+IterableDataTypes = list | tuple | set | Cursor | PantherDBCursor
+StreamingDataTypes = Generator | AsyncGenerator
 
 
 class Response:
@@ -15,76 +24,96 @@ class Response:
         self,
         data: ResponseDataTypes = None,
         headers: dict | None = None,
-        status_code: int = 200,
+        status_code: int = status.HTTP_200_OK,
     ):
         """
-        :param data: should be int | float | dict | list | tuple | set | str | bool | bytes | NoneType
-            or instance of Pydantic.BaseModel
+        :param data: should be an instance of ResponseDataTypes
+        :param headers: should be dict of headers
         :param status_code: should be int
         """
-        self.data = self._clean_data_type(data)
-        self._check_status_code(status_code)
-        self._headers = headers
+        self.headers = headers or {}
+        self.data = self.prepare_data(data=data)
+        self.status_code = self.check_status_code(status_code=status_code)
 
     @property
     def body(self) -> bytes:
         if isinstance(self.data, bytes):
             return self.data
-        else:
-            return json.dumps(self.data)
+
+        if self.data is None:
+            return b''
+        return json.dumps(self.data)
 
     @property
     def headers(self) -> dict:
-        content_length = 0 if self.body == b'null' else len(self.body)
         return {
-            'content-type': self.content_type,
-            'content-length': content_length,
-            'access-control-allow-origin': '*',
-        } | (self._headers or {})
+            'Content-Type': self.content_type,
+            'Content-Length': len(self.body),
+            'Access-Control-Allow-Origin': '*',
+        } | self._headers
 
-    def _clean_data_type(self, data: any):
-        """Make sure the response data is only ResponseDataTypes or Iterable of ResponseDataTypes"""
-        if issubclass(type(data), PydanticBaseModel):
-            return data.model_dump()
+    @property
+    def bytes_headers(self) -> list[list[bytes]]:
+        return [[k.encode(), str(v).encode()] for k, v in (self.headers or {}).items()]
 
-        elif isinstance(data, IterableDataTypes):
-            return [self._clean_data_type(d) for d in data]
+    @headers.setter
+    def headers(self, headers: dict):
+        self._headers = headers
+
+    def prepare_data(self, 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: self._clean_data_type(value) for key, value in data.items()}
+            return {key: self.prepare_data(value) for key, value in data.items()}
 
-        elif isinstance(data, (int | float | str | bool | bytes | NoneType)):
-            return data
+        elif issubclass(type(data), PydanticBaseModel):
+            return data.model_dump()
+
+        elif isinstance(data, IterableDataTypes):
+            return [self.prepare_data(d) for d in data]
 
         else:
             msg = f'Invalid Response Type: {type(data)}'
             raise TypeError(msg)
 
-    def _check_status_code(self, status_code: any):
+    @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)})'
+            error = f'Response `status_code` Should Be `int`. (`{status_code}` is {type(status_code)})'
             raise TypeError(error)
-
-        self.status_code = status_code
-
-    def _clean_data_with_output_model(self, output_model: ModelMetaclass | None):
-        if self.data and output_model:
-            self.data = self._serialize_with_output_model(self.data, output_model=output_model)
+        return status_code
 
     @classmethod
-    def _serialize_with_output_model(cls, data: any, /, output_model: ModelMetaclass):
+    def apply_output_model(cls, data: any, /, output_model: ModelMetaclass):
+        """This method is called in API.__call__"""
         # Dict
         if isinstance(data, dict):
+            for field_name, field in output_model.model_fields.items():
+                if field.validation_alias and field_name in data:
+                    data[field.validation_alias] = data.pop(field_name)
             return output_model(**data).model_dump()
 
         # Iterable
         if isinstance(data, IterableDataTypes):
-            return [cls._serialize_with_output_model(d, output_model=output_model) for d in data]
+            return [cls.apply_output_model(d, output_model=output_model) for d in data]
 
         # Str | Bool | Bytes
         msg = 'Type of Response data is not match with `output_model`.\n*hint: You may want to remove `output_model`'
         raise TypeError(msg)
 
+    async def send_headers(self, send, /):
+        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, /, monitoring: Monitoring):
+        await self.send_headers(send)
+        await self.send_body(send, receive)
+        await monitoring.after(self.status_code)
+
     def __str__(self):
         if len(data := str(self.data)) > 30:
             data = f'{data:.27}...'
@@ -93,6 +122,57 @@ class Response:
     __repr__ = __str__
 
 
+class StreamingResponse(Response):
+    content_type = 'application/octet-stream'
+
+    def __init__(self, *args, **kwargs):
+        self.connection_closed = False
+        super().__init__(*args, **kwargs)
+
+    async def listen_to_disconnection(self, receive):
+        message = await receive()
+        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
+
+    @property
+    async def body(self) -> AsyncGenerator:
+        async for chunk in self.data:
+            if isinstance(chunk, bytes):
+                yield chunk
+            elif chunk is None:
+                yield b''
+            else:
+                yield json.dumps(chunk)
+
+    async def send_body(self, send, receive, /):
+        asyncio.create_task(self.listen_to_disconnection(receive))
+        async for chunk in self.body:
+            if self.connection_closed:
+                break
+            await send({'type': 'http.response.body', 'body': chunk, 'more_body': True})
+        else:
+            await send({'type': 'http.response.body', 'body': b'', 'more_body': False})
+
+
 class HTMLResponse(Response):
     content_type = 'text/html; charset=utf-8'
 

panther/routings.py

@@ -1,4 +1,3 @@
-import logging
 import re
 from collections import Counter
 from collections.abc import Callable, Mapping, MutableMapping
@@ -6,9 +5,7 @@ from copy import deepcopy
 from functools import partial, reduce
 
 from panther.configs import config
-
-
-logger = logging.getLogger('panther')
+from panther.exceptions import PantherError
 
 
 def flatten_urls(urls: dict) -> dict:
@@ -28,20 +25,17 @@ def _flattening_urls(data: dict | Callable, url: str = ''):
         url = url.removeprefix('/')
 
         # Collect it, if it doesn't have problem
-        if _is_url_endpoint_valid(url=url, endpoint=data):
-            yield url, data
+        _is_url_endpoint_valid(url=url, endpoint=data)
+        yield url, data
 
 
-def _is_url_endpoint_valid(url: str, endpoint: Callable) -> bool:
+def _is_url_endpoint_valid(url: str, endpoint: Callable):
     if endpoint is ...:
-        logger.error(f"URL Can't Point To Ellipsis. ('{url}' -> ...)")
+        raise PantherError(f"URL Can't Point To Ellipsis. ('{url}' -> ...)")
     elif endpoint is None:
-        logger.error(f"URL Can't Point To None. ('{url}' -> 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):
-        logger.error(f"URL Is Not Valid. --> '{url}'")
-    else:
-        return True
-    return False
+        raise PantherError(f"URL Is Not Valid. --> '{url}'")
 
 
 def finalize_urls(urls: dict) -> dict:
@@ -60,7 +54,33 @@ def finalize_urls(urls: dict) -> dict:
             else:
                 path = {single_path: path or endpoint}
         urls_list.append(path)
-    return _merge(*urls_list) if urls_list else {}
+    final_urls = _merge(*urls_list) if urls_list else {}
+    check_urls_path_variables(final_urls)
+    return final_urls
+
+
+def check_urls_path_variables(urls: dict, path: str = '', ) -> None:
+    middle_route_error = []
+    last_route_error = []
+    for key, value in urls.items():
+        new_path = f'{path}/{key}'
+
+        if isinstance(value, dict):
+            if key.startswith('<'):
+                middle_route_error.append(new_path)
+            check_urls_path_variables(value, path=new_path)
+        elif key.startswith('<'):
+            last_route_error.append(new_path)
+
+    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}")
+
+    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}")
 
 
 def _merge(destination: MutableMapping, *sources) -> MutableMapping:
@@ -106,67 +126,64 @@ ENDPOINT_NOT_FOUND = (None, '')
 
 
 def find_endpoint(path: str) -> tuple[Callable | None, str]:
-    urls = config['urls']
+    urls = config.URLS
 
-    if (location := path.find('?')) != -1:
-        path = path[:location]
-    path = path.removesuffix('/').removeprefix('/')  # 'user/list'
-    paths = path.split('/')  # ['user', 'list']
-    paths_len = len(paths)
+    # 'user/list/?name=ali' --> 'user/list/' --> 'user/list' --> ['user', 'list']
+    parts = path.split('?')[0].strip('/').split('/')
+    paths_len = len(parts)
 
-    found_path = ''
-    for i, split_path in enumerate(paths):
+    found_path = []
+    for i, part in enumerate(parts):
         last_path = bool((i + 1) == paths_len)
-        found = urls.get(split_path)
-
-        # `found` is callable
-        if last_path and callable(found):
-            found_path += f'{split_path}/'
-            return found, found_path
-
-        # `found` is dict
-        if isinstance(found, dict):
-            found_path += f'{split_path}/'
-            if last_path and callable(endpoint := found.get('')):
-                return endpoint, found_path
-
-            urls = found
-            continue
-
-        # `found` is None
-        for key, value in urls.items():
-            if not key.startswith('<'):
-                continue
-
-            elif last_path:
-                if callable(value):
-                    found_path += f'{key}/'
-                    return value, found_path
-                elif isinstance(value, dict) and '' in value:
-                    found_path += f'{key}/'
-                    return value[''], found_path
+        found = urls.get(part)
+
+        if last_path:
+            # `found` is callable
+            if callable(found):
+                found_path.append(part)
+                return found, '/'.join(found_path)
+
+            # `found` is dict
+            if isinstance(found, dict) and (endpoint := found.get('')):
+                if callable(endpoint):
+                    found_path.append(part)
+                    return endpoint, '/'.join(found_path)
                 else:
                     return ENDPOINT_NOT_FOUND
 
-            elif isinstance(value, dict):
-                urls = value
-                found_path += f'{key}/'
-                break
+            # `found` is None
+            for key, value in urls.items():
+                if key.startswith('<'):
+                    if callable(value):
+                        found_path.append(key)
+                        return value, '/'.join(found_path)
 
-            else:
-                return ENDPOINT_NOT_FOUND
+                    elif isinstance(value, dict) and (endpoint := value.get('')):
+                        if callable(endpoint):
+                            found_path.append(key)
+                            return endpoint, '/'.join(found_path)
+                        else:
+                            return ENDPOINT_NOT_FOUND
 
-        else:
             return ENDPOINT_NOT_FOUND
 
-    return ENDPOINT_NOT_FOUND
+        # `found` is dict
+        elif isinstance(found, dict):
+            found_path.append(part)
+            urls = found
+            continue
 
+        # `found` is callable
+        elif callable(found):
+            return ENDPOINT_NOT_FOUND
 
-def collect_path_variables(request_path: str, found_path: str) -> dict:
-    found_path = found_path.removesuffix('/').removeprefix('/')
-    request_path = request_path.removesuffix('/').removeprefix('/')
-    path_variables = {}
-    for f_path, r_path in zip(found_path.split('/'), request_path.split('/')):
-        if f_path.startswith('<'):
-            path_variables[f_path[1:-1]] = r_path
-    return path_variables
+        else:
+            # `found` is None
+            for key, value in urls.items():
+                if key.startswith('<'):
+                    if isinstance(value, dict):
+                        found_path.append(key)
+                        urls = value
+                        break
+            else:
+                return ENDPOINT_NOT_FOUND

panther/serializer.py

@@ -1,47 +1,228 @@
-from pydantic import create_model
+import typing
+from typing import TypeVar, Type
+
+from pydantic import create_model, BaseModel, ConfigDict
+from pydantic.fields import FieldInfo, Field
 from pydantic_core._pydantic_core import PydanticUndefined
 
+from panther.db import Model
+from panther.request import Request
+
+
+class MetaModelSerializer:
+    KNOWN_CONFIGS = ['model', 'fields', 'exclude', 'required_fields', 'optional_fields']
 
-class ModelSerializer:
-    def __new__(cls, *args, model=None, **kwargs):
-        # Check `metaclass`
-        if len(args) == 0:
-            address = f'{cls.__module__}.{cls.__name__}'
-            msg = f"you should not inherit the 'ModelSerializer', you should use it as 'metaclass' -> {address}"
-            raise TypeError(msg)
+    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')
+            namespace['__annotations__'].pop('request')
+            cls.model_serializer = type(cls_name, (), namespace)
+            return super().__new__(cls)
 
-        model_name = args[0]
-        data = args[2]
-        address = f'{data["__module__"]}.{model_name}'
+        # 1. Initial Check
+        cls.check_config(cls_name=cls_name, namespace=namespace)
+        config = namespace.pop('Config')
+
+        # 2. Collect `Fields`
+        field_definitions = cls.collect_fields(config=config, namespace=namespace)
+
+        # 3. Collect `pydantic.model_config`
+        model_config = cls.collect_model_config(config=config, namespace=namespace)
+        namespace |= {'model_config': model_config}
+
+        # 4. Create a serializer
+        return create_model(
+            __model_name=cls_name,
+            __module__=namespace['__module__'],
+            __validators__=namespace,
+            __base__=(cls.model_serializer, BaseModel),
+            model=(typing.ClassVar[type[BaseModel]], config.model),
+            request=(Request, Field(None, exclude=True)),
+            **field_definitions
+        )
+
+    @classmethod
+    def check_config(cls, cls_name: str, namespace: dict) -> None:
+        module = namespace['__module__']
+        address = f'{module}.{cls_name}'
+
+        # Check `Config`
+        if (config := namespace.get('Config')) is None:
+            msg = f'`class Config` is required in {address}.'
+            raise AttributeError(msg) from None
 
         # Check `model`
-        if model is None:
-            msg = f"'model' required while using 'ModelSerializer' metaclass -> {address}"
-            raise AttributeError(msg)
+        if (model := getattr(config, 'model', None)) is None:
+            msg = f'`{cls_name}.Config.model` is required.'
+            raise AttributeError(msg) from None
+
+        # Check `model` type
+        try:
+            if not issubclass(model, Model):
+                msg = f'`{cls_name}.Config.model` is not subclass of `panther.db.Model`.'
+                raise AttributeError(msg) from None
+        except TypeError:
+            msg = f'`{cls_name}.Config.model` is not subclass of `panther.db.Model`.'
+            raise AttributeError(msg) from None
+
         # Check `fields`
-        if 'fields' not in data:
-            msg = f"'fields' required while using 'ModelSerializer' metaclass. -> {address}"
+        if not hasattr(config, 'fields'):
+            msg = f'`{cls_name}.Config.fields` is required.'
             raise AttributeError(msg) from None
 
-        model_fields = model.model_fields
-        field_definitions = {}
+        if config.fields != '*':
+            for field_name in config.fields:
+                if field_name == '*':
+                    msg = f"`{cls_name}.Config.fields.{field_name}` is not valid. Did you mean `fields = '*'`"
+                    raise AttributeError(msg) from None
+
+                if field_name not in model.model_fields:
+                    msg = f'`{cls_name}.Config.fields.{field_name}` is not in `{model.__name__}.model_fields`'
+                    raise AttributeError(msg) from None
+
+        # Check `required_fields`
+        if not hasattr(config, 'required_fields'):
+            config.required_fields = []
+
+        if config.required_fields != '*':
+            for required in config.required_fields:
+                if required not in config.fields:
+                    msg = f'`{cls_name}.Config.required_fields.{required}` should be in `Config.fields` too.'
+                    raise AttributeError(msg) from None
 
-        # Collect `fields`
-        for field_name in data['fields']:
-            if field_name not in model_fields:
-                msg = f"'{field_name}' is not in '{model.__name__}' -> {address}"
+        # Check `optional_fields`
+        if not hasattr(config, 'optional_fields'):
+            config.optional_fields = []
+
+        if config.optional_fields != '*':
+            for optional in config.optional_fields:
+                if optional not in config.fields:
+                    msg = f'`{cls_name}.Config.optional_fields.{optional}` should be in `Config.fields` too.'
+                    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 != [])
+        ):
+            msg = (
+                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
+        for optional in config.optional_fields:
+            for required in config.required_fields:
+                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"
+                    )
+                    raise AttributeError(msg) from None
+
+        # Check `exclude`
+        if not hasattr(config, 'exclude'):
+            config.exclude = []
+
+        for field_name in config.exclude:
+            if field_name not in model.model_fields:
+                msg = f'`{cls_name}.Config.exclude.{field_name}` is not valid.'
                 raise AttributeError(msg) from None
-            field_definitions[field_name] = (model_fields[field_name].annotation, model_fields[field_name])
 
-        # Change `required_fields
-        for required in data.get('required_fields', []):
-            if required not in field_definitions:
-                msg = f"'{required}' is in 'required_fields' but not in 'fields' -> {address}"
+            if config.fields != '*' and field_name not in config.fields:
+                msg = f'`{cls_name}.Config.exclude.{field_name}` is not defined in `Config.fields`.'
                 raise AttributeError(msg) from None
-            field_definitions[required][1].default = PydanticUndefined
 
-        # Create Model
-        return create_model(
-            __model_name=model_name,
-            **field_definitions
-        )
+    @classmethod
+    def collect_fields(cls, config: typing.Callable, namespace: dict) -> dict:
+        field_definitions = {}
+
+        # Define `fields`
+        if config.fields == '*':
+            for field_name, field in config.model.model_fields.items():
+                field_definitions[field_name] = (field.annotation, field)
+        else:
+            for field_name in config.fields:
+                field_definitions[field_name] = (
+                    config.model.model_fields[field_name].annotation,
+                    config.model.model_fields[field_name]
+                )
+
+        # Apply `exclude`
+        for field_name in config.exclude:
+            del field_definitions[field_name]
+
+        # Apply `required_fields`
+        if config.required_fields == '*':
+            for value in field_definitions.values():
+                value[1].default = PydanticUndefined
+        else:
+            for field_name in config.required_fields:
+                field_definitions[field_name][1].default = PydanticUndefined
+
+        # Apply `optional_fields`
+        if config.optional_fields == '*':
+            for value in field_definitions.values():
+                value[1].default = value[0]()
+        else:
+            for field_name in config.optional_fields:
+                field_definitions[field_name][1].default = field_definitions[field_name][0]()
+
+        # Collect and Override `Class Fields`
+        for key, value in namespace.pop('__annotations__', {}).items():
+            field_info = namespace.pop(key, FieldInfo(annotation=value))
+            field_definitions[key] = (value, field_info)
+
+        return field_definitions
+
+    @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}
+
+
+class ModelSerializer(metaclass=MetaModelSerializer):
+    """
+    Doc:
+        https://pantherpy.github.io/serializer/#style-2-model-serializer
+    Example:
+        class PersonSerializer(ModelSerializer):
+            class Meta:
+                model = Person
+                fields = '*'
+                exclude = ['created_date']  # Optional
+                required_fields = ['first_name', 'last_name']  # Optional
+                optional_fields = ['age']  # Optional
+    """
+    model: type[BaseModel]
+    request: Request
+
+    async def create(self, validated_data: dict) -> Model:
+        """
+        validated_data = ModelSerializer.model_dump()
+        """
+        return await self.model.insert_one(validated_data)
+
+    async def update(self, instance: Model, validated_data: dict) -> Model:
+        """
+        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) -> Model:
+        """
+        instance = UpdateAPI.object()
+        validated_data = ModelSerializer.model_dump(exclude_none=True)
+        """
+        await instance.update(validated_data)
+        return instance