panther 3.7.0__tar.gz → 3.8.1__tar.gz

{panther-3.7.0 → panther-3.8.1}/PKG-INFO

@@ -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 → panther-3.8.1}/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-3.7.0 → panther-3.8.1}/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-3.7.0 → panther-3.8.1}/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-3.7.0 → panther-3.8.1}/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-3.7.0 → panther-3.8.1}/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-3.7.0 → panther-3.8.1}/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-3.7.0 → panther-3.8.1}/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-3.8.1/panther/websocket.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from panther import status
+from panther.base_websocket import Websocket
+from panther.configs import config
+
+
+class GenericWebsocket(Websocket):
+    async def connect(self, **kwargs):
+        """
+        Check your conditions then `accept()` the connection
+        """
+
+    async def receive(self, data: str | bytes):
+        """
+        Received `data` of connection,
+        You may want to use json.loads() on the `data`
+        """
+
+    async def send(self, data: any = None):
+        """
+        We are using this method to send message to the client,
+        You may want to override it with your custom scenario. (not recommended)
+        """
+        return await super().send(data=data)
+
+
+async def send_message_to_websocket(connection_id: str, data: any):
+    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 = ''):
+    data = {'code': code, 'reason': reason}
+    config.websocket_connections.publish(connection_id=connection_id, action='close', data=data)

{panther-3.7.0 → panther-3.8.1}/panther.egg-info/PKG-INFO

@@ -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 → panther-3.8.1}/tests/test_model_serializer.py

@@ -1,4 +1,3 @@
-import asyncio
 from pathlib import Path
 from unittest import TestCase
 
@@ -6,7 +5,6 @@ from pydantic import Field
 
 from panther import Panther
 from panther.app import API
-from panther.configs import config
 from panther.db import Model
 from panther.request import Request
 from panther.serializer import ModelSerializer
@@ -122,7 +120,7 @@ class TestModelSerializer(TestCase):
                 pass
         except Exception as e:
             assert isinstance(e, AttributeError)
-            assert e.args[0] == "'fields' required while using 'ModelSerializer' metaclass. -> Serializer1"
+            assert e.args[0] == "'fields' required while using 'ModelSerializer' metaclass. -> tests.test_model_serializer.Serializer1"
         else:
             assert False
 
@@ -132,7 +130,7 @@ class TestModelSerializer(TestCase):
                 fields = ['ok', 'no']
         except Exception as e:
             assert isinstance(e, AttributeError)
-            assert e.args[0] == "'ok' is not in 'Book' -> Serializer2"
+            assert e.args[0] == "'ok' is not in 'Book' -> tests.test_model_serializer.Serializer2"
         else:
             assert False
 
@@ -143,7 +141,7 @@ class TestModelSerializer(TestCase):
                 required_fields = ['pages_count']
         except Exception as e:
             assert isinstance(e, AttributeError)
-            assert e.args[0] == "'pages_count' is in 'required_fields' but not in 'fields' -> Serializer3"
+            assert e.args[0] == "'pages_count' is in 'required_fields' but not in 'fields' -> tests.test_model_serializer.Serializer3"
         else:
             assert False
 
@@ -154,7 +152,7 @@ class TestModelSerializer(TestCase):
                 required_fields = ['pages_count']
         except Exception as e:
             assert isinstance(e, AttributeError)
-            assert e.args[0] == "'model' required while using 'ModelSerializer' metaclass -> Serializer4"
+            assert e.args[0] == "'model' required while using 'ModelSerializer' metaclass -> tests.test_model_serializer.Serializer4"
         else:
             assert False
 
@@ -167,7 +165,6 @@ class TestModelSerializer(TestCase):
             Serializer5(name='alice', author='bob')
         except Exception as e:
             assert isinstance(e, TypeError)
-            assert e.args[0] == ("you should not inherit the 'ModelSerializer', "
-                                 "you should use it as 'metaclass' -> Serializer5")
+            assert e.args[0] == "you should not inherit the 'ModelSerializer', you should use it as 'metaclass' -> tests.test_model_serializer.Serializer5"
         else:
             assert False

panther-3.7.0/panther/websocket.py

@@ -1,61 +0,0 @@
-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.configs import config
-from panther.db.connection import redis
-
-
-class GenericWebsocket(Websocket):
-    async def connect(self, **kwargs):
-        """
-        Check your conditions then `accept()` the connection
-        """
-
-    async def receive(self, data: str | bytes):
-        """
-        Received `data` of connection,
-        You may want to use json.loads() on the `data`
-        """
-
-    async def send(self, data: any = None):
-        """
-        We are using this method to send message to the client,
-        You may want to override it with your custom scenario. (not recommended)
-        """
-        return await super().send(data=data)
-
-
-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)
-
-
-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)