panther 3.1.3__py3-none-any.whl → 3.1.5__py3-none-any.whl

panther/__init__.py

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

panther/_load_configs.py

@@ -1,5 +1,4 @@
 import ast
-import os
 import platform
 import sys
 from datetime import timedelta
@@ -11,7 +10,6 @@ from pydantic._internal._model_construction import ModelMetaclass
 from panther._utils import import_class
 from panther.configs import JWTConfig, config
 from panther.exceptions import PantherException
-from panther.middlewares import BaseMiddleware
 from panther.routings import finalize_urls, flatten_urls
 from panther.throttling import Throttling
 
@@ -73,6 +71,8 @@ def load_default_cache_exp(configs: dict, /) -> timedelta | None:
 
 def load_middlewares(configs: dict, /) -> list:
     """Collect The Middlewares & Set db_engine If One Of Middlewares Was For DB"""
+    from panther.middlewares import BaseMiddleware
+
     middlewares = []
 
     for path, data in configs.get('MIDDLEWARES', []):
@@ -113,52 +113,73 @@ def collect_all_models() -> list[dict]:
     """Collecting all models for panel APIs"""
     from panther.db.models import Model
 
-    collected_models = []
-
-    for root, _, files in os.walk(config['base_dir']):
-        # Traverse through each directory
-        for f in files:
-            # Traverse through each file of directory
-            if f == 'models.py':
-                slash = '\\' if platform.system() == 'Windows' else '/'
-
-                # If the file was "models.py" read it
-                file_path = f'{root}{slash}models.py'
-                with Path(file_path).open() as file:
-                    # Parse the file with ast
-                    node = ast.parse(file.read())
-                    for n in node.body:
-                        # Find classes in each element of files' body
-                        if type(n) is ast.ClassDef and n.bases:
-                            class_path = (
-                                file_path.removesuffix(f'{slash}models.py')
-                                .removeprefix(f'{config["base_dir"]}{slash}')
-                                .replace(slash, '.')
-                            )
-                            # We don't need to import the package classes
-                            if class_path.find('site-packages') == -1:
-                                # Import the class to check his parents and siblings
-                                klass = import_class(f'{class_path}.models.{n.name}')
-
-                                collected_models.extend(
-                                    [
-                                        {
-                                            'name': n.name,
-                                            'path': file_path,
-                                            'class': klass,
-                                            'app': class_path.split('.'),
-                                        }
-                                        for parent in klass.__mro__
-                                        if parent is Model
-                                    ]
-                                )
-    return collected_models
-
-
-def load_urls(configs: dict, /, urls: dict | None) -> dict:
+    # Just load all the python files from 'base_dir',
+    #   so Model.__subclasses__ can find all the subclasses
+    slash = '\\' if platform.system() == 'Windows' else '/'
+    python_files = [
+        f for f in config['base_dir'].rglob('*.py')
+        if not f.name.startswith('_') and 'site-packages' not in f.parents._parts
+    ]
+    for file in python_files:
+        # Analyse the file
+        with Path(file).open() as f:
+            node = ast.parse(f.read())
+
+        model_imported = False
+        panther_imported = False
+        panther_called = False
+        for n in node.body:
+            match n:
+
+                # from panther.db import Model
+                case ast.ImportFrom(module='panther.db', names=[ast.alias(name='Model')]):
+                    model_imported = True
+
+                # from panther.db.models import ..., Model, ...
+                case ast.ImportFrom(module='panther.db.models', names=[*names]):
+                    try:
+                        next(v for v in names if v.name == 'Model')
+                        model_imported = True
+                    except StopIteration:
+                        pass
+
+                # from panther import Panther, ...
+                case ast.ImportFrom(module='panther', names=[ast.alias(name='Panther'), *_]):
+                    panther_imported = True
+
+                # from panther import ..., Panther
+                case ast.ImportFrom(module='panther', names=[*_, ast.alias(name='Panther')]):
+                    panther_imported = True
+
+                # ... = Panther(...)
+                case ast.Assign(value=ast.Call(func=ast.Name(id='Panther'))):
+                    panther_called = True
+
+        # Panther() should not be called in the file and Model() should be imported,
+        #   We check the import of the Panther to make sure he is calling the panther.Panther and not any Panther
+        if panther_imported and panther_called or not model_imported:
+            continue
+
+        # Load the module
+        dotted_f = str(file).removeprefix(f'{config["base_dir"]}{slash}').removesuffix('.py').replace(slash, '.')
+        import_module(dotted_f)
+
+    return [
+        {
+            'name': m.__name__,
+            'module': m.__module__,
+            'class': m
+        } for m in Model.__subclasses__() if m.__module__ != 'panther.db.models'
+    ]
+
+
+def load_urls(configs: dict, /, urls: dict | None) -> tuple[dict, dict]:
+    """
+    Return tuple of all urls (as a flat dict) and (as a nested dict)
+    """
     if isinstance(urls, dict):
         collected_urls = flatten_urls(urls)
-        return finalize_urls(collected_urls)
+        return collected_urls, finalize_urls(collected_urls)
 
     if (url_routing := configs.get('URLs')) is None:
         raise _exception_handler(field='URLs', error='is required.')
@@ -182,7 +203,7 @@ def load_urls(configs: dict, /, urls: dict | None) -> dict:
         raise _exception_handler(field='URLs', error='should point to a dict.')
 
     collected_urls = flatten_urls(imported_urls)
-    return finalize_urls(collected_urls)
+    return collected_urls, finalize_urls(collected_urls)
 
 
 def load_panel_urls() -> dict:

panther/_utils.py

@@ -1,4 +1,5 @@
 import importlib
+import logging
 import re
 from collections.abc import Callable
 from traceback import TracebackException
@@ -8,7 +9,9 @@ import orjson as json
 
 from panther import status
 from panther.file_handler import File
-from panther.logger import logger
+
+
+logger = logging.getLogger('panther')
 
 
 async def _http_response_start(send: Callable, /, headers: dict, status_code: int) -> None:
@@ -42,8 +45,7 @@ async def http_response(
     elif status_code == status.HTTP_204_NO_CONTENT or body == b'null':
         body = None
 
-    if monitoring is not None:
-        await monitoring.after(status_code=status_code)
+    await monitoring.after(status_code)
 
     await _http_response_start(send, headers=headers, status_code=status_code)
     await _http_response_body(send, body=body)

panther/app.py

@@ -1,6 +1,7 @@
 import functools
 from collections.abc import Callable
 from datetime import datetime, timedelta
+import logging
 from typing import Literal
 
 from orjson import JSONDecodeError
@@ -18,7 +19,6 @@ from panther.exceptions import (
     MethodNotAllowed,
     ThrottlingException,
 )
-from panther.logger import logger
 from panther.request import Request
 from panther.response import Response
 from panther.throttling import Throttling, throttling_storage
@@ -27,6 +27,9 @@ from panther.utils import round_datetime
 __all__ = ('API', 'GenericAPI')
 
 
+logger = logging.getLogger('panther')
+
+
 class API:
     def __init__(
             self,

panther/authentications.py

@@ -1,5 +1,6 @@
 import time
 from abc import abstractmethod
+import logging
 from typing import Literal
 
 from jose import JWTError, jwt
@@ -7,10 +8,12 @@ from jose import JWTError, jwt
 from panther.configs import config
 from panther.db.models import BaseUser, IDType, Model
 from panther.exceptions import AuthenticationException
-from panther.logger import logger
 from panther.request import Request
 
 
+logger = logging.getLogger('panther')
+
+
 class BaseAuthentication:
     @classmethod
     @abstractmethod

panther/background_tasks.py

@@ -1,12 +1,12 @@
 import asyncio
 import datetime
+import logging
 import sys
 import time
 from threading import Thread
 from typing import Callable, Literal
 
 from panther._utils import is_function_async
-from panther.logger import logger
 from panther.utils import Singleton
 
 
@@ -16,6 +16,9 @@ __all__ = (
 )
 
 
+logger = logging.getLogger('panther')
+
+
 if sys.version_info.minor >= 11:
     from typing import Self
 else:

panther/base_request.py

@@ -2,8 +2,6 @@ from collections import namedtuple
 from collections.abc import Callable
 from dataclasses import dataclass
 
-from panther.db import Model
-
 
 @dataclass(frozen=True)
 class Headers:
@@ -86,8 +84,8 @@ class BaseRequest:
         return self.scope['scheme']
 
     @property
-    def user(self) -> Model:
+    def user(self):
         return self._user
 
-    def set_user(self, user: Model) -> None:
+    def set_user(self, user) -> None:
         self._user = user

panther/base_websocket.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import logging
 from typing import TYPE_CHECKING
 
 import orjson as json
@@ -10,13 +11,15 @@ 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.logger import logger
 from panther.utils import Singleton
 
 if TYPE_CHECKING:
     from redis import Redis
 
 
+logger = logging.getLogger('panther')
+
+
 class WebsocketConnections(Singleton):
     def __init__(self):
         self.connections = {}

panther/caching.py

@@ -1,16 +1,19 @@
 from collections import namedtuple
 from datetime import timedelta
+import logging
 from types import NoneType
 
 import orjson as json
 
 from panther.configs import config
 from panther.db.connection import redis
-from panther.logger import logger
 from panther.request import Request
 from panther.response import Response, ResponseDataTypes
 from panther.utils import generate_hash_value_from_string
 
+
+logger = logging.getLogger('panther')
+
 caches = {}
 CachedResponse = namedtuple('Cached', ['data', 'status_code'])
 

panther/cli/monitor_command.py

@@ -12,9 +12,12 @@ from rich.panel import Panel
 from rich.table import Table
 from watchfiles import watch
 
+from panther.cli.utils import cli_error
+from panther.configs import config
+
 
 def monitor() -> None:
-    monitoring_log_file = 'logs/monitoring.log'
+    monitoring_log_file = Path(config['base_dir'] / 'logs' / 'monitoring.log')
 
     def _generate_table(rows: deque) -> Panel:
         layout = Layout()
@@ -42,7 +45,10 @@ def monitor() -> None:
             border_style='bright_blue',
         )
 
-    with Path(monitoring_log_file).open() as f:
+    if not monitoring_log_file.exists():
+        return cli_error('Monitoring file not found. (You need at least one monitoring record for this action)')
+
+    with monitoring_log_file.open() as f:
         f.readlines()  # Set cursor at the end of file
 
         _, init_lines_count = os.get_terminal_size()

panther/cli/utils.py

@@ -1,7 +1,10 @@
-from panther.db.connection import redis
-from panther.logger import logger
+import logging
 from rich import print as rprint
 
+
+logger = logging.getLogger('panther')
+
+
 logo = r"""│    ____                 __    __                         │
 │   /\  _`\              /\ \__/\ \                        │
 │   \ \ \L\ \ __      ___\ \ ,_\ \ \___      __   _ __     │
@@ -78,21 +81,26 @@ def print_uvicorn_help_message():
 def print_info(config: dict):
     mo = config['monitoring']
     lq = config['log_queries']
-    rc = redis.is_connected
     bt = config['background_tasks']
+    ws = config['has_ws']
     bd = '{0:<39}'.format(str(config['base_dir']))
     if len(bd) > 39:
         bd = f'{bd[:36]}...'
 
+    if config['monitoring']:
+        monitor = '│ * Run "panther monitor" in another session for Monitoring│'
+    else:
+        monitor = f'│{58 * " "}│'
+
     info_message = f"""
 ╭{58 * '─'}╮
 {logo}│{58 * ' '}│
-│                                                          │
 │   Monitoring: {mo}                                  \t   │
 │   Log Queries: {lq}                                 \t   │
-│   Redis Is Connected: {rc}                          \t   │
 │   Background Tasks: {bt}                            \t   │
+│   Websocket: {ws}                                   \t   │
 │   Base directory: {bd}│
+{monitor}
 ╰{58 * '─'}╯
 """
     rprint(info_message)

panther/configs.py

@@ -41,10 +41,12 @@ class Config(TypedDict):
     authentication: ModelMetaclass | None
     jwt_config: JWTConfig | None
     models: list[dict]
+    flat_urls: dict
     urls: dict
     db_engine: str
     websocket_connections: any  # type: WebsocketConnections
     background_tasks: bool
+    has_ws: bool
 
 
 config: Config = {
@@ -60,8 +62,10 @@ config: Config = {
     'authentication': None,
     'jwt_config': None,
     'models': [],
+    'flat_urls': {},
     'urls': {},
     'db_engine': '',
     'websocket_connections': None,
     'background_tasks': False,
+    'has_ws': False,
 }

panther/db/queries/queries.py

@@ -6,7 +6,7 @@ from panther import status
 from panther.configs import config
 from panther.db.queries.mongodb_queries import BaseMongoDBQuery
 from panther.db.queries.pantherdb_queries import BasePantherDBQuery
-from panther.db.utils import log_query
+from panther.db.utils import log_query, check_connection
 from panther.exceptions import APIException, DBException
 
 BaseQuery = BasePantherDBQuery if config['db_engine'] == 'pantherdb' else BaseMongoDBQuery
@@ -55,6 +55,7 @@ class Query(BaseQuery):
 
     # # # # # Find # # # # #
     @classmethod
+    @check_connection
     @log_query
     def find_one(cls, _data: dict | None = None, /, **kwargs) -> Self | None:
         """
@@ -66,6 +67,7 @@ class Query(BaseQuery):
         return super().find_one(_data, **kwargs)
 
     @classmethod
+    @check_connection
     @log_query
     def find(cls, _data: dict | None = None, /, **kwargs) -> list[Self]:
         """
@@ -77,6 +79,7 @@ class Query(BaseQuery):
         return super().find(_data, **kwargs)
 
     @classmethod
+    @check_connection
     @log_query
     def first(cls, _data: dict | None = None, /, **kwargs) -> Self | None:
         """
@@ -89,6 +92,7 @@ class Query(BaseQuery):
         return super().first(_data, **kwargs)
 
     @classmethod
+    @check_connection
     @log_query
     def last(cls, _data: dict | None = None, /, **kwargs) -> Self | None:
         """
@@ -101,6 +105,7 @@ class Query(BaseQuery):
 
     # # # # # Count # # # # #
     @classmethod
+    @check_connection
     @log_query
     def count(cls, _data: dict | None = None, /, **kwargs) -> int:
         """
@@ -113,6 +118,7 @@ class Query(BaseQuery):
 
     # # # # # Insert # # # # #
     @classmethod
+    @check_connection
     @log_query
     def insert_one(cls, _data: dict | None = None, /, **kwargs) -> Self:
         """
@@ -125,12 +131,14 @@ class Query(BaseQuery):
         return super().insert_one(_data, **kwargs)
 
     @classmethod
+    @check_connection
     @log_query
     def insert_many(cls, _data: dict | None = None, /, **kwargs):
         msg = 'insert_many() is not supported yet.'
         raise DBException(msg)
 
     # # # # # Delete # # # # #
+    @check_connection
     @log_query
     def delete(self) -> None:
         """
@@ -143,6 +151,7 @@ class Query(BaseQuery):
         return super().delete()
 
     @classmethod
+    @check_connection
     @log_query
     def delete_one(cls, _data: dict | None = None, /, **kwargs) -> bool:
         """
@@ -154,6 +163,7 @@ class Query(BaseQuery):
         return super().delete_one(_data, **kwargs)
 
     @classmethod
+    @check_connection
     @log_query
     def delete_many(cls, _data: dict | None = None, /, **kwargs) -> int:
         """
@@ -165,6 +175,7 @@ class Query(BaseQuery):
         return super().delete_many(_data, **kwargs)
 
     # # # # # Update # # # # #
+    @check_connection
     @log_query
     def update(self, **kwargs) -> None:
         """
@@ -178,6 +189,7 @@ class Query(BaseQuery):
         return super().update(**kwargs)
 
     @classmethod
+    @check_connection
     @log_query
     def update_one(cls, _filter: dict, _data: dict | None = None, /, **kwargs) -> bool:
         """
@@ -190,6 +202,7 @@ class Query(BaseQuery):
         return super().update_one(_filter, _data, **kwargs)
 
     @classmethod
+    @check_connection
     @log_query
     def update_many(cls, _filter: dict, _data: dict | None = None, /, **kwargs) -> int:
         """
@@ -203,7 +216,6 @@ class Query(BaseQuery):
 
     # # # # # Other # # # # #
     @classmethod
-    @log_query
     def find_or_insert(cls, **kwargs) -> tuple[bool, any]:
         """
         Example:
@@ -216,7 +228,6 @@ class Query(BaseQuery):
         return True, cls.insert_one(**kwargs)
 
     @classmethod
-    @log_query
     def find_one_or_raise(cls, **kwargs) -> Self:
         """
         Example:
@@ -232,6 +243,7 @@ class Query(BaseQuery):
             status_code=status.HTTP_404_NOT_FOUND,
         )
 
+    @check_connection
     @log_query
     def save(self, **kwargs) -> None:
         """

panther/db/utils.py

@@ -1,3 +1,4 @@
+import logging
 import operator
 from functools import reduce
 from time import perf_counter
@@ -5,23 +6,38 @@ from time import perf_counter
 import bson
 
 from panther.configs import config
-from panther.logger import query_logger
+
+
+logger = logging.getLogger('query')
 
 
 def log_query(func):
     def log(*args, **kwargs):
+        # Check Database Connection
+        if config['db_engine'] == '':
+            msg = "You don't have active database connection, Check your middlewares"
+            raise NotImplementedError(msg)
+
         if config['log_queries'] is False:
             return func(*args, **kwargs)
         start = perf_counter()
         response = func(*args, **kwargs)
         end = perf_counter()
         class_name = args[0].__name__ if hasattr(args[0], '__name__') else args[0].__class__.__name__
-        query_logger.info(f'\033[1mQuery -->\033[0m  {class_name}.{func.__name__}() --> {(end - start) * 1_000:.2} ms')
+        logger.info(f'\033[1mQuery -->\033[0m  {class_name}.{func.__name__}() --> {(end - start) * 1_000:.2} ms')
         return response
-
     return log
 
 
+def check_connection(func):
+    def wrapper(*args, **kwargs):
+        if config['db_engine'] == '':
+            msg = "You don't have active database connection, Check your middlewares"
+            raise NotImplementedError(msg)
+        return func(*args, **kwargs)
+    return wrapper
+
+
 def prepare_id_for_query(*args, is_mongo: bool = False):
     for d in args:
         if d is None:

panther/logging.py

@@ -0,0 +1,68 @@
+import logging
+from pathlib import Path
+from panther.configs import config
+
+LOGS_DIR = config['base_dir'] / 'logs'
+
+
+class FileHandler(logging.FileHandler):
+    def __init__(self, filename, mode='a', encoding=None, delay=False, errors=None):
+        Path(LOGS_DIR).mkdir(exist_ok=True)
+        logging.FileHandler.__init__(self, filename, mode=mode, encoding=encoding, delay=delay, errors=errors)
+
+
+LOGGING = {
+    'version': 1,
+    'disable_existing_loggers': False,
+    'formatters': {
+        'default': {
+            '()': 'uvicorn.logging.DefaultFormatter',
+            'fmt': '%(levelprefix)s | %(asctime)s | %(message)s',
+            'datefmt': '%Y-%m-%d %H:%M:%S',
+        },
+        'panther_file_formatter': {
+            '()': 'uvicorn.logging.DefaultFormatter',
+            'fmt': '%(asctime)s | %(message)s',
+            'datefmt': '%Y-%m-%d %H:%M:%S',
+        },
+    },
+    'handlers': {
+        'panther_file': {
+            'formatter': 'panther_file_formatter',
+            'filename': LOGS_DIR / 'main.log',
+            'class': 'panther.logging.FileHandler',
+            'delay': True,
+        },
+        'monitoring_file': {
+            'formatter': 'panther_file_formatter',
+            'filename': LOGS_DIR / 'monitoring.log',
+            'class': 'panther.logging.FileHandler',
+            'delay': True,
+        },
+        'query_file': {
+            'formatter': 'panther_file_formatter',
+            'filename': LOGS_DIR / 'query.log',
+            'class': 'panther.logging.FileHandler',
+            'delay': True,
+        },
+        'default': {
+            'formatter': 'default',
+            'class': 'logging.StreamHandler',
+            'stream': 'ext://sys.stderr',
+        },
+    },
+    'loggers': {
+        'panther': {
+            'handlers': ['default', 'panther_file'],
+            'level': 'DEBUG',
+        },
+        'monitoring': {
+            'handlers': ['monitoring_file'],
+            'level': 'DEBUG',
+        },
+        'query': {
+            'handlers': ['default', 'query_file'],
+            'level': 'DEBUG',
+        }
+    }
+}

panther/main.py

@@ -1,10 +1,13 @@
 import contextlib
+import logging
 import sys
 import types
 from collections.abc import Callable
+from logging.config import dictConfig
 from pathlib import Path
 from threading import Thread
 
+import panther.logging
 from panther import status
 from panther._load_configs import *
 from panther._utils import clean_traceback_message, http_response
@@ -12,18 +15,18 @@ from panther.background_tasks import background_tasks
 from panther.cli.utils import print_info
 from panther.configs import config
 from panther.exceptions import APIException, PantherException
-from panther.middlewares.monitoring import Middleware as MonitoringMiddleware
+from panther.monitoring import Monitoring
 from panther.request import Request
 from panther.response import Response
 from panther.routings import collect_path_variables, find_endpoint
 
-""" We can't import logger on the top cause it needs config['base_dir'] ans its fill in __init__ """
+
+dictConfig(panther.logging.LOGGING)
+logger = logging.getLogger('panther')
 
 
 class Panther:
     def __init__(self, name: str, configs=None, urls: dict | None = None):
-        from panther.logger import logger
-
         self._configs = configs
         self._urls = urls
         config['base_dir'] = Path(name).resolve().parent
@@ -37,22 +40,21 @@ class Panther:
                 logger.error(clean_traceback_message(e))
             sys.exit()
 
-        # Start Websocket Listener (Redis Required)
-        Thread(
-            target=self.websocket_connections,
-            daemon=True,
-            args=(self.ws_redis_connection,),
-        ).start()
+        # Monitoring
+        self.monitoring = Monitoring(is_active=config['monitoring'])
 
         # Print Info
         print_info(config)
-        if config['monitoring']:
-            logger.info('Run "panther monitor" in another session for Monitoring.')
-        if sys.version_info < (3, 11):
-            logger.warning('Use Python Version 3.11+ For Better Performance.')
+
+        # Start Websocket Listener (Redis Required)
+        if config['has_ws']:
+            Thread(
+                target=self.websocket_connections,
+                daemon=True,
+                args=(self.ws_redis_connection,),
+            ).start()
 
     def load_configs(self) -> None:
-        from panther.logger import logger
 
         # Check & Read The Configs File
         self.configs = load_configs_file(self._configs)
@@ -71,58 +73,74 @@ class Panther:
         config['jwt_config'] = load_jwt_config(self.configs)
         config['models'] = collect_all_models()
 
-        # Create websocket connections instance
-        from panther.websocket import WebsocketConnections
-
-        config['websocket_connections'] = self.websocket_connections = WebsocketConnections()
-        # Websocket Redis Connection
-        for middleware in config['middlewares']:
-            if middleware.__class__.__name__ == 'RedisMiddleware':
-                self.ws_redis_connection = middleware.redis_connection_for_ws()
-                break
-        else:
-            self.ws_redis_connection = None
-
         # Initialize Background Tasks
         if config['background_tasks']:
             background_tasks.initialize()
 
-        # Load URLs should be the last call in load_configs,
+        # Load URLs should be one of the last calls in load_configs,
         #   because it will read all files and loads them.
-        config['urls'] = load_urls(self.configs, urls=self._urls)
+        config['flat_urls'], config['urls'] = load_urls(self.configs, urls=self._urls)
         config['urls']['_panel'] = load_panel_urls()
 
+        self._create_ws_connections_instance()
+
+    def _create_ws_connections_instance(self):
+        from panther.base_websocket import Websocket
+        from panther.websocket import WebsocketConnections
+
+        # Check do we have ws endpoint
+        for endpoint in config['flat_urls'].values():
+            if not isinstance(endpoint, types.FunctionType) and issubclass(endpoint, Websocket):
+                config['has_ws'] = True
+                break
+        else:
+            config['has_ws'] = False
+
+        # Create websocket connections instance
+        if config['has_ws']:
+            config['websocket_connections'] = self.websocket_connections = WebsocketConnections()
+            # Websocket Redis Connection
+            for middleware in config['middlewares']:
+                if middleware.__class__.__name__ == 'RedisMiddleware':
+                    self.ws_redis_connection = middleware.redis_connection_for_ws()
+                    break
+            else:
+                self.ws_redis_connection = None
+
     async def __call__(self, scope: dict, receive: Callable, send: Callable) -> None:
         """
         1.
-            async with asyncio.TaskGroup() as tg:
-                tg.create_task(self.run(scope, receive, send))
+            await func(scope, receive, send)
         2.
-            await self.run(scope, receive, send)
+            async with asyncio.TaskGroup() as tg:
+                tg.create_task(func(scope, receive, send))
         3.
             async with anyio.create_task_group() as task_group:
-                task_group.start_soon(self.run, scope, receive, send)
-                await anyio.to_thread.run_sync(self.run, scope, receive, send)
+                task_group.start_soon(func, scope, receive, send)
+                await anyio.to_thread.run_sync(func, scope, receive, send)
         4.
             with ProcessPoolExecutor() as e:
-                e.submit(self.run, scope, receive, send)
+                e.submit(func, scope, receive, send)
         """
         func = self.handle_http if scope['type'] == 'http' else self.handle_ws
         await func(scope=scope, receive=receive, send=send)
 
     async def handle_ws(self, scope: dict, receive: Callable, send: Callable) -> None:
-        from panther.logger import logger
         from panther.websocket import GenericWebsocket, Websocket
+        monitoring = Monitoring(is_active=config['monitoring'], is_ws=True)
 
         temp_connection = Websocket(scope=scope, receive=receive, send=send)
+        await monitoring.before(request=temp_connection)
 
         endpoint, found_path = find_endpoint(path=temp_connection.path)
         if endpoint is None:
+            await monitoring.after('Rejected')
             return await temp_connection.close(status.WS_1000_NORMAL_CLOSURE)
         path_variables: dict = collect_path_variables(request_path=temp_connection.path, found_path=found_path)
 
         if not issubclass(endpoint, GenericWebsocket):
             logger.critical(f'You may have forgotten to inherit from GenericWebsocket on the {endpoint.__name__}()')
+            await monitoring.after('Rejected')
             return await temp_connection.close(status.WS_1014_BAD_GATEWAY)
 
         del temp_connection
@@ -138,24 +156,22 @@ class Panther:
                 break
         else:
             await self.websocket_connections.new_connection(connection=connection)
+            await monitoring.after('Accepted')
             await connection.listen()
 
         # Call 'After' Middleware
         for middleware in config['reversed_middlewares']:
             with contextlib.suppress(APIException):
                 await middleware.after(response=connection)
+
+        await monitoring.after('Closed')
         return None
 
     async def handle_http(self, scope: dict, receive: Callable, send: Callable) -> None:
-        from panther.logger import logger
-
         request = Request(scope=scope, receive=receive, send=send)
 
-        # Monitoring Middleware
-        monitoring_middleware = None
-        if config['monitoring']:
-            monitoring_middleware = MonitoringMiddleware()
-            await monitoring_middleware.before(request=request)
+        # Monitoring
+        await self.monitoring.before(request=request)
 
         # Read Request Payload
         await request.read_body()
@@ -168,7 +184,7 @@ class Panther:
             return await http_response(
                 send,
                 status_code=status.HTTP_404_NOT_FOUND,
-                monitoring=monitoring_middleware,
+                monitoring=self.monitoring,
                 exception=True,
             )
 
@@ -185,7 +201,7 @@ class Panther:
                     return await http_response(
                         send,
                         status_code=status.HTTP_501_NOT_IMPLEMENTED,
-                        monitoring=monitoring_middleware,
+                        monitoring=self.monitoring,
                         exception=True,
                     )
 
@@ -201,7 +217,7 @@ class Panther:
                     return await http_response(
                         send,
                         status_code=status.HTTP_501_NOT_IMPLEMENTED,
-                        monitoring=monitoring_middleware,
+                        monitoring=self.monitoring,
                         exception=True,
                     )
                 # Declare Endpoint
@@ -220,7 +236,7 @@ class Panther:
             return await http_response(
                 send,
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                monitoring=monitoring_middleware,
+                monitoring=self.monitoring,
                 exception=True,
             )
 
@@ -234,7 +250,7 @@ class Panther:
         await http_response(
             send,
             status_code=response.status_code,
-            monitoring=monitoring_middleware,
+            monitoring=self.monitoring,
             headers=response.headers,
             body=response.body,
         )

panther/middlewares/redis.py

@@ -1,13 +1,16 @@
+import logging
 from redis import Redis
 
 from panther.db.connection import RedisConnection
-from panther.logger import logger
 from panther.middlewares.base import BaseMiddleware
 from panther.request import Request
 from panther.response import Response
 from panther.websocket import GenericWebsocket
 
 
+logger = logging.getLogger('panther')
+
+
 class RedisMiddleware(BaseMiddleware):
     def __init__(self, **kwargs):
         self.kwargs = kwargs
@@ -35,4 +38,6 @@ class RedisMiddleware(BaseMiddleware):
         return response
 
     def redis_connection_for_ws(self) -> Redis:
-        return Redis(**self.kwargs)
+        r = Redis(**self.kwargs)
+        r.ping()
+        return r

panther/monitoring.py

@@ -0,0 +1,41 @@
+import logging
+from time import perf_counter
+from typing import Literal
+
+from panther.base_request import BaseRequest
+
+
+logger = logging.getLogger('monitoring')
+
+
+class Monitoring:
+    """
+    Create Log Message Like Below:
+    date time | method | path | ip:port | response_time [ms, s] | status
+    """
+    def __init__(self, is_active: bool, is_ws: bool = False):
+        self.is_active = is_active
+        self.is_ws = is_ws
+
+    async def before(self, request: BaseRequest):
+        if self.is_active:
+            ip, port = request.client
+
+            if self.is_ws:
+                method = 'WS'
+            else:
+                method = request.scope['method']
+
+            self.log = f'{method} | {request.path} | {ip}:{port}'
+            self.start_time = perf_counter()
+
+    async def after(self, status: int | Literal['Accepted', 'Rejected', 'Closed'], /):
+        if self.is_active:
+            response_time = perf_counter() - self.start_time
+            time_unit = ' s'
+
+            if response_time < 0.01:
+                response_time = response_time * 1_000
+                time_unit = 'ms'
+
+            logger.info(f'{self.log} | {round(response_time, 4)} {time_unit} | {status}')

panther/panel/apis.py

@@ -8,16 +8,11 @@ from panther.response import Response
 
 @API()
 async def models_api():
-    result = []
-    for i, m in enumerate(config['models']):
-        data = {
-            'name': m['name'],
-            'app': '.'.join(a for a in m['app']),
-            'path': m['path'],
-            'index': i
-        }
-        result.append(data)
-    return result
+    return [{
+        'name': m['name'],
+        'module': m['module'],
+        'index': i
+    } for i, m in enumerate(config['models'])]
 
 
 @API()

panther/request.py

@@ -1,10 +1,13 @@
+import logging
 from typing import Literal
 
 import orjson as json
 
 from panther._utils import read_multipart_form_data
 from panther.base_request import BaseRequest
-from panther.logger import logger
+
+
+logger = logging.getLogger('panther')
 
 
 class Request(BaseRequest):

panther/routings.py

@@ -1,3 +1,4 @@
+import logging
 import re
 from collections import Counter
 from collections.abc import Callable, Mapping, MutableMapping
@@ -7,6 +8,9 @@ from functools import partial, reduce
 from panther.configs import config
 
 
+logger = logging.getLogger('panther')
+
+
 def flatten_urls(urls: dict) -> dict:
     return dict(_flattening_urls(urls))
 
@@ -29,8 +33,6 @@ def _flattening_urls(data: dict | Callable, url: str = ''):
 
 
 def _is_url_endpoint_valid(url: str, endpoint: Callable) -> bool:
-    from panther.logger import logger
-
     if endpoint is ...:
         logger.error(f"URL Can't Point To Ellipsis. ('{url}' -> ...)")
     elif endpoint is None:

panther/utils.py

@@ -1,9 +1,12 @@
+import logging
+import os
 import hashlib
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import ClassVar
 
-from panther.logger import logger
+
+logger = logging.getLogger('panther')
 
 
 class Singleton(object):
@@ -30,6 +33,9 @@ def load_env(env_file: str | Path, /) -> dict[str, str]:
                 key = key.strip()
                 value = value.strip().strip('"\'')
                 variables[key] = value
+
+                # Load them as system environment variable
+                os.environ[key] = value
     return variables
 
 

{panther-3.1.3.dist-info → panther-3.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: panther
-Version: 3.1.3
+Version: 3.1.5
 Summary: Fast &  Friendly, Web Framework For Building Async APIs
 Home-page: https://github.com/alirn76/panther
 Author: Ali RajabNezhad
@@ -18,7 +18,7 @@ Requires-Dist: bson ~=0.5
 Requires-Dist: httptools ~=0.6
 Requires-Dist: pantherdb ~=1.3
 Requires-Dist: pydantic ~=2.1
-Requires-Dist: redis ~=5.0
+Requires-Dist: redis ==5.0.1
 Requires-Dist: rich ~=13.5
 Requires-Dist: uvicorn ~=0.23
 Requires-Dist: watchfiles ~=0.19

{panther-3.1.3.dist-info → panther-3.1.5.dist-info}/RECORD

@@ -1,53 +1,53 @@
-panther/__init__.py,sha256=B9pXYy0ONjwd2TV6rRd6ZBmRCRdZ_DkwoQw6zgG--kw,110
-panther/_load_configs.py,sha256=D3RPY5VOVzcmbp4AbzVJL8YHykiOo_h2Em3gvzHC64A,6996
-panther/_utils.py,sha256=A_cr2AZRtwiWFvPAEGufbmt3ktBlAUJ_rvbtxzEPtfs,4372
-panther/app.py,sha256=HnU2Mkj4991da-ln5DfmHrrPMXjQee4AJFcy6soDMyQ,7940
-panther/authentications.py,sha256=mjAjZ-AhL717qn3T6QtjFNTTLXTU_LPtHb0R9nHyGpo,4128
-panther/background_tasks.py,sha256=oHIEJsqPGN-qfjJTwhCJ_LO5mllQDmPOuwfZCUAlg5M,7204
-panther/base_request.py,sha256=N8oV-tRLNNo9n4shAD5tolT4u8yOV7yUz3A-5b9rSvw,2797
-panther/base_websocket.py,sha256=BpBtS6FO_swqeF5fx6-Sz6K2j5JVT-sL_toKsN7LJn4,6140
-panther/caching.py,sha256=vSUFb3SolXO3r1v-KSMoOt2T1Y1OnUyKb1Hj4xTyNcI,2532
-panther/configs.py,sha256=XSQ0AkT70r4lCa6s37DcfSpuh5xwOCHxO24DBynOTWE,1841
+panther/__init__.py,sha256=6LwXZVmGyh5YmGDfYREWyRqoMsv9NiCxNibakKFUzJo,110
+panther/_load_configs.py,sha256=S5zN5ErktjXCIi7cgg8HZwRCez51qiYxa1Ppu2No9Xw,7476
+panther/_utils.py,sha256=H0VIv9VPt7mIDZo-N7x5ZaMMes1jo60wp1TtxkNvFnQ,4346
+panther/app.py,sha256=8-W1XsOfVjNcP1RxV8X9TgQzshP9Qk9E0LBcXBf25aM,7961
+panther/authentications.py,sha256=Fh7Z7rpysSJXN9xEKJqH94oYf2L3jJQxr6fPhRz3UFg,4149
+panther/background_tasks.py,sha256=J6JrjiEzyGohYsaFZHnZtXeP52piP84RlGFLsKOFa-Y,7225
+panther/base_request.py,sha256=GhKfPdDDl-r9l9ro8DWnUNtC_10Nh1EhVy8lX4ULLhs,2751
+panther/base_websocket.py,sha256=aaonC-7EAdA9fkzVQobTS-a-tTvdjI6cnMSMIMUdW6Q,6161
+panther/caching.py,sha256=Kwhhv0fqCRWbYiq12jwiTdedSSsTy3z_NTBjWdUPgnA,2553
+panther/configs.py,sha256=lvmPDT_W8gnXNv214zLQedYFZhM78E-3XGa7KyWQbo4,1920
 panther/exceptions.py,sha256=DB6nGfU5LxrglEN_I-HInMqdIA3ZmN8rRv0ynEuQyGA,1332
 panther/file_handler.py,sha256=b-paQykGfjlvslfEkM23V50v8bosjRLq1S1HmsmlXEc,855
-panther/logger.py,sha256=aWUY9QtwjvrENpJuBmySx2b1MNn_zbwE5G8yFHMYSmM,2602
-panther/main.py,sha256=jPoG-ssIArUuCJJ6_AHzxm_Bmg_T6vgALS9uLpGS5TA,9894
+panther/logging.py,sha256=DZVf3nxzLodT-hD4820J1jEAffU8zIxXRPKs2lbP8ho,2074
+panther/main.py,sha256=F8yGaVN97JMD0FKWvTPuGZ43g1BGdEEtDzjWSelG4mg,10301
+panther/monitoring.py,sha256=krmcoTUcV12pHwCFVAHywgsp1-US9cyiMlgsrMJdUQ0,1203
 panther/permissions.py,sha256=Q-l25369yQaP-tY11tFQm-v9PPh8iVImbfUpY3pnQUk,355
-panther/request.py,sha256=LpQGbyLLLD9I9_7BAVRdk1hlbfekmsjDV10eJq6RjXQ,1752
+panther/request.py,sha256=W3L_udvIxgjqVxxc8aaKDIQBVjdc7TTrFyoOJQ8M8FA,1773
 panther/response.py,sha256=HcL8nuXpZX_vhT9QUw0dnbtP75T_LbvKAWGT48_LPuU,3382
-panther/routings.py,sha256=3_4IFL7sXZBrCCnCfGVzogCAlqP_40w3b-sJBHLjgbU,5124
+panther/routings.py,sha256=Y5FH5Of7zf--mhjFt26G6bTKcTZyL5XkQoVLqAHxfGM,5140
 panther/status.py,sha256=Gc_PnYrHfInTsZpGbqiCfDB-py1C7Rh8KMdb6Lq9Exs,3346
 panther/test.py,sha256=withvHE4Vsv7hakPMfadoKBP59jB0-CMzMNBgEuiCbM,4748
 panther/throttling.py,sha256=mVa_mGv6w_Ad7LLtV4eG5QpDwwNsk4QjFFi0mIHQBnE,231
-panther/utils.py,sha256=SeuAAG3UU6urOcWzmMQ7yG1Wt6f3o7ocNTtK53iDyLk,1622
+panther/utils.py,sha256=6MjJSJgWeYn2rWMlqS4_kwyhfipJPWser03JAVBy-_s,1752
 panther/websocket.py,sha256=KKnSqgnaP5-BsA87qUM7Y176ECWSnBWZ5ENbJBo8BiU,2167
 panther/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 panther/cli/create_command.py,sha256=1OFNE9pk2mhXNQMzjdDEtp0RocHy0u6kyhrhlLso1DM,2932
 panther/cli/main.py,sha256=84k70hh9BXU5fegNR44JZN7eH7AOz4bXotRJLbNQ55w,1894
-panther/cli/monitor_command.py,sha256=ovnYCfySm4hlNGCTLSYKZAvRAYz8a9kF6JBTqpBhRCA,2191
+panther/cli/monitor_command.py,sha256=cZ7wOxeQ8jKXgRLP28SgFI9pbIEp4RK6VmVf74WKT6c,2447
 panther/cli/run_command.py,sha256=X8DTHPyfpC7h9HNpVDhpjUN52buauEgAwxlCV0MIloQ,2020
 panther/cli/template.py,sha256=kXLsT2YANV0pw1L82H3epgAaICcy3SuHmH8QuAxnxHQ,3044
-panther/cli/utils.py,sha256=a5nVysMM6gi5eh-GMNFIchl-1OL0YaBoAMmLuQ3aG0w,3549
+panther/cli/utils.py,sha256=fOLlUAUqQ8_-GP_23RhgXjyDpIS260LazIYs8W9mNOk,3637
 panther/db/__init__.py,sha256=w9lEL0vRqb18Qx_iUJipUR_fi5GQ5uVX0DWycx14x08,50
 panther/db/connection.py,sha256=UwssfAXwCRNveT_dMr51n9Pu9AdMcC4IYuv8aT5Y27c,2323
 panther/db/models.py,sha256=VytEvIRgI12Co3WyDsN8lycf_AWMRdOCZt4JOa1P_n0,1464
-panther/db/utils.py,sha256=X0XDonolAfZSvemn0MfuWWQYxwGUz-xZeLfsIm3jl6c,1325
+panther/db/utils.py,sha256=G1TcS9cBAA7AmIBNvXRK-4DRsnho1zYYhZ5ogP9IBvQ,1822
 panther/db/queries/__init__.py,sha256=FpSQGNHGMs5PJow8Qan4eBAld6QH6wfMvj7lC92vKcU,55
 panther/db/queries/mongodb_queries.py,sha256=17yq8J7m5_312Eb4XYitE3tAcfUjGgPMGBhRa4eB7K4,3358
 panther/db/queries/pantherdb_queries.py,sha256=giFLUxjmQykuZOySlBxQa5z6ex49H_8ZrKWzOno1NpU,3269
-panther/db/queries/queries.py,sha256=qFnlda2CEP4BnOfwkhvjFIpVaI0JoLNXDntNulNgWpQ,7302
+panther/db/queries/queries.py,sha256=5DAaTCLu-SfWHjJUnaLcr6HqSn6fAe11fjgB-7BqGMU,7598
 panther/middlewares/__init__.py,sha256=ydo0bSadGqa2v7Xy1oCTkF2uXrImedXjiyx2vPTwPhE,66
 panther/middlewares/base.py,sha256=kBJp0U6982pfwDRSzDfMRfdUra9oVoL9Ms52EavW0r4,239
 panther/middlewares/db.py,sha256=Dotc7LPKEZ26w3yK0SY_PhO47JEKJtYpVZPO9SLA2Lg,638
-panther/middlewares/monitoring.py,sha256=7STDDmup3vEdzp3oHSO2HSqM1qYfy-gF-XgnqG8c9Xc,863
-panther/middlewares/redis.py,sha256=A1JuYnCndwekoq7PC9N5ujZUKkqZklU4HLke5t10usU,1322
+panther/middlewares/redis.py,sha256=Wa_uvTe2yGw9LYO1CehrUYYXc6hdyNMOJc7X5lDJ5LU,1374
 panther/panel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-panther/panel/apis.py,sha256=9sKeAbVeRJV-FSTgz88waeLcTFWzcP4iYm5tmBgPrJk,1834
+panther/panel/apis.py,sha256=f4eWTi212ZnnPYcxuU4SdJ-7yYQxZFImaXgTTnXw_fc,1703
 panther/panel/urls.py,sha256=BQkWqSJBPP3VEQYeorKSHIRx-PUl21Y7Z6NFylmhs1I,192
 panther/panel/utils.py,sha256=0Rv79oR5IEqalqwpRKQHMn1p5duVY5mxMqDKiA5mWx4,437
-panther-3.1.3.dist-info/LICENSE,sha256=2aF1hL2aC0zRPjzUkSxJUzZbn2_uLoOkn7DHjzZni-I,1524
-panther-3.1.3.dist-info/METADATA,sha256=XYEK2AmEUPZ_0wnVvujumAYOA93VLZ7e1rTmElX8a4Q,6074
-panther-3.1.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-panther-3.1.3.dist-info/entry_points.txt,sha256=6GPxYFGuzVfNB4YpHFJvYex6iWah5_tLnirAHwj2Qsg,51
-panther-3.1.3.dist-info/top_level.txt,sha256=VbBs02JGXTIoHMzsX-eLOk2MCbBZzQbLhWiYpI7xI2g,8
-panther-3.1.3.dist-info/RECORD,,
+panther-3.1.5.dist-info/LICENSE,sha256=2aF1hL2aC0zRPjzUkSxJUzZbn2_uLoOkn7DHjzZni-I,1524
+panther-3.1.5.dist-info/METADATA,sha256=YmW-daTXDu085RPgfX1YbQYKkq6SewmDkw4QR50E-eY,6076
+panther-3.1.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+panther-3.1.5.dist-info/entry_points.txt,sha256=6GPxYFGuzVfNB4YpHFJvYex6iWah5_tLnirAHwj2Qsg,51
+panther-3.1.5.dist-info/top_level.txt,sha256=VbBs02JGXTIoHMzsX-eLOk2MCbBZzQbLhWiYpI7xI2g,8
+panther-3.1.5.dist-info/RECORD,,

panther/logger.py

@@ -1,89 +0,0 @@
-import logging
-from logging.config import dictConfig
-from pathlib import Path
-
-from pydantic import BaseModel
-
-from panther.configs import config
-
-LOGS_DIR = config['base_dir'] / 'logs'
-
-
-class LogConfig(BaseModel):
-    """Logging configuration to be set for the server."""
-
-    LOGGER_NAME: str = 'panther-logger'
-    DEFAULT_LOG_FORMAT: str = '%(levelprefix)s | %(asctime)s | %(message)s'
-    FILE_LOG_FORMAT: str = '%(asctime)s | %(message)s'
-    LOG_LEVEL: str = 'DEBUG'
-    MAX_FILE_SIZE: int = 1024 * 1024 * 100  # 100 MB
-
-    version: int = 1
-    disable_existing_loggers: bool = False
-
-    formatters: dict = {
-        'default': {
-            '()': 'uvicorn.logging.DefaultFormatter',
-            'fmt': DEFAULT_LOG_FORMAT,
-            'datefmt': '%Y-%m-%d %H:%M:%S',
-        },
-        'file_formatter': {
-            '()': 'uvicorn.logging.DefaultFormatter',
-            'fmt': FILE_LOG_FORMAT,
-            'datefmt': '%Y-%m-%d %H:%M:%S',
-        },
-    }
-    handlers: dict = {
-        'monitoring_file': {
-            'formatter': 'file_formatter',
-            'filename': LOGS_DIR / 'monitoring.log',
-            'class': 'logging.handlers.RotatingFileHandler',
-            'maxBytes': MAX_FILE_SIZE,  # 100 MB,
-            'backupCount': 3,
-        },
-        'query_file': {
-            'formatter': 'file_formatter',
-            'filename': LOGS_DIR / 'query.log',
-            'class': 'logging.handlers.RotatingFileHandler',
-            'maxBytes': MAX_FILE_SIZE,  # 100 MB,
-            'backupCount': 3,
-        },
-        'file': {
-            'formatter': 'file_formatter',
-            'filename': LOGS_DIR / 'main.log',
-            'class': 'logging.handlers.RotatingFileHandler',
-            'maxBytes': MAX_FILE_SIZE,  # 100 MB,
-            'backupCount': 3,
-        },
-        'default': {
-            'formatter': 'default',
-            'class': 'logging.StreamHandler',
-            'stream': 'ext://sys.stderr',
-        },
-    }
-    loggers: dict = {
-        'panther': {
-            'handlers': ['default', 'file'],
-            'level': LOG_LEVEL,
-        },
-        'monitoring': {
-            'handlers': ['monitoring_file'],
-            'level': LOG_LEVEL,
-        },
-        'query': {
-            'handlers': ['default', 'query_file'],
-            'level': LOG_LEVEL,
-        },
-    }
-
-
-try:
-    dictConfig(LogConfig().model_dump())
-except ValueError:
-    LOGS_DIR = config['base_dir'] / 'logs'
-    Path(LOGS_DIR).mkdir(exist_ok=True)
-
-
-logger = logging.getLogger('panther')
-query_logger = logging.getLogger('query')
-monitoring_logger = logging.getLogger('monitoring')

panther/middlewares/monitoring.py

@@ -1,26 +0,0 @@
-from time import perf_counter
-
-from panther.logger import monitoring_logger
-from panther.middlewares.base import BaseMiddleware
-from panther.request import Request
-
-
-class Middleware(BaseMiddleware):
-    """
-    Create Log Message Like Below:
-    [method] path | ip:port | response_time ms | status_code
-    """
-
-    async def before(self, request: Request) -> Request:
-        ip, port = request.client
-        self.log = f'{request.method} | {request.path} | {ip}:{port}'
-        self.start_time = perf_counter()
-        return request
-
-    async def after(self, status_code: int):
-        """
-        We handled Monitoring Middle manually,
-        cause of that we only have "status_code" here
-        """
-        response_time = (perf_counter() - self.start_time) * 1_000
-        monitoring_logger.info(f'{self.log} | {response_time: .3} ms | {status_code}')