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

panther/base_websocket.py

@@ -1,18 +1,19 @@
 from __future__ import annotations
 
 import asyncio
-import orjson as json
+import logging
 from multiprocessing.managers import SyncManager
 from typing import TYPE_CHECKING, Literal
 
-import logging
+import orjson as json
+import ulid
+
 from panther import status
 from panther.base_request import BaseRequest
 from panther.configs import config
 from panther.db.connections import redis
-from panther.exceptions import AuthenticationAPIError, InvalidPathVariableAPIError
-from panther.monitoring import Monitoring
-from panther.utils import Singleton, ULID
+from panther.exceptions import InvalidPathVariableAPIError, BaseError
+from panther.utils import Singleton
 
 if TYPE_CHECKING:
     from redis.asyncio import Redis
@@ -108,7 +109,7 @@ class WebsocketConnections(Singleton):
         else:
             self.pubsub.publish(publish_data)
 
-    async def listen(self, connection: Websocket) -> None:
+    async def listen(self, connection: Websocket):
         # 1. Authentication
         if not connection.is_rejected:
             await self.handle_authentication(connection=connection)
@@ -125,7 +126,7 @@ class WebsocketConnections(Singleton):
         try:
             kwargs = connection.clean_parameters(connection.connect)
         except InvalidPathVariableAPIError as e:
-            connection.log(e.detail)
+            connection.change_state(state='Rejected', message=e.detail)
             return await connection.close()
 
         # 4. Connect To Endpoint
@@ -139,6 +140,8 @@ class WebsocketConnections(Singleton):
         # 6. Listen Connection
         await self.listen_connection(connection=connection)
 
+        return connection
+
     async def listen_connection(self, connection: Websocket):
         while True:
             response = await connection.asgi_receive()
@@ -146,7 +149,7 @@ class WebsocketConnections(Singleton):
                 continue
 
             if response['type'] == 'websocket.disconnect':
-                # Connect has to be closed by the client
+                # Connection has to be closed by the client.
                 await self.connection_closed(connection=connection)
                 break
 
@@ -157,25 +160,20 @@ class WebsocketConnections(Singleton):
 
     async def connection_accepted(self, connection: Websocket) -> None:
         # Generate ConnectionID
-        connection._connection_id = ULID.new()
+        connection._connection_id = ulid.new()
 
         # Save Connection
         self.connections[connection.connection_id] = connection
-
-        # Logs
-        await connection.monitoring.after('Accepted')
-        connection.log(f'Accepted {connection.connection_id}')
+        connection.change_state(state='Accepted')
 
     async def connection_closed(self, connection: Websocket, from_server: bool = False) -> None:
         if connection.is_connected:
             del self.connections[connection.connection_id]
-            await connection.monitoring.after('Closed')
-            connection.log(f'Closed {connection.connection_id}')
+            connection.change_state(state='Closed')
             connection._connection_id = ''
 
         elif connection.is_rejected is False and from_server is True:
-            await connection.monitoring.after('Rejected')
-            connection.log('Rejected')
+            connection.change_state(state='Rejected')
             connection._is_rejected = True
 
     async def start(self):
@@ -203,8 +201,8 @@ class WebsocketConnections(Singleton):
             else:
                 try:
                     connection.user = await config.WS_AUTHENTICATION.authentication(connection)
-                except AuthenticationAPIError as e:
-                    connection.log(e.detail)
+                except BaseError as e:
+                    connection.change_state(state='Rejected', message=e.detail)
                     await connection.close()
 
     @classmethod
@@ -215,16 +213,16 @@ class WebsocketConnections(Singleton):
                 logger.critical(f'{perm.__name__}.authorization should be "classmethod"')
                 await connection.close()
             elif await perm.authorization(connection) is False:
-                connection.log('Permission Denied')
+                connection.change_state(state='Rejected', message='Permission Denied')
                 await connection.close()
 
 
 class Websocket(BaseRequest):
     auth: bool = False
     permissions: list = []
+    state: str = 'Connected'
     _connection_id: str = ''
     _is_rejected: bool = False
-    _monitoring: Monitoring
 
     def __init_subclass__(cls, **kwargs):
         if cls.__module__ != 'panther.websocket':
@@ -274,9 +272,10 @@ class Websocket(BaseRequest):
     def is_rejected(self) -> bool:
         return self._is_rejected
 
-    @property
-    def monitoring(self) -> Monitoring:
-        return self._monitoring
-
-    def log(self, message: str):
-        logger.debug(f'WS {self.path} --> {message}')
+    def change_state(self, state: Literal['Accepted', 'Closed', 'Rejected'], message: str = ''):
+        self.state = state
+        if message:
+            message = f' | {message}'
+        if self.is_connected:
+            message = f' | {self.connection_id}{message}'
+        logger.debug(f'WS {self.path} --> {state}{message}')

panther/cli/create_command.py

@@ -90,6 +90,7 @@ class CreateProject:
                 'field': 'log_queries',
                 'message': 'Do You Want To Log Queries',
                 'is_boolean': True,
+                'condition': "self.database != '2'"
             },
             {
                 'field': 'auto_reformat',

panther/cli/main.py

@@ -1,40 +1,32 @@
-import os
+import logging
 import sys
 
 from panther import version as panther_version
 from panther.cli.create_command import create
 from panther.cli.monitor_command import monitor
 from panther.cli.run_command import run
-from panther.cli.utils import cli_error, cli_info, cli_warning, print_help_message
+from panther.cli.utils import cli_error, print_help_message
 
+logger = logging.getLogger('panther')
 
-def shell(args: list) -> None:
+
+def shell(args) -> None:
     if len(args) == 0:
-        cli_info('You may want to use "bpython" or "ipython" for better interactive shell')
-        os.system('python')
+        return cli_error(
+            'Not Enough Arguments, Give me a file path that contains `Panther()` app.\n'
+            '       * Make sure to run `panther shell` in the same directory as that file!\n'
+            '       * Example: `panther shell main.py`'
+        )
     elif len(args) != 1:
         return cli_error('Too Many Arguments.')
-    shell_type = args[0].lower()
-    if shell_type not in ['ipython', 'bpython']:
-        return cli_error(f'"{shell_type}" Is Not Supported.')
-
-    # Bpython
-    if shell_type == 'bpython':
-        try:
-            import bpython
-            os.system('bpython')
-        except ImportError as e:
-            cli_warning(e, 'Hint: "pip install bpython"')
-            os.system('python')
-
-    # Ipython
-    elif shell_type == 'ipython':
-        try:
-            import IPython
-            os.system('ipython')
-        except ImportError as e:
-            cli_warning(e, 'Hint: "pip install ipython"')
-            os.system('python')
+
+    package = args[0].removesuffix('.py')
+    try:
+        from IPython import start_ipython
+
+        start_ipython(('--gui', 'asyncio', '-c', f'"import {package}"', '-i'))
+    except ImportError:
+        logger.error('Make sure `ipython` is installed -> Hint: `pip install ipython`')
 
 
 def version() -> None:
@@ -54,7 +46,7 @@ def start() -> None:
             shell(args)
         case 'monitor':
             monitor()
-        case 'version':
+        case 'version' | '--version':
             version()
         case _:
             cli_error('Invalid Arguments.')

panther/cli/monitor_command.py

@@ -15,6 +15,7 @@ from rich.table import Table
 
 from panther.cli.utils import import_error
 from panther.configs import config
+from panther.middlewares.monitoring import WebsocketMonitoringMiddleware
 
 with contextlib.suppress(ImportError):
     from watchfiles import watch
@@ -53,7 +54,7 @@ class Monitoring:
                 for line in f.readlines():
                     # line = date_time | method | path | ip:port | response_time(seconds) | status
                     columns = line.split('|')
-                    columns[4] = self._clean_response_time(float(columns[4]))
+                    columns[4] = self._clean_response_time(columns[4])
                     self.rows.append(columns)
                     live.update(self.generate_table())
 
@@ -66,7 +67,7 @@ class Monitoring:
 
         # Check log file
         if not self.monitoring_log_file.exists():
-            return f'`{self.monitoring_log_file}` file not found. (Make sure `MONITORING` is `True` in `configs` and you have at least one record)'
+            return f'`{self.monitoring_log_file}` file not found. (Make sure `panther.middlewares.monitoring.MonitoringMiddleware` is in your `MIDDLEWARES`)'
 
         # Initialize Deque
         self.update_rows()
@@ -104,14 +105,17 @@ class Monitoring:
         self.rows = deque(self.rows, maxlen=lines)
 
     @classmethod
-    def _clean_response_time(cls, response_time: int) -> str:
+    def _clean_response_time(cls, response_time: str) -> str:
+        if response_time == WebsocketMonitoringMiddleware.ConnectedConnectionTime:
+            return response_time
+        response_time = float(response_time)
         time_unit = ' s'
 
         if response_time < 0.01:
             response_time = response_time * 1_000
             time_unit = 'ms'
 
-        elif response_time >= 10:
+        elif response_time >= 60:
             response_time = response_time / 60
             time_unit = ' m'
 

panther/cli/template.py

@@ -63,7 +63,11 @@ from panther.utils import load_env
 BASE_DIR = Path(__name__).resolve().parent
 env = load_env(BASE_DIR / '.env')
 
-SECRET_KEY = env['SECRET_KEY']{DATABASE}{REDIS}{USER_MODEL}{AUTHENTICATION}{MONITORING}{LOG_QUERIES}{AUTO_REFORMAT}
+SECRET_KEY = env['SECRET_KEY']{DATABASE}{REDIS}{USER_MODEL}{AUTHENTICATION}{LOG_QUERIES}{AUTO_REFORMAT}
+
+MIDDLEWARES = [
+    {MONITORING}
+]
 
 # More Info: https://PantherPy.GitHub.io/urls/
 URLs = 'core.urls.url_routing'
@@ -134,7 +138,11 @@ from panther.utils import load_env, timezone_now
 BASE_DIR = Path(__name__).resolve().parent
 env = load_env(BASE_DIR / '.env')
 
-SECRET_KEY = env['SECRET_KEY']{DATABASE}{REDIS}{USER_MODEL}{AUTHENTICATION}{MONITORING}{LOG_QUERIES}{AUTO_REFORMAT}
+SECRET_KEY = env['SECRET_KEY']{DATABASE}{REDIS}{USER_MODEL}{AUTHENTICATION}{LOG_QUERIES}{AUTO_REFORMAT}
+
+MIDDLEWARES = [
+    {MONITORING}
+]
 
 InfoThrottling = Throttling(rate=5, duration=timedelta(minutes=1))
 
@@ -216,10 +224,7 @@ AUTHENTICATION_PART = """
 # More Info: https://PantherPy.GitHub.io/authentications/
 AUTHENTICATION = 'panther.authentications.JWTAuthentication'"""
 
-MONITORING_PART = """
-
-# More Info: https://PantherPy.GitHub.io/monitoring/
-MONITORING = True"""
+MONITORING_PART = """'panther.middlewares.monitoring.MonitoringMiddleware'"""
 
 LOG_QUERIES_PART = """
 

panther/cli/utils.py

@@ -48,13 +48,14 @@ help_message = f"""{logo}
 {h}       - panther run [--reload | --help]                  {h}
 {h}           Run your project with uvicorn                  {h}
 {h}                                                          {h}
-{h}       - panther shell [ bpython | ipython ]              {h}
+{h}       - panther shell <application file path>            {h}
 {h}           Run interactive python shell                   {h}
+{h}           * Example: `panther shell main.py`             {h}
 {h}                                                          {h}
 {h}       - panther monitor                                  {h}
 {h}           Show the monitor :)                            {h}
 {h}                                                          {h}
-{h}       - panther version                                  {h}
+{h}       - panther version | --version                      {h}
 {h}           Print the current version of Panther           {h}
 {h}                                                          {h}
 {h}       - panther h | help | --help | -h                   {h}

panther/configs.py

@@ -6,11 +6,9 @@ from pathlib import Path
 from typing import Callable
 
 import jinja2
-from pydantic._internal._model_construction import ModelMetaclass
-
+from pydantic import BaseModel as PydanticBaseModel
 from panther.throttling import Throttling
 
-
 class JWTConfig:
     def __init__(
             self,
@@ -53,13 +51,13 @@ class Config:
     DEFAULT_CACHE_EXP: timedelta | None
     THROTTLING: Throttling | None
     SECRET_KEY: bytes | None
-    HTTP_MIDDLEWARES: list[tuple]
-    WS_MIDDLEWARES: list[tuple]
-    USER_MODEL: ModelMetaclass | None
-    AUTHENTICATION: ModelMetaclass | None
-    WS_AUTHENTICATION: ModelMetaclass | None
+    HTTP_MIDDLEWARES: list
+    WS_MIDDLEWARES: list
+    USER_MODEL: type[PydanticBaseModel] | None # type: type[panther.db.Model]
+    AUTHENTICATION: type[PydanticBaseModel] | None
+    WS_AUTHENTICATION: type[PydanticBaseModel] | None
     JWT_CONFIG: JWTConfig | None
-    MODELS: list[dict]
+    MODELS: list[type[PydanticBaseModel]]  # type: type[panther.db.Model]
     FLAT_URLS: dict
     URLS: dict
     WEBSOCKET_CONNECTIONS: typing.Callable | None

panther/db/cursor.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from sys import version_info
 
+from panther.utils import run_coroutine
+
 try:
     from pymongo.cursor import Cursor as _Cursor
 except ImportError:
@@ -31,13 +33,27 @@ class Cursor(_Cursor):
             self.cls = self.models[collection.name]
         super().__init__(collection, *args, **kwargs)
 
-    def next(self) -> Self:
-        return self.cls._create_model_instance(document=super().next())
+    def __aiter__(self) -> Self:
+        return self
+
+    async def next(self) -> Self:
+        return await self.cls._create_model_instance(document=super().next())
+
+    async def __anext__(self) -> Self:
+        try:
+            return await self.cls._create_model_instance(document=super().next())
+        except StopIteration:
+            raise StopAsyncIteration
+
+    def __next__(self) -> Self:
+        try:
+            return run_coroutine(self.cls._create_model_instance(document=super().next()))
+        except StopIteration:
+            raise
 
-    __next__ = next
 
     def __getitem__(self, index: int | slice) -> Cursor[Self] | Self:
-        result = super().__getitem__(index)
-        if isinstance(result, dict):
-            return self.cls._create_model_instance(document=result)
-        return result
+        document = super().__getitem__(index)
+        if isinstance(document, dict):
+            return run_coroutine(self.cls._create_model_instance(document=document))
+        return document

panther/db/models.py

@@ -1,7 +1,7 @@
 import contextlib
 import os
 from datetime import datetime
-from typing import Annotated
+from typing import Annotated, ClassVar
 
 from pydantic import Field, WrapValidator, PlainSerializer, BaseModel as PydanticBaseModel
 
@@ -15,16 +15,17 @@ with contextlib.suppress(ImportError):
 
 
 def validate_object_id(value, handler):
-    if config.DATABASE.__class__.__name__ == 'MongoDBConnection':
-        if isinstance(value, bson.ObjectId):
-            return value
-        else:
-            try:
-                return bson.ObjectId(value)
-            except Exception as e:
-                msg = 'Invalid ObjectId'
-                raise ValueError(msg) from e
-    return str(value)
+    if config.DATABASE.__class__.__name__ != 'MongoDBConnection':
+        return str(value)
+
+    if isinstance(value, bson.ObjectId):
+        return value
+
+    try:
+        return bson.ObjectId(value)
+    except Exception as e:
+        msg = 'Invalid ObjectId'
+        raise ValueError(msg) from e
 
 
 ID = Annotated[str, WrapValidator(validate_object_id), PlainSerializer(lambda x: str(x), return_type=str)]
@@ -36,23 +37,28 @@ class Model(PydanticBaseModel, Query):
             return
         config.MODELS.append(cls)
 
-    id: ID | None = Field(None, validation_alias='_id')
+    id: ID | None = Field(None, validation_alias='_id', alias='_id')
 
     @property
     def _id(self):
         """
-        return
-            `str` for PantherDB
-            `ObjectId` for MongoDB
+        Returns the actual ID value:
+            - For MongoDB: returns ObjectId
+            - For PantherDB: returns str
         """
+        if config.DATABASE.__class__.__name__ == 'MongoDBConnection':
+            return bson.ObjectId(self.id)
         return self.id
 
 
 class BaseUser(Model):
+    username: str
     password: str = Field('', max_length=64)
     last_login: datetime | None = None
     date_created: datetime | None = Field(default_factory=timezone_now)
 
+    USERNAME_FIELD: ClassVar = 'username'
+
     async def update_last_login(self) -> None:
         await self.update(last_login=timezone_now())
 
@@ -63,7 +69,7 @@ class BaseUser(Model):
     async def logout(self) -> dict:
         return await config.AUTHENTICATION.logout(self._auth_token)
 
-    def set_password(self, password: str):
+    async def set_password(self, password: str):
         """
         URANDOM_SIZE = 16 char -->
             salt = 16 bytes
@@ -73,12 +79,13 @@ class BaseUser(Model):
         salt = os.urandom(URANDOM_SIZE)
         derived_key = scrypt(password=password, salt=salt, digest=True)
 
-        self.password = f'{salt.hex()}{derived_key}'
+        hashed_password = f'{salt.hex()}{derived_key}'
+        await self.update(password=hashed_password)
 
-    def check_password(self, new_password: str) -> bool:
+    def check_password(self, password: str) -> bool:
         size = URANDOM_SIZE * 2
         salt = self.password[:size]
         stored_hash = self.password[size:]
-        derived_key = scrypt(password=new_password, salt=bytes.fromhex(salt), digest=True)
+        derived_key = scrypt(password=password, salt=bytes.fromhex(salt), digest=True)
 
         return derived_key == stored_hash

panther/db/queries/base_queries.py

@@ -46,7 +46,7 @@ class BaseQuery:
                 raise DatabaseError(error)
 
     @classmethod
-    def _create_model_instance(cls, document: dict):
+    async def _create_model_instance(cls, document: dict):
         """Prevent getting errors from document insertion"""
         try:
             return cls(**document)