panther 4.3.7__py3-none-any.whl → 5.0.0b2__py3-none-any.whl

panther/panel/utils.py

@@ -1,6 +1,96 @@
+from collections import defaultdict
+
+from panther.configs import config
 from panther.db.models import Model
 
 
+def _ref_name(ref: str) -> str:
+    obj_name = ref.rsplit('/', maxsplit=1)[1]
+    return f'${obj_name}'
+
+
+def clean_model_schema(schema: dict) -> dict:
+    """
+    Example:
+        {
+        'title': 'Author',
+        '$': {
+            'Book': {
+                'title': 'Book',
+                'fields': {
+                    'title': {'title': 'Title', 'type': ['string'], 'required': True},
+                    'pages_count': {'title': 'Pages Count', 'type': ['integer'], 'required': True},
+                    'readers': {'title': 'Readers', 'type': ['array', 'null'], 'items': '$Person', 'default': None, 'required': False},
+                    'co_owner': {'type': ['$Person', 'null'], 'default': None, 'required': False}
+                }
+            },
+            'Parent': {
+                'title': 'Parent',
+                'fields': {
+                    'name': {'title': 'Name', 'type': ['string'], 'required': True},
+                    'age': {'title': 'Age', 'type': ['string'], 'required': True},
+                    'has_child': {'title': 'Has Child', 'type': ['boolean'], 'required': True}
+                }
+            },
+            'Person': {
+                'title': 'Person',
+                'fields': {
+                    'age': {'title': 'Age', 'type': ['integer'], 'required': True},
+                    'real_name': {'title': 'Real Name', 'type': ['string'], 'required': True},
+                    'parent': {'type': '$Parent', 'required': True},
+                    'is_alive': {'title': 'Is Alive', 'type': ['boolean'], 'required': True},
+                    'friends': {'title': 'Friends', 'type': ['array'], 'items': '$Person', 'required': True}
+                }
+            }
+        },
+        'fields': {
+            '_id': {'title': ' Id', 'type': ['string', 'null'], 'default': None, 'required': False},
+            'name': {'title': 'Name', 'type': ['string'], 'required': True},
+            'person': {'type': ['$Person', 'null'], 'default': None, 'required': False},
+            'books': {'title': 'Books', 'type': ['array'], 'items': '$Book', 'required': True},
+            'is_male': {'title': 'Is Male', 'type': ['boolean', 'null'], 'required': True}
+        }
+    }
+    """
+
+    result = defaultdict(dict)
+    result['title'] = schema['title']
+    if '$defs' in schema:
+        for sk, sv in schema['$defs'].items():
+            result['$'][sk] = clean_model_schema(sv)
+
+    for k, v in schema['properties'].items():
+        result['fields'][k] = {}
+        if 'title' in v:
+            result['fields'][k]['title'] = v['title']
+
+        if 'type' in v:
+            result['fields'][k]['type'] = [v['type']]
+
+        if 'anyOf' in v:
+            result['fields'][k]['type'] = [i['type'] if 'type' in i else _ref_name(i['$ref']) for i in v['anyOf']]
+            if 'array' in result['fields'][k]['type']:
+                # One of them was array, so add the `items` field
+                for t in v['anyOf']:
+                    if 'items' in t:
+                        result['fields'][k]['items'] = _ref_name(t['items']['$ref'])
+
+        if 'default' in v:
+            result['fields'][k]['default'] = v['default']
+
+        if '$ref' in v:  # For obj
+            result['fields'][k]['type'] = _ref_name(v['$ref'])
+
+        if 'items' in v:  # For array
+            result['fields'][k]['items'] = _ref_name(v['items']['$ref'])
+
+        result['fields'][k]['required'] = k in schema.get('required', [])
+
+    # Cast it to have a more clear stdout
+    return dict(result)
+
+
+# TODO: Remove this
 def get_model_fields(model):
     result = {}
 
@@ -15,3 +105,11 @@ def get_model_fields(model):
         else:
             result[k] = getattr(v.annotation, '__name__', str(v.annotation))
     return result
+
+
+def get_models():
+    return [{
+        'index': i,
+        'name': model.__name__,
+        'module': model.__module__,
+    } for i, model in enumerate(config.MODELS)]

panther/panel/views.py

@@ -0,0 +1,143 @@
+import logging
+
+from panther import status
+from panther.app import API, GenericAPI
+from panther.authentications import JWTAuthentication, CookieJWTAuthentication
+from panther.configs import config
+from panther.db.models import BaseUser
+from panther.exceptions import RedirectAPIError, AuthenticationAPIError
+from panther.panel.middlewares import RedirectToSlashMiddleware
+from panther.panel.utils import get_models, clean_model_schema
+from panther.permissions import BasePermission
+from panther.request import Request
+from panther.response import TemplateResponse, Response, Cookie, RedirectResponse
+
+logger = logging.getLogger('panther')
+
+
+class AdminPanelPermission(BasePermission):
+    @classmethod
+    async def authorization(cls, request: Request) -> bool:
+        try:  # We don't want to set AUTHENTICATION class, so we have to use permission classes
+            await CookieJWTAuthentication.authentication(request=request)
+            return True
+        except AuthenticationAPIError:
+            raise RedirectAPIError(url=f'login?redirect_to={request.path}')
+
+
+class LoginView(GenericAPI):
+    middlewares = [RedirectToSlashMiddleware]
+
+    def get(self, request: Request):
+        return TemplateResponse(name='login.html')
+
+    async def post(self, request: Request):
+        user: BaseUser = await config.USER_MODEL.find_one({config.USER_MODEL.USERNAME_FIELD: request.data['username']})
+        if user is None:
+            logger.debug('User not found.')
+            return TemplateResponse(
+                name='login.html',
+                status_code=status.HTTP_400_BAD_REQUEST,
+                context={'error': 'Authentication Error'},
+            )
+        if user.check_password(password=request.data['password']) is False:
+            logger.debug('Password is incorrect.')
+            return TemplateResponse(
+                name='login.html',
+                status_code=status.HTTP_400_BAD_REQUEST,
+                context={'error': 'Authentication Error'},
+            )
+        tokens = JWTAuthentication.login(user.id)
+        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
+                )
+            ]
+        )
+
+
+class HomeView(GenericAPI):
+    permissions = [AdminPanelPermission]
+
+    def get(self):
+        return TemplateResponse(name='home.html', context={'tables': get_models()})
+
+
+class TableView(GenericAPI):
+    permissions = [AdminPanelPermission]
+    middlewares = [RedirectToSlashMiddleware]
+
+    async def get(self, request: Request, index: int):
+        model = config.MODELS[index]
+        if data := await model.find():
+            data = data
+        else:
+            data = []
+
+        return TemplateResponse(
+            name='table.html',
+            context={
+                'fields': clean_model_schema(model.schema()),
+                'tables': get_models(),
+                'records': Response.prepare_data(data),
+            }
+        )
+
+
+class CreateView(GenericAPI):
+    permissions = [AdminPanelPermission]
+    middlewares = [RedirectToSlashMiddleware]
+
+    async def get(self, request: Request, index: int):
+        model = config.MODELS[index]
+        return TemplateResponse(
+            name='create.html',
+            context={
+                'fields': clean_model_schema(model.schema()),
+                'tables': get_models(),
+            }
+        )
+
+    async def post(self, request: Request, index: int):
+        model = config.MODELS[index]
+        validated_data = API.validate_input(model=model, request=request)
+        instance = await model.insert_one(validated_data.model_dump())
+        if issubclass(model, BaseUser):
+            await instance.set_password(password=instance.password)
+        return instance
+
+
+class DetailView(GenericAPI):
+    permissions = [AdminPanelPermission]
+    middlewares = [RedirectToSlashMiddleware]
+
+    async def get(self, index: int, document_id: str):
+        model = config.MODELS[index]
+        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()
+            }
+        )
+
+    async def put(self, request: Request, index: int, document_id: str):
+        model = config.MODELS[index]
+        validated_data = API.validate_input(model=model, request=request)
+        return await model.update_one({'id': document_id}, validated_data.model_dump())
+
+    async def delete(self, index: int, document_id: str):
+        model = config.MODELS[index]
+        await model.delete_one(id=document_id)
+        return Response(status_code=status.HTTP_204_NO_CONTENT)

panther/request.py

@@ -1,5 +1,6 @@
 import logging
 from typing import Literal, Callable
+from urllib.parse import parse_qsl
 
 import orjson as json
 
@@ -26,6 +27,8 @@ class Request(BaseRequest):
             match (self.headers.content_type or '').split('; boundary='):
                 case ['' | 'application/json']:
                     self._data = json.loads(self.__body or b'{}')
+                case ['application/x-www-form-urlencoded']:
+                    self._data = {k.decode(): v.decode() for k, v in parse_qsl(self.__body)}
                 case ['multipart/form-data', boundary]:
                     self._data = read_multipart_form_data(boundary=boundary, body=self.__body)
                 case [unknown]:

panther/response.py

@@ -1,7 +1,9 @@
 import asyncio
+from dataclasses import dataclass
+from http import cookies
 from sys import version_info
 from types import NoneType
-from typing import Generator, AsyncGenerator, Any, Type
+from typing import Generator, AsyncGenerator, Any, Type, Literal
 
 if version_info >= (3, 11):
     from typing import LiteralString
@@ -10,7 +12,6 @@ else:
 
     LiteralString = TypeVar('LiteralString')
 
-
 import orjson as json
 from pydantic import BaseModel
 
@@ -19,7 +20,6 @@ from panther.configs import config
 from panther._utils import to_async_generator
 from panther.db.cursor import Cursor
 from pantherdb import Cursor as PantherDBCursor
-from panther.monitoring import Monitoring
 from panther.pagination import Pagination
 
 ResponseDataTypes = list | tuple | set | Cursor | PantherDBCursor | dict | int | float | str | bool | bytes | NoneType | Type[BaseModel]
@@ -27,30 +27,75 @@ IterableDataTypes = list | tuple | set | Cursor | PantherDBCursor
 StreamingDataTypes = Generator | AsyncGenerator
 
 
+@dataclass(slots=True)
+class Cookie:
+    """
+    path: [Optional] Indicates the path that must exist in the requested URL for the browser to send the Cookie header.
+        Default is `/`
+    domain: [Optional] Defines the host to which the cookie will be sent.
+        Default is the host of the current document URL, not including subdomains.
+    max_age: [Optional] Indicates the number of seconds until the cookie expires.
+        A zero or negative number will expire the cookie immediately.
+    secure: [Optional] Indicates that the cookie is sent to the server
+        only when a request is made with the https: scheme (except on localhost)
+    httponly: [Optional] Forbids JavaScript from accessing the cookie,
+        for example, through the `Document.cookie` property.
+    samesite: [Optional] Controls whether a cookie is sent with cross-site requests or not,
+        `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
+    max_age: int = None
+    secure: bool = False
+    httponly: bool = False
+    samesite: Literal['none', 'lax', 'strict'] = 'lax'
+    path: str = '/'
+
+
 class Response:
     content_type = 'application/json'
 
     def __init__(
         self,
         data: ResponseDataTypes = None,
-        headers: dict | None = None,
         status_code: int = status.HTTP_200_OK,
+        headers: dict | None = None,
         pagination: Pagination | None = None,
+        set_cookies: list[Cookie] | None = None
     ):
         """
         :param data: should be an instance of ResponseDataTypes
-        :param headers: should be dict of headers
         :param status_code: should be int
-        :param pagination: instance of Pagination or None
+        :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
         """
-        self.headers = headers or {}
+        headers = headers or {}
         self.pagination: Pagination | None = pagination
         if isinstance(data, Cursor):
             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.cookies = None
+        if set_cookies:
+            c = cookies.SimpleCookie()
+            for cookie in set_cookies:
+                c[cookie.key] = cookie.value
+                c[cookie.key]['path'] = cookie.path
+                c[cookie.key]['secure'] = cookie.secure
+                c[cookie.key]['httponly'] = cookie.httponly
+                c[cookie.key]['samesite'] = cookie.samesite
+                if cookie.domain is not None:
+                    c[cookie.key]['domain'] = cookie.domain
+                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:
@@ -70,26 +115,30 @@ class Response:
         } | self._headers
 
     @property
-    def bytes_headers(self) -> list[list[bytes]]:
-        return [[k.encode(), str(v).encode()] for k, v in (self.headers or {}).items()]
+    def bytes_headers(self) -> list[tuple[bytes]]:
+        result = [(k.encode(), str(v).encode()) for k, v in (self.headers or {}).items()]
+        if self.cookies:
+            result.extend(self.cookies)
+        return result
 
     @headers.setter
     def headers(self, headers: dict):
         self._headers = headers
 
-    def prepare_data(self, data: Any):
+    @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: self.prepare_data(value) for key, value in data.items()}
+            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 [self.prepare_data(d) for d in data]
+            return [cls.prepare_data(d) for d in data]
 
         else:
             msg = f'Invalid Response Type: {type(data)}'
@@ -102,51 +151,15 @@ class Response:
             raise TypeError(error)
         return status_code
 
-    async def apply_output_model(self, output_model: Type[BaseModel]):
-        """This method is called in API.__call__"""
-
-        # Dict
-        if isinstance(self.data, dict):
-            # Apply `validation_alias` (id -> _id)
-            for field_name, field in output_model.model_fields.items():
-                if field.validation_alias and field_name in self.data:
-                    self.data[field.validation_alias] = self.data.pop(field_name)
-            output = output_model(**self.data)
-            if hasattr(output_model, 'prepare_response'):
-                return await output.prepare_response(instance=self.initial_data, data=output.model_dump())
-            return output.model_dump()
-
-        # Iterable
-        results = []
-        if isinstance(self.data, IterableDataTypes):
-            for i, d in enumerate(self.data):
-                # Apply `validation_alias` (id -> _id)
-                for field_name, field in output_model.model_fields.items():
-                    if field.validation_alias and field_name in d:
-                        d[field.validation_alias] = d.pop(field_name)
-
-                output = output_model(**d)
-                if hasattr(output_model, 'prepare_response'):
-                    result = await output.prepare_response(instance=self.initial_data[i], data=output.model_dump())
-                else:
-                    result = output.model_dump()
-                results.append(result)
-            return results
-
-        # 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):
+    async def send(self, send, receive, /):
         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:
@@ -228,23 +241,31 @@ class PlainTextResponse(Response):
 
 
 class TemplateResponse(HTMLResponse):
+    """
+    You may want to declare `TEMPLATES_DIR` in your configs
+
+    Example:
+        TEMPLATES_DIR = 'templates/'
+            or
+        TEMPLATES_DIR = '.'
+    """
     def __init__(
         self,
         source: str | LiteralString | NoneType = None,
-        path: str | NoneType = None,
+        name: str | NoneType = None,
         context: dict | NoneType = None,
         headers: dict | NoneType = None,
         status_code: int = status.HTTP_200_OK,
     ):
         """
         :param source: should be a string
-        :param path: should be path of template file
+        :param name: name of the template file (should be with its extension, e.g. index.html)
         :param context: should be dict of items
         :param headers: should be dict of headers
         :param status_code: should be int
         """
-        if path:
-            template = config.JINJA_ENVIRONMENT.get_template(name=path)
+        if name:
+            template = config.JINJA_ENVIRONMENT.get_template(name=name)
         else:
             template = config.JINJA_ENVIRONMENT.from_string(source=source)
         super().__init__(
@@ -252,3 +273,20 @@ class TemplateResponse(HTMLResponse):
             headers=headers,
             status_code=status_code,
         )
+
+
+class RedirectResponse(Response):
+    def __init__(
+        self,
+        url: str,
+        headers: dict | None = None,
+        status_code: int = status.HTTP_307_TEMPORARY_REDIRECT,
+        set_cookies: list[Cookie] | None = None
+    ):
+        headers = headers or {}
+        headers['Location'] = url
+        super().__init__(
+            headers=headers,
+            status_code=status_code,
+            set_cookies=set_cookies,
+        )

panther/routings.py

@@ -18,6 +18,11 @@ def _flattening_urls(data: dict | Callable, url: str = ''):
         url = f'{url}/'
 
     if isinstance(data, dict):
+        if data == {}:
+            # User didn't define any endpoint,
+            #   So we just reserve this path so won't be used in path variables.
+            yield url.removeprefix('/'), {}
+
         for k, v in data.items():
             yield from _flattening_urls(v, f'{url}{k}')
     else:
@@ -144,8 +149,8 @@ def find_endpoint(path: str) -> tuple[Callable | None, str]:
                 return found, '/'.join(found_path)
 
             # `found` is dict
-            if isinstance(found, dict) and (endpoint := found.get('')):
-                if callable(endpoint):
+            if isinstance(found, dict):
+                if (endpoint := found.get('')) and callable(endpoint):
                     found_path.append(part)
                     return endpoint, '/'.join(found_path)
                 else:

panther/serializer.py

@@ -195,7 +195,7 @@ class ModelSerializer(metaclass=MetaModelSerializer):
         https://pantherpy.github.io/serializer/#style-2-model-serializer
     Example:
         class PersonSerializer(ModelSerializer):
-            class Meta:
+            class Config:
                 model = Person
                 fields = '*'
                 exclude = ['created_date']  # Optional

panther/utils.py

@@ -1,10 +1,11 @@
+import asyncio
 import base64
 import hashlib
 import logging
 import os
-import secrets
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timedelta
 from pathlib import Path
+from threading import Thread
 from typing import ClassVar
 
 import pytz
@@ -38,7 +39,10 @@ def load_env(env_file: str | Path, /) -> dict[str, str]:
                 key, value = striped_line.split('=', 1)
                 key = key.strip()
                 value = value.strip().strip('"\'')
-                variables[key] = value
+                if (boolean_value := value.lower()) in ['true', 'false']:
+                    variables[key] = bool(boolean_value == 'true')
+                else:
+                    variables[key] = value
 
                 # Load them as system environment variable
                 os.environ[key] = value
@@ -101,27 +105,31 @@ def scrypt(password: str, salt: bytes, digest: bool = False) -> str | bytes:
     return derived_key
 
 
-class ULID:
-    """https://github.com/ulid/spec"""
-
-    crockford_base32_characters = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'
-
-    @classmethod
-    def new(cls):
-        current_timestamp = int(datetime.now(timezone.utc).timestamp() * 1000)
-        epoch_bits = '{0:050b}'.format(current_timestamp)
-        random_bits = '{0:080b}'.format(secrets.randbits(80))
-        bits = epoch_bits + random_bits
-        return cls._generate(bits)
-
-    @classmethod
-    def _generate(cls, bits: str) -> str:
-        return ''.join(
-            cls.crockford_base32_characters[int(bits[i: i + 5], base=2)]
-            for i in range(0, 130, 5)
-        )
-
-
 def timezone_now():
-    tz = pytz.timezone(config.TIMEZONE)
-    return datetime.now(tz=tz)
+    return datetime.now(tz=pytz.timezone(config.TIMEZONE))
+
+
+def run_coroutine(coroutine):
+    try:
+        # Check if there's an event loop already running in this thread
+        asyncio.get_running_loop()
+    except RuntimeError:
+        # No event loop is running in this thread — safe to use asyncio.run
+        return asyncio.run(coroutine)
+
+    # Since we cannot block a running event loop with run_until_complete,
+    # we execute the coroutine in a separate thread with its own event loop.
+    result = []
+
+    def run_in_thread():
+        new_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(new_loop)
+        try:
+            result.append(new_loop.run_until_complete(coroutine))
+        finally:
+            new_loop.close()
+
+    thread = Thread(target=run_in_thread)
+    thread.start()
+    thread.join()
+    return result[0]

panther/websocket.py

@@ -9,6 +9,9 @@ class GenericWebsocket(Websocket):
     auth: bool = False
     permissions: list = []
 
+    def __init__(self, parent):
+        self.__dict__ = parent.__dict__.copy()
+
     async def connect(self, **kwargs):
         """
         Check your conditions then `accept()` or `close()` the connection