panther 3.8.1__tar.gz → 3.9.0__tar.gz

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

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

{panther-3.8.1 → panther-3.9.0}/panther/__init__.py

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

{panther-3.8.1 → panther-3.9.0}/panther/cli/template.py

@@ -99,6 +99,7 @@ requirements = """panther==%s
 
 TEMPLATE = {
     'app': {
+        '__init__.py': '',
         'apis.py': apis_py,
         'models.py': models_py,
         'serializers.py': serializers_py,
@@ -106,6 +107,7 @@ TEMPLATE = {
         'urls.py': app_urls_py,
     },
     'core': {
+        '__init__.py': '',
         'configs.py': configs_py,
         'urls.py': urls_py,
     },

{panther-3.8.1 → panther-3.9.0}/panther/main.py

@@ -300,6 +300,7 @@ class Panther:
     async def _raise(self, send, *, status_code: int):
         await http_response(
             send,
+            headers={'content-type': 'application/json'},
             status_code=status_code,
             monitoring=self.monitoring,
             exception=True,

panther-3.9.0/panther/serializer.py

@@ -0,0 +1,122 @@
+import typing
+
+from pydantic import create_model, BaseModel
+from pydantic.fields import FieldInfo
+from pydantic_core._pydantic_core import PydanticUndefined
+
+from panther.db import Model
+
+
+class MetaModelSerializer:
+    KNOWN_CONFIGS = ['model', 'fields', 'required_fields']
+
+    def __new__(
+            cls,
+            cls_name: str,
+            bases: tuple[type[typing.Any], ...],
+            namespace: dict[str, typing.Any],
+            **kwargs
+    ):
+        if cls_name == 'ModelSerializer':
+            cls.model_serializer = type(cls_name, (), namespace)
+            return super().__new__(cls)
+
+        # 1. Initial Check
+        cls.check_config(cls_name=cls_name, namespace=namespace)
+        config = namespace.pop('Config')
+
+        # 2. Collect `Fields`
+        field_definitions = cls.collect_fields(config=config, namespace=namespace)
+
+        # 3. Collect `pydantic.model_config`
+        model_config = cls.collect_model_config(config=config, namespace=namespace)
+        namespace |= {'model_config': model_config}
+
+        # 4. Create a serializer
+        return create_model(
+            __model_name=cls_name,
+            __module__=namespace['__module__'],
+            __validators__=namespace,
+            __base__=(cls.model_serializer, BaseModel),
+            __doc__=namespace.get('__doc__'),
+            model=(typing.ClassVar, config.model),
+            **field_definitions
+        )
+
+    @classmethod
+    def check_config(cls, cls_name: str, namespace: dict) -> None:
+        module = namespace['__module__']
+        address = f'{module}.{cls_name}'
+
+        # Check `Config`
+        if (config := namespace.get('Config')) is None:
+            msg = f'`class Config` is required in {address}.'
+            raise AttributeError(msg) from None
+
+        # Check `model`
+        if (model := getattr(config, 'model', None)) is None:
+            msg = f'`{cls_name}.Config.model` is required.'
+            raise AttributeError(msg) from None
+
+        # Check `model` type
+        try:
+            if not issubclass(model, Model):
+                msg = f'`{cls_name}.Config.model` is not subclass of `panther.db.Model`.'
+                raise AttributeError(msg) from None
+        except TypeError:
+            msg = f'`{cls_name}.Config.model` is not subclass of `panther.db.Model`.'
+            raise AttributeError(msg) from None
+
+        # Check `fields`
+        if (fields := getattr(config, 'fields', None)) is None:
+            msg = f'`{cls_name}.Config.fields` is required.'
+            raise AttributeError(msg) from None
+
+        for field_name in fields:
+            if field_name not in model.model_fields:
+                msg = f'`{cls_name}.Config.fields.{field_name}` is not valid.'
+                raise AttributeError(msg) from None
+
+        # Check `required_fields`
+        if not hasattr(config, 'required_fields'):
+            config.required_fields = []
+
+        for required in config.required_fields:
+            if required not in config.fields:
+                msg = f'`{cls_name}.Config.required_fields.{required}` should be in `Config.fields` too.'
+                raise AttributeError(msg) from None
+
+    @classmethod
+    def collect_fields(cls, config: typing.Callable, namespace: dict) -> dict:
+        field_definitions = {}
+
+        # Define `fields`
+        for field_name in config.fields:
+            field_definitions[field_name] = (
+                config.model.model_fields[field_name].annotation,
+                config.model.model_fields[field_name]
+            )
+
+        # Apply `required_fields`
+        for required in config.required_fields:
+            field_definitions[required][1].default = PydanticUndefined
+
+        # Collect and Override `Class Fields`
+        for key, value in namespace.pop('__annotations__', {}).items():
+            field_info = namespace.pop(key, FieldInfo(required=True))
+            field_info.annotation = value
+            field_definitions[key] = (value, field_info)
+
+        return field_definitions
+
+    @classmethod
+    def collect_model_config(cls, config: typing.Callable, namespace: dict) -> dict:
+        return {
+            attr: getattr(config, attr) for attr in dir(config)
+            if not attr.startswith('__') and attr not in cls.KNOWN_CONFIGS
+        } | namespace.pop('model_config', {})
+
+
+class ModelSerializer(metaclass=MetaModelSerializer):
+    def create(self) -> type[Model]:
+        return self.model.insert_one(self.model_dump())

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

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

{panther-3.8.1 → panther-3.9.0}/panther.egg-info/SOURCES.txt

@@ -61,13 +61,13 @@ tests/test_background_tasks.py
 tests/test_caching.py
 tests/test_cli.py
 tests/test_database.py
-tests/test_model_serializer.py
 tests/test_mongodb.py
 tests/test_multipart.py
 tests/test_panel_apis.py
 tests/test_request.py
 tests/test_routing.py
 tests/test_run.py
+tests/test_serializer.py
 tests/test_simple_responses.py
 tests/test_status.py
 tests/test_utils.py

panther-3.9.0/tests/test_serializer.py

@@ -0,0 +1,317 @@
+from pathlib import Path
+from unittest import TestCase
+
+from pydantic import Field, ConfigDict
+from pydantic import field_validator
+
+from panther import Panther
+from panther.app import API
+from panther.db import Model
+from panther.request import Request
+from panther.serializer import ModelSerializer
+from panther.test import APIClient
+
+
+class Book(Model):
+    name: str
+    author: str = Field('default_author')
+    pages_count: int = Field(0)
+
+
+class NotRequiredFieldsSerializer(ModelSerializer):
+    class Config:
+        model = Book
+        fields = ['author', 'pages_count']
+
+
+class RequiredFieldsSerializer(ModelSerializer):
+    class Config:
+        model = Book
+        fields = ['name', 'author', 'pages_count']
+
+
+class OnlyRequiredFieldsSerializer(ModelSerializer):
+    class Config:
+        model = Book
+        fields = ['name', 'author', 'pages_count']
+        required_fields = ['author', 'pages_count']
+
+
+class WithValidatorsSerializer(ModelSerializer):
+    class Config:
+        model = Book
+        fields = ['name', 'author', 'pages_count']
+        required_fields = ['author', 'pages_count']
+
+    @field_validator('name', 'author', 'pages_count')
+    def validate(cls, field):
+        return 'validated'
+
+
+class WithClassFieldsSerializer(ModelSerializer):
+    age: int = Field(10)
+
+    class Config:
+        model = Book
+        fields = ['name', 'author', 'pages_count']
+        required_fields = ['author', 'pages_count']
+
+
+@API(input_model=NotRequiredFieldsSerializer)
+async def not_required(request: Request):
+    return request.validated_data
+
+
+@API(input_model=RequiredFieldsSerializer)
+async def required(request: Request):
+    return request.validated_data
+
+
+@API(input_model=OnlyRequiredFieldsSerializer)
+async def only_required(request: Request):
+    return request.validated_data
+
+
+@API(input_model=WithValidatorsSerializer)
+async def with_validators(request: Request):
+    return request.validated_data
+
+
+@API(input_model=WithClassFieldsSerializer)
+async def with_class_fields(request: Request):
+    return request.validated_data
+
+
+urls = {
+    'not-required': not_required,
+    'required': required,
+    'only-required': only_required,
+    'with-validators': with_validators,
+    'class-fields': with_class_fields,
+}
+
+
+class TestModelSerializer(TestCase):
+    DB_PATH = 'test.pdb'
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        global MIDDLEWARES
+        MIDDLEWARES = [
+            ('panther.middlewares.db.DatabaseMiddleware', {'url': f'pantherdb://{cls.DB_PATH}'}),
+        ]
+        app = Panther(__name__, configs=__name__, urls=urls)
+        cls.client = APIClient(app=app)
+
+    def tearDown(self) -> None:
+        Path(self.DB_PATH).unlink(missing_ok=True)
+
+    # # # Class Usage
+
+    def test_not_required_fields_empty_response(self):
+        payload = {}
+        res = self.client.post('not-required', payload=payload)
+        assert res.status_code == 200
+        assert res.data == {'author': 'default_author', 'pages_count': 0}
+
+    def test_not_required_fields_full_response(self):
+        payload = {
+            'author': 'ali',
+            'pages_count': '12'
+        }
+        res = self.client.post('not-required', payload=payload)
+        assert res.status_code == 200
+        assert res.data == {'author': 'ali', 'pages_count': 12}
+
+    def test_required_fields_error(self):
+        payload = {}
+        res = self.client.post('required', payload=payload)
+        assert res.status_code == 400
+        assert res.data == {'name': 'Field required'}
+
+    def test_required_fields_success(self):
+        payload = {
+            'name': 'how to code',
+            'author': 'ali',
+            'pages_count': '12'
+        }
+        res = self.client.post('required', payload=payload)
+        assert res.status_code == 200
+        assert res.data == {'name': 'how to code', 'author': 'ali', 'pages_count': 12}
+
+    def test_only_required_fields_error(self):
+        payload = {}
+        res = self.client.post('only-required', payload=payload)
+        assert res.status_code == 400
+        assert res.data == {'name': 'Field required', 'author': 'Field required', 'pages_count': 'Field required'}
+
+    def test_only_required_fields_success(self):
+        payload = {
+            'name': 'how to code',
+            'author': 'ali',
+            'pages_count': '12'
+        }
+        res = self.client.post('only-required', payload=payload)
+        assert res.status_code == 200
+        assert res.data == {'name': 'how to code', 'author': 'ali', 'pages_count': 12}
+
+    def test_with_validators(self):
+        payload = {
+            'name': 'how to code',
+            'author': 'ali',
+            'pages_count': '12'
+        }
+        res = self.client.post('with-validators', payload=payload)
+        assert res.status_code == 200
+        assert res.data == {'name': 'validated', 'author': 'validated', 'pages_count': 'validated'}
+
+    def test_with_class_fields_success(self):
+        # Test Default Value
+        payload1 = {
+            'name': 'how to code',
+            'author': 'ali',
+            'pages_count': '12'
+        }
+        res = self.client.post('class-fields', payload=payload1)
+        assert res.status_code == 200
+        assert res.data == {'name': 'how to code', 'author': 'ali', 'pages_count': 12, 'age': 10}
+
+        # Test Validation
+        payload2 = {
+            'name': 'how to code',
+            'author': 'ali',
+            'pages_count': '12',
+            'age': 30
+        }
+        res = self.client.post('class-fields', payload=payload2)
+        assert res.status_code == 200
+        assert res.data == {'name': 'how to code', 'author': 'ali', 'pages_count': 12, 'age': 30}
+
+    # # # Class Definition
+
+    def test_define_class_without_meta(self):
+        try:
+            class Serializer0(ModelSerializer):
+                pass
+        except Exception as e:
+            assert isinstance(e, AttributeError)
+            assert e.args[0] == '`class Config` is required in tests.test_serializer.Serializer0.'
+        else:
+            assert False
+
+    def test_define_class_without_model(self):
+        try:
+            class Serializer1(ModelSerializer):
+                class Config:
+                    pass
+        except Exception as e:
+            assert isinstance(e, AttributeError)
+            assert e.args[0] == '`Serializer1.Config.model` is required.'
+        else:
+            assert False
+
+    def test_define_class_without_fields(self):
+        try:
+            class Serializer2(ModelSerializer):
+                class Config:
+                    model = Book
+        except Exception as e:
+            assert isinstance(e, AttributeError)
+            assert e.args[0] == '`Serializer2.Config.fields` is required.'
+        else:
+            assert False
+
+    def test_define_class_with_invalid_fields(self):
+        try:
+            class Serializer3(ModelSerializer):
+                class Config:
+                    model = Book
+                    fields = ['ok', 'no']
+        except Exception as e:
+            assert isinstance(e, AttributeError)
+            assert e.args[0] == '`Serializer3.Config.fields.ok` is not valid.'
+        else:
+            assert False
+
+    def test_define_class_with_invalid_required_fields(self):
+        try:
+            class Serializer4(ModelSerializer):
+                class Config:
+                    model = Book
+                    fields = ['name', 'author']
+                    required_fields = ['pages_count']
+        except Exception as e:
+            assert isinstance(e, AttributeError)
+            assert e.args[0] == '`Serializer4.Config.required_fields.pages_count` should be in `Config.fields` too.'
+        else:
+            assert False
+
+    def test_define_class_with_invalid_model(self):
+        try:
+            class Serializer5(ModelSerializer):
+                class Config:
+                    model = ModelSerializer
+                    fields = ['name', 'author', 'pages_count']
+        except Exception as e:
+            assert isinstance(e, AttributeError)
+            assert e.args[0] == '`Serializer5.Config.model` is not subclass of `panther.db.Model`.'
+        else:
+            assert False
+
+    # # # Serializer Usage
+    def test_with_simple_model_config(self):
+        class Serializer(ModelSerializer):
+            model_config = ConfigDict(str_to_upper=True)
+
+            class Config:
+                model = Book
+                fields = ['name', 'author', 'pages_count']
+
+        serialized = Serializer(name='book', author='AliRn', pages_count='12')
+        assert serialized.name == 'BOOK'
+        assert serialized.author == 'ALIRN'
+        assert serialized.pages_count == 12
+
+    def test_with_inner_model_config(self):
+        class Serializer(ModelSerializer):
+            class Config:
+                str_to_upper = True
+                model = Book
+                fields = ['name', 'author', 'pages_count']
+
+        serialized = Serializer(name='book', author='AliRn', pages_count='12')
+        assert serialized.name == 'BOOK'
+        assert serialized.author == 'ALIRN'
+        assert serialized.pages_count == 12
+
+    def test_with_dual_model_config(self):
+        class Serializer(ModelSerializer):
+            model_config = ConfigDict(str_to_upper=False)
+
+            class Config:
+                str_to_upper = True
+                model = Book
+                fields = ['name', 'author', 'pages_count']
+
+        serialized = Serializer(name='book', author='AliRn', pages_count='12')
+        assert serialized.name == 'book'
+        assert serialized.author == 'AliRn'
+        assert serialized.pages_count == 12
+
+    def test_serializer_doc(self):
+        class Serializer1(ModelSerializer):
+            """Hello I'm Doc"""
+            class Config:
+                model = Book
+                fields = ['name', 'author', 'pages_count']
+
+        serialized = Serializer1(name='book', author='AliRn', pages_count='12')
+        assert serialized.__doc__ == 'Hello I\'m Doc'
+
+        class Serializer2(ModelSerializer):
+            class Config:
+                model = Book
+                fields = ['name', 'author', 'pages_count']
+
+        serialized = Serializer2(name='book', author='AliRn', pages_count='12')
+        assert serialized.__doc__ is None

panther-3.8.1/panther/serializer.py

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

panther-3.8.1/tests/test_model_serializer.py

@@ -1,170 +0,0 @@
-from pathlib import Path
-from unittest import TestCase
-
-from pydantic import Field
-
-from panther import Panther
-from panther.app import API
-from panther.db import Model
-from panther.request import Request
-from panther.serializer import ModelSerializer
-from panther.test import APIClient
-
-
-class Book(Model):
-    name: str
-    author: str = Field('default_author')
-    pages_count: int = Field(0)
-
-
-class NotRequiredFieldsSerializer(metaclass=ModelSerializer, model=Book):
-    fields = ['author', 'pages_count']
-
-
-class RequiredFieldsSerializer(metaclass=ModelSerializer, model=Book):
-    fields = ['name', 'author', 'pages_count']
-
-
-class OnlyRequiredFieldsSerializer(metaclass=ModelSerializer, model=Book):
-    fields = ['name', 'author', 'pages_count']
-    required_fields = ['author', 'pages_count']
-
-
-@API(input_model=NotRequiredFieldsSerializer)
-async def not_required(request: Request):
-    return request.validated_data
-
-
-@API(input_model=RequiredFieldsSerializer)
-async def required(request: Request):
-    return request.validated_data
-
-
-@API(input_model=OnlyRequiredFieldsSerializer)
-async def only_required(request: Request):
-    return request.validated_data
-
-
-urls = {
-    'not-required': not_required,
-    'required': required,
-    'only-required': only_required,
-}
-
-
-class TestModelSerializer(TestCase):
-    DB_PATH = 'test.pdb'
-
-    @classmethod
-    def setUpClass(cls) -> None:
-        global MIDDLEWARES
-        MIDDLEWARES = [
-            ('panther.middlewares.db.DatabaseMiddleware', {'url': f'pantherdb://{cls.DB_PATH}'}),
-        ]
-        app = Panther(__name__, configs=__name__, urls=urls)
-        cls.client = APIClient(app=app)
-
-    def tearDown(self) -> None:
-        Path(self.DB_PATH).unlink(missing_ok=True)
-
-    def test_not_required_fields_empty_response(self):
-        payload = {}
-        res = self.client.post('not-required', payload=payload)
-        assert res.status_code == 200
-        assert res.data == {'author': 'default_author', 'pages_count': 0}
-
-    def test_not_required_fields_full_response(self):
-        payload = {
-            'author': 'ali',
-            'pages_count': '12'
-        }
-        res = self.client.post('not-required', payload=payload)
-        assert res.status_code == 200
-        assert res.data == {'author': 'ali', 'pages_count': 12}
-
-    def test_required_fields_error(self):
-        payload = {}
-        res = self.client.post('required', payload=payload)
-        assert res.status_code == 400
-        assert res.data == {'name': 'Field required'}
-
-    def test_required_fields_success(self):
-        payload = {
-            'name': 'how to code',
-            'author': 'ali',
-            'pages_count': '12'
-        }
-        res = self.client.post('required', payload=payload)
-        assert res.status_code == 200
-        assert res.data == {'name': 'how to code', 'author': 'ali', 'pages_count': 12}
-
-    def test_only_required_fields_error(self):
-        payload = {}
-        res = self.client.post('only-required', payload=payload)
-        assert res.status_code == 400
-        assert res.data == {'name': 'Field required', 'author': 'Field required', 'pages_count': 'Field required'}
-
-    def test_only_required_fields_success(self):
-        payload = {
-            'name': 'how to code',
-            'author': 'ali',
-            'pages_count': '12'
-        }
-        res = self.client.post('only-required', payload=payload)
-        assert res.status_code == 200
-        assert res.data == {'name': 'how to code', 'author': 'ali', 'pages_count': 12}
-
-    def test_define_class_without_fields(self):
-        try:
-            class Serializer1(metaclass=ModelSerializer, model=Book):
-                pass
-        except Exception as e:
-            assert isinstance(e, AttributeError)
-            assert e.args[0] == "'fields' required while using 'ModelSerializer' metaclass. -> tests.test_model_serializer.Serializer1"
-        else:
-            assert False
-
-    def test_define_class_with_invalid_fields(self):
-        try:
-            class Serializer2(metaclass=ModelSerializer, model=Book):
-                fields = ['ok', 'no']
-        except Exception as e:
-            assert isinstance(e, AttributeError)
-            assert e.args[0] == "'ok' is not in 'Book' -> tests.test_model_serializer.Serializer2"
-        else:
-            assert False
-
-    def test_define_class_with_invalid_required_fields(self):
-        try:
-            class Serializer3(metaclass=ModelSerializer, model=Book):
-                fields = ['name', 'author']
-                required_fields = ['pages_count']
-        except Exception as e:
-            assert isinstance(e, AttributeError)
-            assert e.args[0] == "'pages_count' is in 'required_fields' but not in 'fields' -> tests.test_model_serializer.Serializer3"
-        else:
-            assert False
-
-    def test_define_class_without_model(self):
-        try:
-            class Serializer4(metaclass=ModelSerializer):
-                fields = ['name', 'author']
-                required_fields = ['pages_count']
-        except Exception as e:
-            assert isinstance(e, AttributeError)
-            assert e.args[0] == "'model' required while using 'ModelSerializer' metaclass -> tests.test_model_serializer.Serializer4"
-        else:
-            assert False
-
-    def test_define_class_without_metaclass(self):
-        class Serializer5(ModelSerializer):
-            fields = ['name', 'author']
-            required_fields = ['pages_count']
-
-        try:
-            Serializer5(name='alice', author='bob')
-        except Exception as e:
-            assert isinstance(e, TypeError)
-            assert e.args[0] == "you should not inherit the 'ModelSerializer', you should use it as 'metaclass' -> tests.test_model_serializer.Serializer5"
-        else:
-            assert False