panther 1.3.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

panther/__init__.py

@@ -1,6 +1,6 @@
 from .main import Panther
 
-__version__ = '1.3.2'
+__version__ = '1.5.0'
 
 
 def version():

panther/cli/template.py

@@ -65,6 +65,8 @@ USER_MODEL = 'panther.db.models.User'
 
 MONITORING = True
 
+LOG_QUERIES = True
+
 URLs = 'core/urls.py'
 """ % datetime.now().date().isoformat()
 

panther/configs.py

@@ -15,6 +15,7 @@ class JWTConfig:
 class Config(TypedDict):
     base_dir: Path
     monitoring: bool
+    log_queries: bool
     urls: dict
     middlewares: list
     reversed_middlewares: list
@@ -28,7 +29,8 @@ class Config(TypedDict):
 
 config: Config = {
     'base_dir': Path(),
-    'monitoring': True,
+    'monitoring': False,
+    'log_queries': False,
     'secret_key': None,
     'urls': {},
     'middlewares': [],

panther/db/connection.py

@@ -1,6 +1,7 @@
 from redis import Redis
 from pantherdb import PantherDB
 from panther.configs import config
+from panther.cli.utils import error
 
 
 class Singleton(object):
@@ -19,9 +20,8 @@ class DBSession(Singleton):
         if db_url:
             self._db_name = db_url[:db_url.find(':')]
             match self._db_name:
-                # case 'mongodb':
-                #     # TODO: Check pymongo installed or not
-                #     self._create_mongodb_session(db_url)
+                case 'mongodb':
+                    self._create_mongodb_session(db_url)
                 case 'pantherdb':
                     self._create_pantherdb_session(db_url[12:])
                 case _:
@@ -37,8 +37,12 @@ class DBSession(Singleton):
         return self._db_name
 
     def _create_mongodb_session(self, db_url: str) -> None:
-        from pymongo import MongoClient
-        from pymongo.database import Database
+        try:
+            from pymongo import MongoClient
+            from pymongo.database import Database
+        except ImportError:
+            error('No module named "pymongo"\n\nHint: Try to install with "pip install pymongo"')
+            raise ImportError(error)
         self._client: MongoClient = MongoClient(db_url)
         self._session: Database = self._client.get_database()
 
@@ -56,7 +60,6 @@ class RedisConnection(Singleton, Redis):
     is_connected: bool = False
 
     def __init__(self, host: str | None = None, port: int | None = None, **kwargs):
-        # TODO: Check redis installed or not
         if host and port:
             super().__init__(host=host, port=port, **kwargs)
             self.is_connected = True

panther/db/queries/mongodb_queries.py

@@ -1,102 +1,85 @@
-from typing import TypeVar
-
-import bson
+from typing import Self
 
 from panther.db.connection import db  # NOQA: F401
-from panther.db.utils import clean_object_id_in_dicts, merge_dicts, query_logger
-
-# TODO: Not sure about this bounding
-T = TypeVar('T', bound='BaseMongoDBQuery')
+from panther.exceptions import DBException
+from panther.db.utils import clean_object_id_in_dicts, merge_dicts
 
 
 class BaseMongoDBQuery:
 
     @classmethod
-    @query_logger
-    def get_one(cls: type[T], _data: dict = None, /, **kwargs) -> T:
-        clean_object_id_in_dicts(_data, kwargs)
-        _query = merge_dicts(_data, kwargs)
-        obj = eval(f'db.session.{cls.__name__}.find_one(_query)')
-        return cls(**obj) if obj else None
+    def _merge(cls, *args) -> dict:
+        clean_object_id_in_dicts(*args)
+        # TODO: Convert "id" to "_id"
+        return merge_dicts(*args)
 
+    # # # # # Find # # # # #
     @classmethod
-    @query_logger
-    def count(cls, _data: dict = None, /, **kwargs) -> int:
-        clean_object_id_in_dicts(_data, kwargs)
-        _query = merge_dicts(_data, kwargs)
-        return eval(f'db.session.{cls.__name__}.count_documents(_query)')
+    def find_one(cls, _data: dict = None, /, **kwargs) -> Self | None:
+        _query = cls._merge(_data, kwargs)
+        if document := eval(f'db.session.{cls.__name__}.find_one(_query)'):
+            return cls(**document)
 
     @classmethod
-    @query_logger
-    def list(cls, _data: dict = None, /, **kwargs):
-        clean_object_id_in_dicts(_data, kwargs)
-        _query = merge_dicts(_data, kwargs)
-        result = eval(f'db.session.{cls.__name__}.find(_query)')
-        return [cls(**obj) for obj in result]
+    def find(cls, _data: dict = None, /, **kwargs) -> list[Self]:
+        _query = cls._merge(_data, kwargs)
+        documents = eval(f'db.session.{cls.__name__}.find(_query)')
+        return [cls(**document) for document in documents]
 
+    # # # # # Insert # # # # #
     @classmethod
-    @query_logger
-    def create(cls, _data: dict = None, **kwargs) -> bson.objectid.ObjectId:
-        _query = merge_dicts(_data, kwargs)
-        return eval(f'db.session.{cls.__name__}.insert_one(_query)').inserted_id
+    def insert_one(cls, _data: dict = None, **kwargs) -> Self:
+        document = cls._merge(_data, kwargs)
+        document['id'] = eval(f'db.session.{cls.__name__}.insert_one(document)').inserted_id
+        return cls(**document)
 
-    @query_logger
-    def delete(self) -> bool:
+    @classmethod
+    def insert_many(cls, _data: dict = None, **kwargs) -> Self:
+        raise DBException('insert_many() is not supported while using MongoDB.')
+
+    # # # # # Delete # # # # #
+    def delete(self) -> None:
         _filter = {'_id': self._id}
-        result = eval(f'db.session.{self.__class__.__name__}.delete_one(_filter)')
-        return bool(result.deleted_count)
+        eval(f'db.session.{self.__class__.__name__}.delete_one(_filter)')
 
     @classmethod
-    @query_logger
-    def delete_one(cls, **kwargs) -> bool:
-        clean_object_id_in_dicts(kwargs)
-        result = eval(f'db.session.{cls.__name__}.delete_one(kwargs)')
+    def delete_one(cls, _data: dict = None, /, **kwargs) -> bool:
+        _query = cls._merge(_data, kwargs)
+        result = eval(f'db.session.{cls.__name__}.delete_one(_query)')
         return bool(result.deleted_count)
 
     @classmethod
-    @query_logger
-    def delete_many(cls, **kwargs) -> int:
-        clean_object_id_in_dicts(kwargs)
-        result = eval(f'db.session.{cls.__name__}.delete_many(kwargs)')
+    def delete_many(cls, _data: dict = None, /, **kwargs) -> int:
+        _query = cls._merge(_data, kwargs)
+        result = eval(f'db.session.{cls.__name__}.delete_many(_query)')
         return result.deleted_count
 
-    @query_logger
-    def update(self, _data: dict = None, **kwargs) -> dict:
-        for field, value in (_data or kwargs).items():
-            if hasattr(self, field):
-                setattr(self, field, value)
+    # # # # # Update # # # # #
+    def update(self, **kwargs) -> None:
+        for field, value in kwargs.items():
+            setattr(self, field, value)
         _filter = {'_id': self._id}
         _update = {'$set': kwargs}
-        return eval(f'db.session.{self.__class__.__name__}.update_one(_filter, _update)')
+        eval(f'db.session.{self.__class__.__name__}.update_one(_filter, _update)')
 
     @classmethod
-    @query_logger
-    def update_one(cls, _filter, _data: dict = None, /, **kwargs) -> dict:
+    def update_one(cls, _filter, _data: dict = None, /, **kwargs) -> bool:
         clean_object_id_in_dicts(_filter)
-
         _update = {'$set': kwargs | {}}
         if isinstance(_data, dict):
             _data['$set'] = _data.get('$set', {}) | (kwargs or {})
 
-        return eval(f'db.session.{cls.__name__}.update_one(_filter, _data | _update)')
-
-    @classmethod
-    @query_logger
-    def update_many(cls, _filter, **kwargs) -> dict:
-        _update = {'$set': kwargs}
-        return eval(f'db.session.{cls.__name__}.update_many(_filter, _update)')
+        result = eval(f'db.session.{cls.__name__}.update_one(_filter, _data | _update)')
+        return bool(result.updated_count)
 
     @classmethod
-    @query_logger
-    def increment(cls, _filter, **kwargs):
-        _update = {'$inc': kwargs}
-        return eval(f'db.session.{cls.__name__}.update_many({_filter}, {_update})')
+    def update_many(cls, _filter, _data: dict = None, /, **kwargs) -> int:
+        _update = {'$set': cls._merge(_data, kwargs)}
+        result = eval(f'db.session.{cls.__name__}.update_many(_filter, _update)')
+        return result.updated_count
 
+    # # # # # Other # # # # #
     @classmethod
-    @query_logger
-    def get_or_create(cls, **kwargs) -> tuple[bool, any]:
-        obj = cls.get_one(**kwargs)
-        if obj:
-            return False, obj
-        else:
-            return True, cls.create(**kwargs)
+    def count(cls, _data: dict = None, /, **kwargs) -> int:
+        _query = cls._merge(_data, kwargs)
+        return eval(f'db.session.{cls.__name__}.count_documents(_query)')

panther/db/queries/pantherdb_queries.py

@@ -1,43 +1,21 @@
-import operator
-from functools import reduce
 from typing import Self
-from pydantic import ValidationError
 
 from panther.db.connection import db
+from panther.db.utils import merge_dicts
 from panther.exceptions import DBException
 
 
 class BasePantherDBQuery:
 
-    @classmethod
-    def validate_data(cls, data: dict, is_updating: bool = False) -> Self | None:
-        """
-        *. Validate the input of user with its class
-        *. If is_updating is True & exception happens but the message was empty
-                Then return nothing (we don't need the obj on update())
-                & we don't have access to the obj after exception ...
-        """
-        try:
-            obj = cls(**data)
-        except ValidationError as validation_error:
-            error = ', '.join(
-                '{field}="{error}"'.format(field=e['loc'][0], error=e['msg'])
-                for e in validation_error.errors() if not is_updating or e['type'] != 'value_error.missing')
-            if error:
-                message = f'{cls.__name__}({error})'
-                raise DBException(message)
-        else:
-            return obj
-
     @classmethod
     def _merge(cls, *args) -> dict:
         # TODO: Convert "id" to "_id"
-        return reduce(operator.ior, filter(None, args), {})
+        return merge_dicts(*args)
 
     # # # # # Find # # # # #
     @classmethod
     def find_one(cls, _data: dict = None, /, **kwargs) -> Self | None:
-        if document := db.session.collection(cls.__name__).first(**cls._merge(_data, kwargs)):
+        if document := db.session.collection(cls.__name__).find_one(**cls._merge(_data, kwargs)):
             return cls(**document)
 
     @classmethod
@@ -48,13 +26,12 @@ class BasePantherDBQuery:
     # # # # # Insert # # # # #
     @classmethod
     def insert_one(cls, _data: dict = None, **kwargs) -> Self:
-        obj = cls.validate_data(kwargs)
-        obj.id = db.session.collection(cls.__name__).insert_one(**cls._merge(_data, kwargs))['_id']
-        return obj
+        document = db.session.collection(cls.__name__).insert_one(**cls._merge(_data, kwargs))
+        return cls(**document)
 
     @classmethod
     def insert_many(cls, _data: dict = None, /, **kwargs):
-        raise DBException('increment() is not supported while using SlarkDB.')
+        raise DBException('insert_many() is not supported while using PantherDB.')
 
     # # # # # Delete # # # # #
     def delete(self) -> None:
@@ -70,7 +47,8 @@ class BasePantherDBQuery:
 
     # # # # # Update # # # # #
     def update(self, **kwargs) -> None:
-        self.validate_data(kwargs, is_updating=True)
+        for field, value in kwargs.items():
+            setattr(self, field, value)
         db.session.collection(self.__class__.__name__).update_one({'_id': self.id}, **kwargs)
 
     @classmethod
@@ -82,16 +60,6 @@ class BasePantherDBQuery:
         return db.session.collection(cls.__name__).update_many(_filter, **cls._merge(_data, kwargs))
 
     # # # # # Other # # # # #
-    @classmethod
-    def first(cls, _data: dict = None, /, **kwargs) -> Self | None:
-        if document := db.session.collection(cls.__name__).first(**cls._merge(_data, kwargs)):
-            return cls(**document)
-
-    @classmethod
-    def last(cls, _data: dict = None, /, **kwargs) -> Self | None:
-        if document := db.session.collection(cls.__name__).last(**cls._merge(_data, kwargs)):
-            return cls(**document)
-
     @classmethod
     def count(cls, _data: dict = None, /, **kwargs) -> int:
         return db.session.collection(cls.__name__).count(**cls._merge(_data, kwargs))

panther/db/queries/queries.py

@@ -1,8 +1,12 @@
 from typing import Self
 
+from pydantic import ValidationError
+
+from panther.configs import config
+from panther.db.utils import log_query
 from panther.db.queries.mongodb_queries import BaseMongoDBQuery
 from panther.db.queries.pantherdb_queries import BasePantherDBQuery
-from panther.configs import config
+from panther.exceptions import DBException
 
 if config['db_engine'] == 'pantherdb':
     BaseQuery = BasePantherDBQuery
@@ -16,8 +20,25 @@ __all__ = (
 
 class Query(BaseQuery):
 
+    @classmethod
+    def validate_data(cls, data: dict, is_updating: bool = False) -> Self | None:
+        """
+        *. Validate the input of user with its class
+        *. If is_updating is True & exception happens but the message was empty
+        """
+        try:
+            cls(**data)
+        except ValidationError as validation_error:
+            error = ', '.join(
+                '{field}="{error}"'.format(field=e['loc'][0], error=e['msg'])
+                for e in validation_error.errors() if not is_updating or e['type'] != 'value_error.missing')
+            if error:
+                message = f'{cls.__name__}({error})'
+                raise DBException(message)
+
     # # # # # Find # # # # #
     @classmethod
+    @log_query
     def find_one(cls, _data: dict = None, /, **kwargs) -> Self | None:
         """
         example:
@@ -27,6 +48,7 @@ class Query(BaseQuery):
         return super().find_one(_data, **kwargs)
 
     @classmethod
+    @log_query
     def find(cls, _data: dict = None, /, **kwargs) -> list[Self]:
         """
         example:
@@ -37,19 +59,23 @@ class Query(BaseQuery):
 
     # # # # # Insert # # # # #
     @classmethod
+    @log_query
     def insert_one(cls, _data: dict = None, /, **kwargs) -> Self:
         """
         example:
             >>> from example.app.models import User
             >>> User.insert_one(name='Ali', age=24, ...)
         """
+        cls.validate_data(kwargs)
         return super().insert_one(_data, **kwargs)
 
     @classmethod
+    @log_query
     def insert_many(cls, _data: dict = None, **kwargs):
         return super().insert_many(_data, **kwargs)
 
     # # # # # Delete # # # # #
+    @log_query
     def delete(self) -> None:
         """
         example:
@@ -60,6 +86,7 @@ class Query(BaseQuery):
         return super().delete()
 
     @classmethod
+    @log_query
     def delete_one(cls, **kwargs) -> bool:
         """
         example:
@@ -69,6 +96,7 @@ class Query(BaseQuery):
         return super().delete_one(**kwargs)
 
     @classmethod
+    @log_query
     def delete_many(cls, **kwargs) -> int:
         """
         example:
@@ -78,6 +106,7 @@ class Query(BaseQuery):
         return super().delete_many(**kwargs)
 
     # # # # # Update # # # # #
+    @log_query
     def update(self, **kwargs) -> None:
         """
         example:
@@ -85,9 +114,11 @@ class Query(BaseQuery):
             >>> user = User.find_one(name='Ali')
             >>> user.update(name='Saba')
         """
+        self.validate_data(kwargs, is_updating=True)
         return super().update(**kwargs)
 
     @classmethod
+    @log_query
     def update_one(cls, _filter, _data: dict = None, /, **kwargs) -> bool:
         """
         example:
@@ -98,6 +129,7 @@ class Query(BaseQuery):
         return super().update_one(_filter, _data, **kwargs)
 
     @classmethod
+    @log_query
     def update_many(cls, _filter, **kwargs) -> int:
         """
         example:
@@ -108,29 +140,34 @@ class Query(BaseQuery):
 
     # # # # # Other # # # # #
     @classmethod
-    def first(cls, _data: dict = None, /, **kwargs) -> Self | None:
+    @log_query
+    def last(cls, _data: dict = None, /, **kwargs) -> Self | None:
         """
-        It works same as find_one()
         example:
             >>> from example.app.models import User
-            >>> User.first(name='Ali')
+            >>> user = User.last(name='Ali')
         """
-        return super().first(_data, **kwargs)
+        return super().last(_data, **kwargs)
 
     @classmethod
-    def last(cls, _data: dict = None, /, **kwargs) -> Self | None:
+    @log_query
+    def count(cls, _data: dict = None, /, **kwargs) -> int:
         """
         example:
             >>> from example.app.models import User
-            >>> User.last(name='Ali')
+            >>> User.count(name='Ali')
         """
-        return super().last(_data, **kwargs)
+        return super().count(_data, **kwargs)
 
     @classmethod
-    def count(cls, _data: dict = None, /, **kwargs) -> int:
+    @log_query
+    def find_or_insert(cls, **kwargs) -> tuple[bool, any]:
         """
         example:
             >>> from example.app.models import User
-            >>> User.count(name='Ali')
+            >>> user = User.find_or_insert(name='Ali')
         """
-        return super().count(_data, **kwargs)
+        if obj := cls.find_one(**kwargs):
+            return False, obj
+        else:
+            return True, cls.insert_one(**kwargs)

panther/db/utils.py

@@ -4,18 +4,18 @@ from functools import reduce
 from time import perf_counter
 
 from panther.configs import config
-from panther.logger import logger
+from panther.logger import query_logger
 
 
-def query_logger(func):
+def log_query(func):
     def log(*args, **kwargs):
-        if config['monitoring'] is False:
+        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__
-        logger.info(f'\033[1mQuery -->\033[0m  {class_name}.{func.__name__}() --> {(end - start) * 1_000:.2} ms')
+        query_logger.info(f'\033[1mQuery -->\033[0m  {class_name}.{func.__name__}() --> {(end - start) * 1_000:.2} ms')
         return response
     return log
 

panther/logger.py

@@ -18,6 +18,7 @@ class LogConfig(BaseModel):
     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 = 1
     disable_existing_loggers = False
@@ -39,15 +40,21 @@ class LogConfig(BaseModel):
             'formatter': 'file_formatter',
             'filename': LOGS_DIR / 'monitoring.log',
             'class': 'logging.handlers.RotatingFileHandler',
-            'maxBytes': 1024 * 1024 * 100,  # 100 MB,
+            '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',
-            # TODO: Don't know but base_dir.name will return '.' here :\
-            'filename': LOGS_DIR / f'{config["base_dir"].name}.log',
+            'filename': LOGS_DIR / f'main.log',
             'class': 'logging.handlers.RotatingFileHandler',
-            'maxBytes': 1024 * 1024 * 100,  # 100 MB,
+            'maxBytes': MAX_FILE_SIZE,  # 100 MB,
             'backupCount': 3,
         },
         'default': {
@@ -65,13 +72,14 @@ class LogConfig(BaseModel):
             'handlers': ['monitoring_file'],
             'level': LOG_LEVEL,
         },
+        'query': {
+            'handlers': ['default', 'query_file'],
+            'level': LOG_LEVEL,
+        },
     }
 
 
 dictConfig(LogConfig().dict())
 logger = logging.getLogger('panther')
-monitoring = logging.getLogger('monitoring')
-
-"""
-[debug, info, warning, error, critical]
-"""
+query_logger = logging.getLogger('query')
+monitoring_logger = logging.getLogger('monitoring')

panther/main.py

@@ -4,12 +4,12 @@ from runpy import run_path
 from pydantic.main import ModelMetaclass
 
 from panther import status
-from panther.configs import JWTConfig, config
+from panther.request import Request
+from panther.response import Response
 from panther.exceptions import APIException
+from panther.configs import JWTConfig, config
 from panther.middlewares.base import BaseMiddleware
 from panther.middlewares.monitoring import Middleware as MonitoringMiddleware
-from panther.request import Request
-from panther.response import Response
 from panther.routings import find_endpoint, check_urls, collect_urls, finalize_urls
 from panther._utils import http_response, import_class, read_body, collect_path_variables
 
@@ -117,6 +117,7 @@ class Panther:
 
         # Put Variables In "config"
         config['monitoring'] = self.settings.get('MONITORING', config['monitoring'])
+        config['log_queries'] = self.settings.get('LOG_QUERIES', config['log_queries'])
         config['default_cache_exp'] = self.settings.get('DEFAULT_CACHE_EXP', config['default_cache_exp'])
         config['secret_key'] = self._get_secret_key()
 

panther/middlewares/monitoring.py

@@ -1,8 +1,8 @@
 from time import perf_counter
 
-from panther.logger import monitoring
-from panther.middlewares.base import BaseMiddleware
 from panther.request import Request
+from panther.logger import monitoring_logger
+from panther.middlewares.base import BaseMiddleware
 
 
 class Middleware(BaseMiddleware):
@@ -21,4 +21,4 @@ class Middleware(BaseMiddleware):
         but we should put in middlewares chain later ...
         """
         response_time = (perf_counter() - self.start_time) * 1_000
-        monitoring.info(f'{self.log} | {response_time: .3} ms | {status_code}')
+        monitoring_logger.info(f'{self.log} | {response_time: .3} ms | {status_code}')

{panther-1.3.2.dist-info → panther-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: panther
-Version: 1.3.2
+Version: 1.5.0
 Summary: Fast &  Friendly, Web Framework For Building Async APIs
 Home-page: https://github.com/alirn76/panther
 Author: Ali RajabNezhad
@@ -14,7 +14,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pantherdb (>=1.2.0)
 Requires-Dist: pydantic (>=1.10.5)
-Requires-Dist: uvicorn (==0.20.0)
+Requires-Dist: watchfiles (>=0.18.1)
+Requires-Dist: uvicorn[standard]
 Requires-Dist: bpython (>=0.24)
 Requires-Dist: bson (>=0.5.10)
 Requires-Dist: redis (>=4.0.2)
@@ -34,7 +35,7 @@ Requires-Dist: pymongo (>=4.3.3) ; extra == 'full'
 ---
 
 ### Features
-- Document-oriented Databases ORM ([PantherDB](https://pypi.org/project/pantherdb/), MongoDB)
+- Document-oriented Databases ODM ([PantherDB](https://pypi.org/project/pantherdb/), MongoDB)
 - Visual API Monitoring (In Terminal)
 - Cache APIs (In Memory, In Redis)
 - Built-in Authentication Classes (Customizable)

{panther-1.3.2.dist-info → panther-1.5.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
-panther/__init__.py,sha256=3wbCCpx1wHKORMYkcXcuf3nk18M7HyPkxPsnmModdlE,89
+panther/__init__.py,sha256=qhYoTW71O9z3-iK8zrAILsgYWzJ_tcpZQaqQoqWIbdw,89
 panther/_utils.py,sha256=Ltev6PCrTWHTWSQcWNfHMWDof1_MXODTAcDaGwflgXo,3667
 panther/app.py,sha256=tojfQaU8x5pZa7m8XS4m9fR7D5sIe_-d96hD2ccBINo,5469
 panther/authentications.py,sha256=FCRQL3xqN1Tla2vZsOY8-qXwPhnZBFsujJ-R7CeaW7w,2350
 panther/caching.py,sha256=qCqb-IaXD1T7VU0AzJVMoXawb366ZYob9kblDUT-7sM,2452
-panther/configs.py,sha256=UU2ePtjM0dT6C1p63l0EE9w0FPCDpUTOHbDPOkFHJRM,926
+panther/configs.py,sha256=bRGRy772Rxjb3RunEBBvfa9LCNCmgcc2TKkfbNTK0GM,975
 panther/exceptions.py,sha256=c1MeSo7_uwDuqoBcjKTFyXz17uXP5iZ3bM0Sp5Stvhw,769
-panther/logger.py,sha256=fb6RdDN908Em_fmbE7yDpViWn-LQ4egvbid_obBZN70,2168
-panther/main.py,sha256=oQu4v_c8Iip1TrXmRtxHx7j4qYiYrNimMoAXMicOZ9g,7372
+panther/logger.py,sha256=1skaZg4w55mTh4pSrCohkGp-7dg62lyEIoFAJKMP5L8,2499
+panther/main.py,sha256=n9Q55NOrx0KgumQOi8Ra3CzxtYPGWZHMKkX4g44e9LQ,7460
 panther/request.py,sha256=Ix1podGHCU5NlUCT9Emc79GOITKEw623ldpTw3oZm68,4383
 panther/response.py,sha256=zzfe8vsPSnydN-_peJTizlnmnawxlNbJFU9zvXppYTk,1025
 panther/routings.py,sha256=sV3xWksKYb3_95BTDOtSqouroHkB98ExoNkgWT1t7jE,4422
@@ -17,24 +17,24 @@ panther/cli/create_command.py,sha256=cUPMzXJnwsa2J1eGetWYUnbEL5GEEe5x-_wG3fA3rLg
 panther/cli/main.py,sha256=TttHOr0jA2rkLxCCtpW3ES9x4dDpq5AS32dMN0VwoW0,891
 panther/cli/monitor_command.py,sha256=wR6Ti8-2-LuLhfPzdXH77g7xlNQAL5flpBoVwu9qdoE,2458
 panther/cli/run_command.py,sha256=SdguosH7Orlh-8x8eZK_EWrv8MPnXFKzqxruTHYdHqk,1501
-panther/cli/template.py,sha256=XssIjmb98tECumKC0wqE4b61_tpzFi9TXv6jzGtrlFg,2297
+panther/cli/template.py,sha256=KhehW5nzovQzbW75J1lpAAQcIsqucqU4IXQXpVWBj5M,2317
 panther/cli/utils.py,sha256=QKQ5_qLWtTjpLY0lZ6yt2vDlc2H0jF6HFe3F-8YNJDg,8225
 panther/db/__init__.py,sha256=lOgqqRkGMzMSS1WS8D7lTChTr9ikIB5ImRPmucOhCyc,54
-panther/db/connection.py,sha256=BoqTetHcWn2cmjo1ELDoFFGkGlvJw6qDuBorKSe8ru0,2097
+panther/db/connection.py,sha256=E6ZRkDY1b-ns6cYBkSCl-DTYLzbRuOaLYFZvU0fauKs,2207
 panther/db/models.py,sha256=vnhFtVONqhCkTkFMOSz_rTDmAAxNcegPoxk1p5SljLc,1028
-panther/db/utils.py,sha256=ed_wCy8tga6CLgGjUDe-GZvXZzVrLoUxPQukJvhrdo4,1209
+panther/db/utils.py,sha256=6ndrZ9reaVTqnbFhX8MjOYtcrcPSY7UywAbDquY4eEg,1219
 panther/db/queries/__init__.py,sha256=BMffHS9RbHE-AUAeT9C5uY3L-hpDh0WGRduDUQ9Kpuc,41
-panther/db/queries/mongodb_queries.py,sha256=CHum1VDxVHt9fqa97CCvOijxSEWycEDiibcuoq0mJow,3447
-panther/db/queries/pantherdb_queries.py,sha256=FjmRILq2hPAuK_NSaJ6UuCqLhUSIfH9sVoG7BsKk_hw,3864
-panther/db/queries/queries.py,sha256=dVjp-P5z6fgIj0jrKW2C2GHQE3Wlx_6IRvgpsg6zH6A,3900
+panther/db/queries/mongodb_queries.py,sha256=uXd81Q2ukJskFDYlNfOiuCCkHuH7URyfZMkD6MUiVkk,3205
+panther/db/queries/pantherdb_queries.py,sha256=Ee3Kb5WIGQ-ZDeAYFHYx_Y34f-I0RgLT0XYFEof5FLM,2505
+panther/db/queries/queries.py,sha256=MD65JzBtot-2fKbePVNBF5wymsywXfTm3mJwAE2dkIk,5052
 panther/middlewares/__init__.py,sha256=7RtHuS-MfybnJc6pcBSGhi9teXNhDsnJ3n7h_cXSkJk,66
 panther/middlewares/base.py,sha256=Php29ckITeGZm6GfauFG3i61bcsb4qoU8RpPLTqsfls,240
 panther/middlewares/db.py,sha256=C_PevTIaMykJl0NaaMYEfwE_oLdSLfKW2HR9UoPN1dU,508
-panther/middlewares/monitoring.py,sha256=WpB_DGPBLC0OSOHCFkFc5R3FlO6PTZ83C-px1Frm254,838
+panther/middlewares/monitoring.py,sha256=CbGNJ4Ja-m9Wq3Ytv7RFyd-Qj9Ft6cYqBZZncCAxccs,852
 panther/middlewares/redis.py,sha256=_XIvPAOrVl74UoiA6-Xz8hSfWoeuM2Y1e74xeyvW0I4,1126
-panther-1.3.2.dist-info/LICENSE,sha256=2aF1hL2aC0zRPjzUkSxJUzZbn2_uLoOkn7DHjzZni-I,1524
-panther-1.3.2.dist-info/METADATA,sha256=W1d6VHYUjlE_vHl4aEFr93fKXcqXgMRBRp8XyCTMme0,5124
-panther-1.3.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-panther-1.3.2.dist-info/entry_points.txt,sha256=6GPxYFGuzVfNB4YpHFJvYex6iWah5_tLnirAHwj2Qsg,51
-panther-1.3.2.dist-info/top_level.txt,sha256=VbBs02JGXTIoHMzsX-eLOk2MCbBZzQbLhWiYpI7xI2g,8
-panther-1.3.2.dist-info/RECORD,,
+panther-1.5.0.dist-info/LICENSE,sha256=2aF1hL2aC0zRPjzUkSxJUzZbn2_uLoOkn7DHjzZni-I,1524
+panther-1.5.0.dist-info/METADATA,sha256=N_WVMfNbFUZfevcMvOxEANoqN03SXZWeBlb65BLgahc,5160
+panther-1.5.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+panther-1.5.0.dist-info/entry_points.txt,sha256=6GPxYFGuzVfNB4YpHFJvYex6iWah5_tLnirAHwj2Qsg,51
+panther-1.5.0.dist-info/top_level.txt,sha256=VbBs02JGXTIoHMzsX-eLOk2MCbBZzQbLhWiYpI7xI2g,8
+panther-1.5.0.dist-info/RECORD,,