panther 3.7.0__py3-none-any.whl → 3.8.1__py3-none-any.whl

panther/__init__.py

@@ -1,6 +1,6 @@
 from panther.main import Panther  # noqa: F401
 
-__version__ = '3.7.0'
+__version__ = '3.8.1'
 
 
 def version():

panther/base_websocket.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import logging
-from typing import TYPE_CHECKING
+from multiprocessing import Manager
+from typing import TYPE_CHECKING, Literal
 
 import orjson as json
 
@@ -11,19 +12,35 @@ from panther import status
 from panther._utils import generate_ws_connection_id
 from panther.base_request import BaseRequest
 from panther.configs import config
+from panther.db.connection import redis
 from panther.utils import Singleton
 
 if TYPE_CHECKING:
     from redis import Redis
 
-
 logger = logging.getLogger('panther')
 
 
+class PubSub:
+    def __init__(self, manager):
+        self._manager = manager
+        self._subscribers = self._manager.list()
+
+    def subscribe(self):
+        queue = self._manager.Queue()
+        self._subscribers.append(queue)
+        return queue
+
+    def publish(self, msg):
+        for queue in self._subscribers:
+            queue.put(msg)
+
+
 class WebsocketConnections(Singleton):
-    def __init__(self):
+    def __init__(self, manager: Manager = None):
         self.connections = {}
         self.connections_count = 0
+        self.manager = manager
 
     def __call__(self, r: Redis | None):
         if r:
@@ -31,39 +48,61 @@ class WebsocketConnections(Singleton):
             subscriber.subscribe('websocket_connections')
             logger.info("Subscribed to 'websocket_connections' channel")
             for channel_data in subscriber.listen():
-                # Check Type of PubSub Message
                 match channel_data['type']:
+                    # Subscribed
                     case 'subscribe':
                         continue
 
+                    # Message Received
                     case 'message':
                         loaded_data = json.loads(channel_data['data'].decode())
-                        if (
-                                isinstance(loaded_data, dict)
-                                and (connection_id := loaded_data.get('connection_id'))
-                                and (data := loaded_data.get('data'))
-                                and (action := loaded_data.get('action'))
-                                and (connection := self.connections.get(connection_id))
-                       ):
-                            # Check Action of WS
-                            match action:
-                                case 'send':
-                                    logger.debug(f'Sending Message to {connection_id}')
-                                    asyncio.run(connection.send(data=data))
-                                case 'close':
-                                    with contextlib.suppress(RuntimeError):
-                                        asyncio.run(connection.close(code=data['code'], reason=data['reason']))
-                                        # We are trying to disconnect the connection between a thread and a user
-                                        # from another thread, it's working, but we have to find another solution it
-                                        #
-                                        # Error:
-                                        # Task <Task pending coro=<Websocket.close()>> got Future
-                                        # <Task pending coro=<WebSocketCommonProtocol.transfer_data()>>
-                                        # attached to a different loop
-                                case _:
-                                    logger.debug(f'Unknown Message Action: {action}')
-                    case _:
-                        logger.debug(f'Unknown Channel Type: {channel_data["type"]}')
+                        self._handle_received_message(received_message=loaded_data)
+
+                    case unknown_type:
+                        logger.debug(f'Unknown Channel Type: {unknown_type}')
+        else:
+            self.pubsub = PubSub(manager=self.manager)
+            queue = self.pubsub.subscribe()
+            logger.info("Subscribed to 'websocket_connections' queue")
+            while True:
+                received_message = queue.get()
+                self._handle_received_message(received_message=received_message)
+
+    def _handle_received_message(self, received_message):
+        if (
+                isinstance(received_message, dict)
+                and (connection_id := received_message.get('connection_id'))
+                and connection_id in self.connections
+                and 'action' in received_message
+                and 'data' in received_message
+        ):
+            # Check Action of WS
+            match received_message['action']:
+                case 'send':
+                    asyncio.run(self.connections[connection_id].send(data=received_message['data']))
+                case 'close':
+                    with contextlib.suppress(RuntimeError):
+                        asyncio.run(self.connections[connection_id].close(
+                            code=received_message['data']['code'],
+                            reason=received_message['data']['reason']
+                        ))
+                        # We are trying to disconnect the connection between a thread and a user
+                        # from another thread, it's working, but we have to find another solution for it
+                        #
+                        # Error:
+                        # Task <Task pending coro=<Websocket.close()>> got Future
+                        # <Task pending coro=<WebSocketCommonProtocol.transfer_data()>>
+                        # attached to a different loop
+                case unknown_action:
+                    logger.debug(f'Unknown Message Action: {unknown_action}')
+
+    def publish(self, connection_id: str, action: Literal['send', 'close'], data: any):
+        publish_data = {'connection_id': connection_id, 'action': action, 'data': data}
+
+        if redis.is_connected:
+            redis.publish('websocket_connections', json.dumps(publish_data))
+        else:
+            self.pubsub.publish(publish_data)
 
     async def new_connection(self, connection: Websocket) -> None:
         await connection.connect(**connection.path_variables)
@@ -106,6 +145,7 @@ class Websocket(BaseRequest):
         pass
 
     async def send(self, data: any = None) -> None:
+        logger.debug(f'Sending WS Message to {self.connection_id}')
         if data:
             if isinstance(data, bytes):
                 await self.send_bytes(bytes_data=data)
@@ -121,6 +161,7 @@ class Websocket(BaseRequest):
         await self.asgi_send({'type': 'websocket.send', 'bytes': bytes_data})
 
     async def close(self, code: int = status.WS_1000_NORMAL_CLOSURE, reason: str = '') -> None:
+        logger.debug(f'Closing WS Connection {self.connection_id}')
         self.is_connected = False
         config['websocket_connections'].remove_connection(self)
         await self.asgi_send({'type': 'websocket.close', 'code': code, 'reason': reason})

panther/cli/template.py

@@ -33,7 +33,7 @@ async def info_api(request: Request):
 models_py = """from panther.db import Model
 """
 
-serializers_py = """from pydantic import BaseModel
+serializers_py = """from panther.serializer import ModelSerializer
 """
 
 throttling_py = """from datetime import timedelta
@@ -70,8 +70,7 @@ SECRET_KEY = env['SECRET_KEY']{DATABASE}{USER_MODEL}{AUTHENTICATION}{MONITORING}
 URLs = 'core.urls.url_routing'
 """ % datetime.now().date().isoformat()
 
-env = """
-SECRET_KEY = '%s'
+env = """SECRET_KEY='%s'
 """ % generate_secret_key()
 
 main_py = """from panther import Panther

panther/db/connection.py

@@ -54,12 +54,15 @@ class DBSession(Singleton):
         self._session: Database = self._client.get_database()
 
     def _create_pantherdb_session(self, db_url: str) -> None:
+        params = {'db_name': db_url, 'return_dict': True}
         if config['pantherdb_encryption']:
             try:
                 import cryptography
             except ModuleNotFoundError as e:
                 import_error(e, package='cryptography')
-        self._session: PantherDB = PantherDB(db_url, return_dict=True, secret_key=config['secret_key'])
+            else:
+                params['secret_key'] = config['secret_key']
+        self._session: PantherDB = PantherDB(**params)
 
     def close(self) -> None:
         if self._db_name == 'mongodb':

panther/main.py

@@ -5,6 +5,7 @@ import sys
 import types
 from collections.abc import Callable
 from logging.config import dictConfig
+from multiprocessing import Manager
 from pathlib import Path
 from threading import Thread
 
@@ -52,14 +53,6 @@ class Panther:
         # Print Info
         print_info(config)
 
-        # Start Websocket Listener (Redis Required)
-        if config['has_ws']:
-            Thread(
-                target=config['websocket_connections'],
-                daemon=True,
-                args=(self.ws_redis_connection,),
-            ).start()
-
     def load_configs(self) -> None:
 
         # Check & Read The Configs File
@@ -98,8 +91,7 @@ class Panther:
         self._create_ws_connections_instance()
 
     def _create_ws_connections_instance(self):
-        from panther.base_websocket import Websocket
-        from panther.websocket import WebsocketConnections
+        from panther.base_websocket import Websocket, WebsocketConnections
 
         # Check do we have ws endpoint
         for endpoint in config['flat_urls'].values():
@@ -111,7 +103,6 @@ class Panther:
 
         # Create websocket connections instance
         if config['has_ws']:
-            config['websocket_connections'] = WebsocketConnections()
             # Websocket Redis Connection
             for middleware in config['http_middlewares']:
                 if middleware.__class__.__name__ == 'RedisMiddleware':
@@ -120,6 +111,10 @@ class Panther:
             else:
                 self.ws_redis_connection = None
 
+            # Don't create Manager() if we are going to use Redis for PubSub
+            manager = None if self.ws_redis_connection else Manager()
+            config['websocket_connections'] = WebsocketConnections(manager=manager)
+
     async def __call__(self, scope: dict, receive: Callable, send: Callable) -> None:
         """
         1.
@@ -138,6 +133,7 @@ class Panther:
         if scope['type'] == 'lifespan':
             message = await receive()
             if message["type"] == "lifespan.startup":
+                await self.handle_ws_listener()
                 await self.handle_startup()
             return
 
@@ -262,6 +258,15 @@ class Panther:
             body=response.body,
         )
 
+    async def handle_ws_listener(self):
+        # Start Websocket Listener (Redis/ Queue)
+        if config['has_ws']:
+            Thread(
+                target=config['websocket_connections'],
+                daemon=True,
+                args=(self.ws_redis_connection,),
+            ).start()
+
     async def handle_startup(self):
         if startup := config['startup'] or self._startup:
             if is_function_async(startup):
@@ -272,7 +277,13 @@ class Panther:
     def handle_shutdown(self):
         if shutdown := config['shutdown'] or self._shutdown:
             if is_function_async(shutdown):
-                asyncio.run(shutdown())
+                try:
+                    asyncio.run(shutdown())
+                except ModuleNotFoundError:
+                    # Error: import of asyncio halted; None in sys.modules
+                    #   And as I figured it out, it only happens when we running with
+                    #   gunicorn and Uvicorn workers (-k uvicorn.workers.UvicornWorker)
+                    pass
             else:
                 shutdown()
 

panther/response.py

@@ -35,9 +35,10 @@ class Response:
 
     @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': len(self.body),
+            'content-length': content_length,
             'access-control-allow-origin': '*',
         } | (self._headers or {})
 

panther/serializer.py

@@ -3,31 +3,44 @@ from pydantic_core._pydantic_core import PydanticUndefined
 
 
 class ModelSerializer:
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, *args, model=None, **kwargs):
+        # Check `metaclass`
         if len(args) == 0:
-            msg = f"you should not inherit the 'ModelSerializer', you should use it as 'metaclass' -> {cls.__name__}"
+            address = f'{cls.__module__}.{cls.__name__}'
+            msg = f"you should not inherit the 'ModelSerializer', you should use it as 'metaclass' -> {address}"
             raise TypeError(msg)
+
         model_name = args[0]
-        if 'model' not in kwargs:
-            msg = f"'model' required while using 'ModelSerializer' metaclass -> {model_name}"
+        data = args[2]
+        address = f'{data["__module__"]}.{model_name}'
+
+        # Check `model`
+        if model is None:
+            msg = f"'model' required while using 'ModelSerializer' metaclass -> {address}"
             raise AttributeError(msg)
+        # Check `fields`
+        if 'fields' not in data:
+            msg = f"'fields' required while using 'ModelSerializer' metaclass. -> {address}"
+            raise AttributeError(msg) from None
 
-        model_fields = kwargs['model'].model_fields
+        model_fields = model.model_fields
         field_definitions = {}
-        if 'fields' not in args[2]:
-            msg = f"'fields' required while using 'ModelSerializer' metaclass. -> {model_name}"
-            raise AttributeError(msg) from None
-        for field_name in args[2]['fields']:
+
+        # Collect `fields`
+        for field_name in data['fields']:
             if field_name not in model_fields:
-                msg = f"'{field_name}' is not in '{kwargs['model'].__name__}' -> {model_name}"
+                msg = f"'{field_name}' is not in '{model.__name__}' -> {address}"
                 raise AttributeError(msg) from None
-
             field_definitions[field_name] = (model_fields[field_name].annotation, model_fields[field_name])
-        for required in args[2].get('required_fields', []):
+
+        # 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' -> {model_name}"
+                msg = f"'{required}' is in 'required_fields' but not in 'fields' -> {address}"
                 raise AttributeError(msg) from None
             field_definitions[required][1].default = PydanticUndefined
+
+        # Create Model
         return create_model(
             __model_name=model_name,
             **field_definitions

panther/websocket.py

@@ -1,13 +1,8 @@
 from __future__ import annotations
 
-from typing import Literal
-
-import orjson as json
-
 from panther import status
-from panther.base_websocket import Websocket, WebsocketConnections
+from panther.base_websocket import Websocket
 from panther.configs import config
-from panther.db.connection import redis
 
 
 class GenericWebsocket(Websocket):
@@ -31,31 +26,9 @@ class GenericWebsocket(Websocket):
 
 
 async def send_message_to_websocket(connection_id: str, data: any):
-    if redis.is_connected:
-        _publish_to_ws_channel(connection_id=connection_id, action='send', data=data)
-    else:
-        websocket_connections: WebsocketConnections = config['websocket_connections']
-        if connection := websocket_connections.connections.get(connection_id):
-            await connection.send(data=data)
+    config.websocket_connections.publish(connection_id=connection_id, action='send', data=data)
 
 
 async def close_websocket_connection(connection_id: str, code: int = status.WS_1000_NORMAL_CLOSURE, reason: str = ''):
-    if redis.is_connected:
-        data = {
-            'code': code,
-            'reason': reason,
-        }
-        _publish_to_ws_channel(connection_id=connection_id, action='close', data=data)
-    else:
-        websocket_connections: WebsocketConnections = config['websocket_connections']
-        if connection := websocket_connections.connections.get(connection_id):
-            await connection.close(code=code, reason=reason)
-
-
-def _publish_to_ws_channel(connection_id: str, action: Literal['send', 'close'], data: any):
-    from panther.db.connection import redis
-
-    assert redis.is_connected, 'Redis Is Not Connected.'
-
-    p_data = json.dumps({'connection_id': connection_id, 'action': action, 'data': data})
-    redis.publish('websocket_connections', p_data)
+    data = {'code': code, 'reason': reason}
+    config.websocket_connections.publish(connection_id=connection_id, action='close', data=data)

{panther-3.7.0.dist-info → panther-3.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: panther
-Version: 3.7.0
+Version: 3.8.1
 Summary: Fast &  Friendly, Web Framework For Building Async APIs
 Home-page: https://github.com/alirn76/panther
 Author: Ali RajabNezhad

{panther-3.7.0.dist-info → panther-3.8.1.dist-info}/RECORD

@@ -1,37 +1,37 @@
-panther/__init__.py,sha256=xRfhzl4lfI9PNr6JDl51kcAwX9xCDez97xYed08Hyds,110
+panther/__init__.py,sha256=sxGEJd2i5R8BqUGWsC5YBeZeY0C0YICZHJM27Wu09bc,110
 panther/_load_configs.py,sha256=jlDO5rK040z3LLmMFMJ6jUL9oTKaDKCWebwmdYJPDjw,9567
 panther/_utils.py,sha256=BHAOdpESn3dt90FtpPKxEZdnkXnDC7MFcncJYburEaQ,4846
 panther/app.py,sha256=3Qf0b-OtczqU5xs7AT7_hFr3t1eFMqzaThQOFu-RoqE,8060
 panther/authentications.py,sha256=II3397DOtB2A1zvPbnCibQXekO_dKeclQ8dgU0s_WAc,4397
 panther/background_tasks.py,sha256=J6JrjiEzyGohYsaFZHnZtXeP52piP84RlGFLsKOFa-Y,7225
 panther/base_request.py,sha256=94mmloCULYtmiRWz-egb5annYp1KQAKFYIAcmIJZZ3o,2897
-panther/base_websocket.py,sha256=I8-ppL7DxFfcZdyt6lfDXeyTa_8xojXK_ADZUYElLBE,6377
+panther/base_websocket.py,sha256=p8nNr3EolttHmMPtIGgFB3evM2N5XZiX9TwXnZbyMqI,7608
 panther/caching.py,sha256=YTFP40aLFR0VabbVYAlHilaALWlCJOrlTNDhG0cRC7c,3075
 panther/configs.py,sha256=8pVMWa2QKaeNOlIUCLX3qfNXl0vNdraiGL4OGykFPXI,2884
 panther/exceptions.py,sha256=DB6nGfU5LxrglEN_I-HInMqdIA3ZmN8rRv0ynEuQyGA,1332
 panther/file_handler.py,sha256=YhqYpGhNybcQBqcxqDEYwI1Hqd-7U5JcwxMb7UM_DbA,854
 panther/logging.py,sha256=DZVf3nxzLodT-hD4820J1jEAffU8zIxXRPKs2lbP8ho,2074
-panther/main.py,sha256=8F9NDzYJIG3cjXgIB18_TsghLK7AUPb2yc3auKXkpXA,11655
+panther/main.py,sha256=0q-ViNYzrR6EgNLZiGqWOlOhpRiJEnunmiqJVfHq6o8,12246
 panther/monitoring.py,sha256=krmcoTUcV12pHwCFVAHywgsp1-US9cyiMlgsrMJdUQ0,1203
 panther/permissions.py,sha256=Q-l25369yQaP-tY11tFQm-v9PPh8iVImbfUpY3pnQUk,355
 panther/request.py,sha256=u_-pyttspRimlSwpSwyVIV0U87hHDIthsFU9Qr8LDvI,1762
-panther/response.py,sha256=Kus8zf5fQLfCgmpKjCMOcEPnAfsQDkSd2NIBvI69lJ8,3653
+panther/response.py,sha256=5t9-HwgwRo3egqzs1uFNhIq5i5wZW-TRrVX8YEdFrgA,3724
 panther/routings.py,sha256=GfwBZL7bt3yVOnpdjOZ-49kiGVrRoF0i8VwS1qkF_oI,5273
-panther/serializer.py,sha256=26l-SDQ194fXAuirrvHIABHlrKQI-9FHsUw-1oOvD20,1581
+panther/serializer.py,sha256=ZvLWwHV2KQdl49ZFRshz4HWXVmFNQtUClggSWkH9pa8,1839
 panther/status.py,sha256=Gc_PnYrHfInTsZpGbqiCfDB-py1C7Rh8KMdb6Lq9Exs,3346
 panther/test.py,sha256=Se0cF51JRAmABpB_QTIJeTDRKDcyOMlibEN6rrr4Sd8,6152
 panther/throttling.py,sha256=mVa_mGv6w_Ad7LLtV4eG5QpDwwNsk4QjFFi0mIHQBnE,231
 panther/utils.py,sha256=fWzUrVnXc-98iOC6RIOD4E1KL2rkd6EtbSqqg5ZTG_U,3142
-panther/websocket.py,sha256=tsG5AYT8RNFmgsb9pYpx1YirRO0qaqmVKQ5V-U1hNmE,2139
+panther/websocket.py,sha256=HEyp3lOTKwitPPX76IfwYdp_gbjjmmrHMizBlLHRmNA,1158
 panther/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 panther/cli/create_command.py,sha256=AshVxzhSpX-L_63OLP7ZgQ5a45NINGomTbvJkCaadks,9671
 panther/cli/main.py,sha256=pCqnOTazgMhTvFHTugutIsiFXueU5kx2VmGngwAl54Q,1679
 panther/cli/monitor_command.py,sha256=cZ7wOxeQ8jKXgRLP28SgFI9pbIEp4RK6VmVf74WKT6c,2447
 panther/cli/run_command.py,sha256=X_T9jP_Z8X_fm9S4LSoR6ARsPp4rCTMi1E5c7QWREjM,2120
-panther/cli/template.py,sha256=GwQE8kadjAgKN3-Nd250xqOO5WThCpEE3HlsJOTZlDA,4928
+panther/cli/template.py,sha256=i4YUgsdVjYhWGoCpoCNQOBo2rKSVk0yx-o_GBmG4yx8,4941
 panther/cli/utils.py,sha256=nhtdr9nhYAbCm2S-17vTc3_unjQJ450uxT0ZVyZueIw,4838
 panther/db/__init__.py,sha256=w9lEL0vRqb18Qx_iUJipUR_fi5GQ5uVX0DWycx14x08,50
-panther/db/connection.py,sha256=yPD3WeSPtbGLMm-C81s09exbsj7Bm2n57rAQkqD2EdY,2952
+panther/db/connection.py,sha256=9lXzMinGNgQraeu4Sjy92AueR7_AGRsDb0EE0_K4VP4,3039
 panther/db/models.py,sha256=7dJ_l0ejVOAVc6qietOYenaRVXBb_O5LNXoyBCLi55g,1434
 panther/db/utils.py,sha256=AFVQz-vvfnAj3hcNq4IMo0T7EB8BR9snM-tGsK-Saw4,1667
 panther/db/queries/__init__.py,sha256=FpSQGNHGMs5PJow8Qan4eBAld6QH6wfMvj7lC92vKcU,55
@@ -46,9 +46,9 @@ panther/panel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 panther/panel/apis.py,sha256=HUf9Km81wWtO3pbgW0Oi5MDbLvX5LIWdiFRy05UsitE,1773
 panther/panel/urls.py,sha256=BQkWqSJBPP3VEQYeorKSHIRx-PUl21Y7Z6NFylmhs1I,192
 panther/panel/utils.py,sha256=0Rv79oR5IEqalqwpRKQHMn1p5duVY5mxMqDKiA5mWx4,437
-panther-3.7.0.dist-info/LICENSE,sha256=2aF1hL2aC0zRPjzUkSxJUzZbn2_uLoOkn7DHjzZni-I,1524
-panther-3.7.0.dist-info/METADATA,sha256=ziap0s_p1ParA6EN0iPFu6s0L3etUKQyEg2PFwgEx90,6023
-panther-3.7.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-panther-3.7.0.dist-info/entry_points.txt,sha256=6GPxYFGuzVfNB4YpHFJvYex6iWah5_tLnirAHwj2Qsg,51
-panther-3.7.0.dist-info/top_level.txt,sha256=VbBs02JGXTIoHMzsX-eLOk2MCbBZzQbLhWiYpI7xI2g,8
-panther-3.7.0.dist-info/RECORD,,
+panther-3.8.1.dist-info/LICENSE,sha256=2aF1hL2aC0zRPjzUkSxJUzZbn2_uLoOkn7DHjzZni-I,1524
+panther-3.8.1.dist-info/METADATA,sha256=KMHrczETrp-LQzP2SxiPcHqaiKuLz2TkUT6dLv5TSU4,6023
+panther-3.8.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+panther-3.8.1.dist-info/entry_points.txt,sha256=6GPxYFGuzVfNB4YpHFJvYex6iWah5_tLnirAHwj2Qsg,51
+panther-3.8.1.dist-info/top_level.txt,sha256=VbBs02JGXTIoHMzsX-eLOk2MCbBZzQbLhWiYpI7xI2g,8
+panther-3.8.1.dist-info/RECORD,,