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

panther/events.py

@@ -2,31 +2,36 @@ import asyncio
 import logging
 
 from panther._utils import is_function_async
-from panther.configs import config
+from panther.utils import Singleton
 
 logger = logging.getLogger('panther')
 
 
-class Event:
-    @staticmethod
-    def startup(func):
-        config.STARTUPS.append(func)
+class Event(Singleton):
+    _startups = []
+    _shutdowns = []
+
+    @classmethod
+    def startup(cls, func):
+        cls._startups.append(func)
 
         def wrapper():
             return func()
+
         return wrapper
 
-    @staticmethod
-    def shutdown(func):
-        config.SHUTDOWNS.append(func)
+    @classmethod
+    def shutdown(cls, func):
+        cls._shutdowns.append(func)
 
         def wrapper():
             return func()
+
         return wrapper
 
-    @staticmethod
-    async def run_startups():
-        for func in config.STARTUPS:
+    @classmethod
+    async def run_startups(cls):
+        for func in cls._startups:
             try:
                 if is_function_async(func):
                     await func()
@@ -35,9 +40,9 @@ class Event:
             except Exception as e:
                 logger.error(f'{func.__name__}() startup event got error: {e}')
 
-    @staticmethod
-    def run_shutdowns():
-        for func in config.SHUTDOWNS:
+    @classmethod
+    def run_shutdowns(cls):
+        for func in cls._shutdowns:
             if is_function_async(func):
                 try:
                     asyncio.run(func())
@@ -48,3 +53,9 @@ class Event:
                     pass
             else:
                 func()
+
+    @classmethod
+    def clear(cls):
+        """Clear all stored events (useful for testing)"""
+        cls._startups.clear()
+        cls._shutdowns.clear()

panther/exceptions.py

@@ -13,12 +13,7 @@ class BaseError(Exception):
     detail: str | dict | list = 'Internal Server Error'
     status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR
 
-    def __init__(
-            self,
-            detail: str | dict | list = None,
-            status_code: int = None,
-            headers: dict = None
-    ):
+    def __init__(self, detail: str | dict | list = None, status_code: int = None, headers: dict = None):
         self.detail = detail or self.detail
         self.status_code = status_code or self.status_code
         self.headers = headers
@@ -81,5 +76,5 @@ class ThrottlingAPIError(APIError):
 
 class InvalidPathVariableAPIError(APIError):
     def __init__(self, value: str, variable_type: type):
-        detail = f"Path variable '{value}' should be '{variable_type.__name__}'"
+        detail = f'Path variable `{value}` is not `{variable_type.__name__}`'
         super().__init__(detail=detail, status_code=status.HTTP_400_BAD_REQUEST)

panther/file_handler.py

@@ -1,8 +1,8 @@
 from functools import cached_property
 
-from panther import status
 from pydantic import BaseModel, field_validator, model_serializer
 
+from panther import status
 from panther.exceptions import APIError
 
 

panther/generics.py

@@ -116,7 +116,8 @@ class ListAPI(GenericAPI, CursorRequired):
         if hasattr(self, 'sort_fields') and 'sort' in query_params:
             return [
                 (field, -1 if param[0] == '-' else 1)
-                for field in self.sort_fields for param in query_params['sort'].split(',')
+                for field in self.sort_fields
+                for param in query_params['sort'].split(',')
                 if field == param.removeprefix('-')
             ]
 
@@ -129,11 +130,13 @@ class CreateAPI(GenericAPI):
     input_model: type[ModelSerializer]
 
     async def post(self, request: Request, **kwargs):
-        instance = await request.validated_data.create(validated_data={
-            field: getattr(request.validated_data, field)
-            for field in request.validated_data.model_fields_set
-            if field != 'request'
-        })
+        instance = await request.validated_data.create(
+            validated_data={
+                field: getattr(request.validated_data, field)
+                for field in request.validated_data.model_fields_set
+                if field != 'request'
+            },
+        )
         return Response(data=instance, status_code=status.HTTP_201_CREATED)
 
 
@@ -146,7 +149,7 @@ class UpdateAPI(GenericAPI, ObjectRequired):
 
         await request.validated_data.update(
             instance=instance,
-            validated_data=request.validated_data.model_dump(by_alias=True)
+            validated_data=request.validated_data.model_dump(by_alias=True),
         )
         return Response(data=instance, status_code=status.HTTP_200_OK)
 
@@ -156,7 +159,7 @@ class UpdateAPI(GenericAPI, ObjectRequired):
 
         await request.validated_data.partial_update(
             instance=instance,
-            validated_data=request.validated_data.model_dump(exclude_none=True, by_alias=True)
+            validated_data=request.validated_data.model_dump(exclude_none=True, by_alias=True),
         )
         return Response(data=instance, status_code=status.HTTP_200_OK)
 

panther/logging.py

@@ -1,5 +1,6 @@
 import logging
 from pathlib import Path
+
 from panther.configs import config
 
 LOGS_DIR = config.BASE_DIR / 'logs'
@@ -64,5 +65,5 @@ LOGGING = {
             'handlers': ['default', 'query_file'],
             'level': 'DEBUG',
         },
-    }
+    },
 }

panther/main.py

@@ -8,13 +8,13 @@ from pathlib import Path
 import panther.logging
 from panther import status
 from panther._load_configs import *
-from panther._utils import traceback_message, reformat_code
+from panther._utils import reformat_code, traceback_message
 from panther.app import GenericAPI
 from panther.base_websocket import Websocket
 from panther.cli.utils import print_info
 from panther.configs import config
 from panther.events import Event
-from panther.exceptions import APIError, PantherError, NotFoundAPIError, BaseError, UpgradeRequiredError
+from panther.exceptions import APIError, BaseError, NotFoundAPIError, PantherError, UpgradeRequiredError
 from panther.request import Request
 from panther.response import Response
 from panther.routings import find_endpoint
@@ -35,6 +35,7 @@ class Panther:
                 If the configuration is defined in the current file, you can also set this to `__name__`.
             urls: A dictionary containing your URL routing.
                 If not provided, Panther will attempt to load `URLs` from the configs module.
+
         """
         self._configs_module_name = configs
         self._urls = urls
@@ -45,7 +46,7 @@ class Panther:
             self.load_configs()
             if config.AUTO_REFORMAT:
                 reformat_code(base_dir=config.BASE_DIR)
-        except Exception as e:  # noqa: BLE001
+        except Exception as e:
             logger.error(e.args[0] if isinstance(e, PantherError) else traceback_message(exception=e))
             sys.exit()
 
@@ -69,7 +70,7 @@ class Panther:
         load_middlewares(self._configs_module)
         load_auto_reformat(self._configs_module)
         load_background_tasks(self._configs_module)
-        load_default_cache_exp(self._configs_module)
+        load_other_configs(self._configs_module)
         load_urls(self._configs_module, urls=self._urls)
         load_authentication_class(self._configs_module)
         load_websocket_connections()
@@ -79,15 +80,15 @@ class Panther:
     async def __call__(self, scope: dict, receive: Callable, send: Callable) -> None:
         if scope['type'] == 'lifespan':
             message = await receive()
-            if message["type"] == 'lifespan.startup':
+            if message['type'] == 'lifespan.startup':
                 if config.HAS_WS:
                     await config.WEBSOCKET_CONNECTIONS.start()
                 try:
                     await Event.run_startups()
                 except Exception as e:
                     logger.error(e)
-                    raise e
-            elif message["type"] == 'lifespan.shutdown':
+                    raise
+            elif message['type'] == 'lifespan.shutdown':
                 # It's not happening :\, so handle the shutdowns in __del__ ...
                 pass
             return
@@ -119,7 +120,6 @@ class Panther:
 
         return await config.WEBSOCKET_CONNECTIONS.listen(connection=final_connection)
 
-
     async def handle_ws(self, scope: dict, receive: Callable, send: Callable) -> None:
         # Create Temp Connection
         connection = Websocket(scope=scope, receive=receive, send=send)
@@ -139,7 +139,6 @@ class Panther:
             logger.error(traceback_message(exception=e))
             await connection.close()
 
-
     @classmethod
     async def handle_http_endpoint(cls, request: Request) -> Response:
         # Find Endpoint
@@ -176,7 +175,7 @@ class Panther:
                 logger.error('You forgot to return `response` on the `Middlewares.__call__()`')
                 response = Response(
                     data={'detail': 'Internal Server Error'},
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                 )
         # Handle `APIError` Exceptions
         except APIError as e:
@@ -186,15 +185,15 @@ class Panther:
                 status_code=e.status_code,
             )
         # Handle Unknown Exceptions
-        except Exception as e:  # noqa: BLE001 - Blind Exception
+        except Exception as e:
             logger.error(traceback_message(exception=e))
             response = Response(
                 data={'detail': 'Internal Server Error'},
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
         # Return Response
-        await response.send(send, receive)
+        await response.send(send=send, receive=receive)
 
     def __del__(self):
         Event.run_shutdowns()

panther/middlewares/cors.py

@@ -0,0 +1,67 @@
+from panther.configs import config
+from panther.middlewares import HTTPMiddleware
+from panther.request import Request
+from panther.response import Response
+
+
+class CORSMiddleware(HTTPMiddleware):
+    """
+    Middleware to handle Cross-Origin Resource Sharing (CORS) for Panther applications.
+
+    This middleware automatically adds the appropriate CORS headers to all HTTP responses
+    based on configuration variables defined in your Panther config file (e.g., core/configs.py).
+    It also handles preflight (OPTIONS) requests.
+
+    Configuration attributes (set these in your config):
+    ---------------------------------------------------
+    ALLOW_ORIGINS: list[str]
+        List of allowed origins. Use ["*"] to allow all origins. Default: ["*"]
+    ALLOW_METHODS: list[str]
+        List of allowed HTTP methods. Default: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+    ALLOW_HEADERS: list[str]
+        List of allowed request headers. Use ["*"] to allow all headers. Default: ["*"]
+    ALLOW_CREDENTIALS: bool
+        Whether to allow credentials (cookies, authorization headers, etc.). Default: False
+    EXPOSE_HEADERS: list[str]
+        List of headers that can be exposed to the browser. Default: []
+    CORS_MAX_AGE: int
+        Number of seconds browsers are allowed to cache preflight responses. Default: 600
+
+    Usage:
+    ------
+    1. Set the above config variables in your config file as needed.
+    2. Add 'panther.middlewares.cors.CORSMiddleware' to your MIDDLEWARES list.
+    """
+
+    async def __call__(self, request: Request) -> Response:
+        # Fetch CORS settings from config, with defaults
+        allow_origins = config.ALLOW_ORIGINS or ['*']
+        allow_methods = config.ALLOW_METHODS or ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']
+        allow_headers = config.ALLOW_HEADERS or ['*']
+        allow_credentials = config.ALLOW_CREDENTIALS or False
+        expose_headers = config.EXPOSE_HEADERS or []
+        max_age = config.CORS_MAX_AGE or 600
+
+        # Handle preflight (OPTIONS) requests
+        if request.method == 'OPTIONS':
+            response = Response(status_code=204)
+        else:
+            response = await self.dispatch(request=request)
+
+        origin = request.headers['origin'] or '*'
+        if '*' in allow_origins:
+            allow_origin = '*'
+        elif origin in allow_origins:
+            allow_origin = origin
+        else:
+            allow_origin = allow_origins[0] if allow_origins else '*'
+
+        response.headers['Access-Control-Allow-Origin'] = allow_origin
+        response.headers['Access-Control-Allow-Methods'] = ', '.join(allow_methods)
+        response.headers['Access-Control-Allow-Headers'] = ', '.join(allow_headers)
+        response.headers['Access-Control-Max-Age'] = str(max_age)
+        if allow_credentials:
+            response.headers['Access-Control-Allow-Credentials'] = 'true'
+        if expose_headers:
+            response.headers['Access-Control-Expose-Headers'] = ', '.join(expose_headers)
+        return response

panther/middlewares/monitoring.py

@@ -11,7 +11,7 @@ logger = logging.getLogger('monitoring')
 class MonitoringMiddleware(HTTPMiddleware):
     """
     Create Log Message Like Below:
-    date_time | method | path | ip:port | response_time(seconds) | status
+    datetime | method | path | ip:port | response_time(seconds) | status
     """
 
     async def __call__(self, request: Request):
@@ -24,11 +24,13 @@ class MonitoringMiddleware(HTTPMiddleware):
         logger.info(f'{method} | {request.path} | {request.client} | {response_time} | {response.status_code}')
         return response
 
+
 class WebsocketMonitoringMiddleware(WebsocketMiddleware):
     """
     Create Log Message Like Below:
-    date_time | WS | path | ip:port | connection_time(seconds) | status
+    datetime | WS | path | ip:port | connection_time(seconds) | status
     """
+
     ConnectedConnectionTime = ' - '
 
     async def __call__(self, connection: Websocket):
@@ -39,4 +41,4 @@ class WebsocketMonitoringMiddleware(WebsocketMiddleware):
 
         connection_time = perf_counter() - start_time  # Seconds
         logger.info(f'WS | {connection.path} | {connection.client} | {connection_time} | {connection.state}')
-        return connection
+        return connection

panther/openapi/urls.py

@@ -1,5 +1,5 @@
 from panther.openapi.views import OpenAPI
 
-urls = {
+url_routing = {
     '': OpenAPI,
-}
+}

panther/openapi/utils.py

@@ -17,9 +17,9 @@ class OutputSchema:
     """
 
     def __init__(
-            self,
-            model: type[ModelSerializer] | type[pydantic.BaseModel] = EmptyResponseModel,
-            status_code: int = status.HTTP_200_OK,
+        self,
+        model: type[ModelSerializer] | type[pydantic.BaseModel] = EmptyResponseModel,
+        status_code: int = status.HTTP_200_OK,
     ):
         self.model = model
         self.status_code = status_code

panther/openapi/views.py

@@ -16,43 +16,31 @@ class OpenAPI(GenericAPI):
             schema = endpoint.output_schema.model.schema()
         else:
             status_code = parsed.status_code
-            schema = {
-                'properties': {
-                    k: {'default': v} for k, v in parsed.data.items()
-                }
-            }
+            schema = {'properties': {k: {'default': v} for k, v in parsed.data.items()}}
 
         responses = {}
         if schema:
-            responses = {
-                'responses': {
-                    status_code: {
-                        'content': {
-                            'application/json': {
-                                'schema': schema
-                            }
-                        }
-                    }
-                }
-            }
+            responses = {'responses': {status_code: {'content': {'application/json': {'schema': schema}}}}}
         request_body = {}
         if endpoint.input_model and method in ['post', 'put', 'patch']:
             request_body = {
                 'requestBody': {
                     'required': True,
                     'content': {
-                        'application/json': {
-                            'schema': endpoint.input_model.schema() if endpoint.input_model else {}
-                        }
-                    }
-                }
+                        'application/json': {'schema': endpoint.input_model.schema() if endpoint.input_model else {}},
+                    },
+                },
             }
 
-        content = {
-                      'title': parsed.title,
-                      'summary': endpoint.__doc__,
-                      'tags': ['.'.join(endpoint.__module__.rsplit('.')[:-1]) or endpoint.__module__],
-                  } | responses | request_body
+        content = (
+            {
+                'title': parsed.title,
+                'summary': endpoint.__doc__,
+                'tags': ['.'.join(endpoint.__module__.rsplit('.')[:-1]) or endpoint.__module__],
+            }
+            | responses
+            | request_body
+        )
         return {method: content}
 
     def get(self):
@@ -70,15 +58,15 @@ class OpenAPI(GenericAPI):
 
             if isinstance(endpoint, types.FunctionType):
                 methods = endpoint.methods
-                if methods is None or 'POST' in methods:
+                if 'POST' in methods:
                     paths[url] |= self.get_content(endpoint, 'post')
-                if methods is None or 'GET' in methods:
+                if 'GET' in methods:
                     paths[url] |= self.get_content(endpoint, 'get')
-                if methods is None or 'PUT' in methods:
+                if 'PUT' in methods:
                     paths[url] |= self.get_content(endpoint, 'put')
-                if methods is None or 'PATCH' in methods:
+                if 'PATCH' in methods:
                     paths[url] |= self.get_content(endpoint, 'patch')
-                if methods is None or 'DELETE' in methods:
+                if 'DELETE' in methods:
                     paths[url] |= self.get_content(endpoint, 'delete')
             else:
                 if endpoint.post is not GenericAPI.post:
@@ -92,10 +80,5 @@ class OpenAPI(GenericAPI):
                 if endpoint.delete is not GenericAPI.delete:
                     paths[url] |= self.get_content(endpoint, 'delete')
 
-        openapi_content = {
-            'openapi': '3.0.0',
-            'paths': paths,
-            'components': {}
-        }
-        print(f'{openapi_content=}')
+        openapi_content = {'openapi': '3.0.0', 'paths': paths, 'components': {}}
         return TemplateResponse(name='openapi.html', context={'openapi_content': openapi_content})

panther/pagination.py

@@ -1,6 +1,7 @@
-from panther.db.cursor import Cursor
 from pantherdb import Cursor as PantherDBCursor
 
+from panther.db.cursor import Cursor
+
 
 class Pagination:
     """
@@ -14,6 +15,7 @@ class Pagination:
             'results': [...]
         }
     """
+
     DEFAULT_LIMIT = 20
     DEFAULT_SKIP = 0
 
@@ -47,5 +49,5 @@ class Pagination:
             'count': count,
             'next': self.build_next_params() if has_next else None,
             'previous': self.build_previous_params() if self.skip else None,
-            'results': response
+            'results': response,
         }

panther/panel/apis.py

@@ -3,8 +3,7 @@ import contextlib
 from panther import status
 from panther.app import API
 from panther.configs import config
-from panther.db.connections import db
-from panther.db.connections import redis
+from panther.db.connections import db, redis
 from panther.panel.utils import get_model_fields
 from panther.request import Request
 from panther.response import Response
@@ -16,11 +15,7 @@ with contextlib.suppress(ImportError):
 
 @API(methods=['GET'])
 async def models_api():
-    return [{
-        'name': model.__name__,
-        'module': model.__module__,
-        'index': i
-    } for i, model in enumerate(config.MODELS)]
+    return [{'name': model.__name__, 'module': model.__module__, 'index': i} for i, model in enumerate(config.MODELS)]
 
 
 @API(methods=['GET', 'POST'])

panther/panel/urls.py

@@ -1,10 +1,6 @@
-from panther.panel.views import TableView, CreateView, LoginView, DetailView, HomeView
+from panther.panel.views import CreateView, DetailView, HomeView, LoginView, TableView
 
-urls = {
-    # '': models_api,
-    # '<index>/': documents_api,
-    # '<index>/<document_id>/': single_document_api,
-    # 'health': healthcheck_api,
+url_routing = {
     '': HomeView,
     '<index>/': TableView,
     '<index>/create/': CreateView,

panther/panel/utils.py

@@ -51,6 +51,7 @@ def clean_model_schema(schema: dict) -> dict:
             'is_male': {'title': 'Is Male', 'type': ['boolean', 'null'], 'required': True}
         }
     }
+
     """
 
     result = defaultdict(dict)
@@ -108,8 +109,11 @@ def get_model_fields(model):
 
 
 def get_models():
-    return [{
-        'index': i,
-        'name': model.__name__,
-        'module': model.__module__,
-    } for i, model in enumerate(config.MODELS)]
+    return [
+        {
+            'index': i,
+            'name': model.__name__,
+            'module': model.__module__,
+        }
+        for i, model in enumerate(config.MODELS)
+    ]

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