fix: metaclass bug

Author: freemindcore

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.1.23
+current_version = 0.1.24
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<feat>\d+)\.(?P<patch>\d+)

easy/__init__.py

@@ -1,6 +1,6 @@
 """Django Easy API - Easy and Fast Django REST framework based on Django-ninja-extra"""
 
-__version__ = "0.1.23"
+__version__ = "0.1.24"
 
 from easy.main import EasyAPI
 

easy/controller/base.py

@@ -1,11 +1,11 @@
 import logging
 
-from easy.controller.meta import CrudAPI, CrudApiMetaclass
+from easy.controller.meta import CrudApiMetaclass
 
 logger = logging.getLogger(__name__)
 
 
-class CrudAPIController(CrudAPI, metaclass=CrudApiMetaclass):
+class CrudAPIController(metaclass=CrudApiMetaclass):
     """
     Base APIController for auto creating CRUD APIs, configurable via Meta class
     APIs auto generated:

easy/controller/meta.py

@@ -1,8 +1,10 @@
 import json
 import logging
+import re
 import uuid
 from abc import ABCMeta
-from typing import Any, List, Optional, Tuple, Type, Union
+from collections import ChainMap
+from typing import Any, List, Match, Optional, Tuple, Type, Union
 
 from django.db import models
 from django.http import HttpRequest
@@ -27,16 +29,29 @@ class APIControllerBase(ControllerBase):
 class CrudAPI(CrudModel):
     # Never add type note to service, it will cause injection error
     def __init__(self, service=None):  # type: ignore
+        # Critical to set __Meta
+        self.service = service
+        if self.service:
+            self.model = self.service.model
+        _meta = getattr(self, "Meta", None)
+        if self.model and _meta:
+            setattr(
+                self.model,
+                "__Meta",
+                {
+                    "model_exclude": getattr(_meta, "model_exclude", None),
+                    "model_fields": getattr(_meta, "model_fields", "__all__"),
+                    "model_recursive": getattr(_meta, "model_recursive", False),
+                    "model_join": getattr(_meta, "model_join", True),
+                    "sensitive_fields": getattr(
+                        _meta, "model_sensitive_fields", ["password", "token"]
+                    ),
+                },
+            )
         if not service:
             self.service = BaseService(model=self.model)
-        else:
-            self.service = service
         super().__init__(model=self.model)
 
-        # Critical to set Meta
-        if hasattr(self, "Meta"):
-            self.model.Meta = self.Meta  # type: ignore
-
     # Define Controller APIs for auto generation
     async def get_obj(self, request: HttpRequest, id: int) -> Any:
         """
@@ -73,28 +88,11 @@ async def get_objs(self, request: HttpRequest, filters: str = None) -> Any:
             return await self.service.get_objs(**json.loads(filters))
         return await self.service.get_objs()
 
-    # async def bulk_create_objs(self, request):
-    #     """
-    #     POST /bulk_create
-    #     Create multiple Object
-    #     """
-    #     return await self.service.bulk_create_objs()
-    #
-    # async def recover_obj(self, request):
-    #     """
-    #     PATCH /{id}/recover
-    #     Recover one Object
-    #     """
-    #     return await self.service.recover_obj()
-    #
-
 
 class CrudApiMetaclass(ABCMeta):
     def __new__(mcs, name: str, bases: Tuple[Type[Any], ...], attrs: dict) -> Any:
         # Get configs from Meta
-        temp_cls: Type = super(CrudApiMetaclass, mcs).__new__(
-            mcs, name, (object,), attrs
-        )
+        temp_cls: Type = super().__new__(mcs, name, (object,), attrs)
         temp_opts: ModelOptions = ModelOptions(getattr(temp_cls, "Meta", None))
         opts_model: Optional[Type[models.Model]] = temp_opts.model
         opts_fields_exclude: Optional[str] = temp_opts.model_exclude
@@ -105,17 +103,18 @@ def __new__(mcs, name: str, bases: Tuple[Type[Any], ...], attrs: dict) -> Any:
             Union[str, List[str]]
         ] = temp_opts.sensitive_fields
 
-        base_cls_attrs = {
-            "get_obj": http_get("/{id}", summary="Get a single object")(
-                copy_func(CrudAPI.get_obj)  # type: ignore
-            ),
-            "del_obj": http_delete("/{id}", summary="Delete a single object")(
-                copy_func(CrudAPI.del_obj)  # type: ignore
-            ),
-            "get_all": http_get("/", summary="Get multiple objects")(
-                copy_func(CrudAPI.get_objs)  # type: ignore
-            ),
-        }
+        def is_private_attrs(attr_name: str) -> Optional[Match[str]]:
+            return re.match(r"^__[^\d\W]\w*\Z__$", attr_name, re.UNICODE)
+
+        parent_attrs = ChainMap(
+            *[attrs]
+            + [
+                {k: v for (k, v) in vars(base).items() if not (is_private_attrs(k))}
+                for base in bases
+            ]
+        )
+        base_cls_attrs: dict = {}
+        base_cls_attrs.update(parent_attrs)
 
         if opts_model:
 
@@ -159,35 +158,60 @@ async def patch_obj(  # type: ignore
                 f"{opts_model.__name__}__AutoSchema({str(uuid.uuid4())[:4]})"
             )
 
-            setattr(CrudAPI, "add_obj", classmethod(add_obj))
-            setattr(CrudAPI, "patch_obj", classmethod(patch_obj))
+            setattr(CrudAPI, "patch_obj", patch_obj)
+            setattr(CrudAPI, "add_obj", add_obj)
 
             base_cls_attrs.update(
                 {
-                    "patch_obj": http_patch("/{id}", summary="Patch a single object")(
+                    "patch_obj_api": http_patch(
+                        "/{id}", summary="Patch a single object"
+                    )(
                         copy_func(CrudAPI.patch_obj)  # type: ignore
                     ),
-                    "add_obj": http_put("/", summary="Create")(
+                    "add_obj_api": http_put("/", summary="Create")(
                         copy_func(CrudAPI.add_obj)  # type: ignore
                     ),
                 }
             )
 
-        new_base: Type = type.__new__(
-            type, name, (APIControllerBase, CrudAPI), base_cls_attrs
+        base_cls_attrs.update(
+            {
+                "get_obj_api": http_get("/{id}", summary="Get a single object")(
+                    copy_func(CrudAPI.get_obj)  # type: ignore
+                ),
+                "del_obj_api": http_delete("/{id}", summary="Delete a single object")(
+                    copy_func(CrudAPI.del_obj)  # type: ignore
+                ),
+                "get_objs_api": http_get("/", summary="Get multiple objects")(
+                    copy_func(CrudAPI.get_objs)  # type: ignore
+                ),
+            }
         )
-        new_cls: Type = super(CrudApiMetaclass, mcs).__new__(
-            mcs, name, (new_base,), attrs
+
+        new_cls: Type = super().__new__(
+            mcs,
+            name,
+            (
+                APIControllerBase,
+                CrudAPI,
+            ),
+            base_cls_attrs,
         )
 
         if opts_model:
-            if hasattr(opts_model, "Meta"):
-                setattr(opts_model.Meta, "model_exclude", opts_fields_exclude)
-                setattr(opts_model.Meta, "model_fields", opts_fields)
-                setattr(opts_model.Meta, "model_recursive", opts_recursive)
-                setattr(opts_model.Meta, "model_join", opts_join)
-                setattr(opts_model.Meta, "sensitive_fields", opts_sensitive_fields)
+            setattr(
+                opts_model,
+                "__Meta",
+                {
+                    "model_exclude": opts_fields_exclude,
+                    "model_fields": opts_fields,
+                    "model_recursive": opts_recursive,
+                    "model_join": opts_join,
+                    "sensitive_fields": opts_sensitive_fields,
+                },
+            )
             setattr(new_cls, "model", opts_model)
+
         return new_cls
 
 

easy/domain/orm.py

@@ -19,14 +19,6 @@ def __init__(self, model: Type[models.Model]):
             if isinstance(_field, models.ManyToManyField)
         )
 
-    # @property
-    # def model_join(self):
-    #     """If configured to retrieve m2m by join"""
-    #     if hasattr(self.model, "Meta"):
-    #         return getattr(self.model.Meta, "model_join", True)
-    #     else:
-    #         return True
-
     def _separate_payload(self, payload: Dict) -> Tuple[Dict, Dict]:
         m2m_fields = {}
         local_fields = {}

easy/domain/serializers.py

@@ -73,7 +73,9 @@ def serialize_foreign_key(
         except Exception as exc:  # pragma: no cover
             logger.error(f"serialize_foreign_key error - {obj}", exc_info=exc)
             return {field.name: None}
-        if hasattr(obj, "Meta") and getattr(obj.Meta, "model_recursive", False):
+        if hasattr(obj, "__Meta") and getattr(obj, "__Meta").get(
+            "model_recursive", False
+        ):
             return {
                 field.name: self.serialize_model_instance(related_instance, referrers)
             }
@@ -92,7 +94,9 @@ def serialize_many_relationship(
             for k, v in obj._prefetched_objects_cache.items():  # type: ignore
                 field_name = k if hasattr(obj, k) else k + "_set"
                 if v:
-                    if hasattr(obj, "Meta") and getattr(obj.Meta, "model_join", True):
+                    if hasattr(obj, "__Meta") and getattr(obj, "__Meta").get(
+                        "model_join", True
+                    ):
                         out[field_name] = self.serialize_queryset(v, referrers + (obj,))
                     else:
                         out[field_name] = [o.pk for o in v]
@@ -110,8 +114,8 @@ def serialize_value_field(obj: models.Model, field: Any) -> Dict[Any, Any]:
         sensitive_list: List = [
             "password",
         ]
-        if hasattr(obj, "Meta"):
-            sensitive_fields = getattr(obj.Meta, "sensitive_fields", None)
+        if hasattr(obj, "__Meta"):
+            sensitive_fields = getattr(obj, "__Meta").get("sensitive_fields", None)
             if sensitive_fields:
                 sensitive_list.extend(sensitive_fields)
             sensitive_list = list(set(sensitive_list))

tests/demo_app/controllers.py

@@ -26,7 +26,6 @@ class AutoGenCrudAPIController(CrudAPIController):
 
     def __init__(self, service: EventService):
         super().__init__(service)
-        self.service = service
 
     class Meta:
         model = Event
@@ -35,11 +34,30 @@ class Meta:
 
 
 @api_controller("unittest", permissions=[BaseApiPermission])
-class RecursiveAPIController(AutoGenCrudAPIController):
+class RecursiveAPIController(CrudAPIController):
     """
     For unit testings of no recursive configuration
     """
 
+    def __init__(self, service: EventService):
+        super().__init__(service)
+
+    class Meta:
+        model = Event
+        model_fields = "__all__"
+        model_join = True
+        model_recursive = True
+
+
+@api_controller("unittest", permissions=[BaseApiPermission])
+class InheritedRecursiveAPIController(AutoGenCrudAPIController):
+    """
+    For unit testings of no recursive configuration
+    """
+
+    def __init__(self, service: EventService):
+        super().__init__(service)
+
     class Meta:
         model = Event
         model_fields = "__all__"
@@ -55,7 +73,6 @@ class AutoGenCrudNoJoinAPIController(CrudAPIController):
 
     def __init__(self, service: EventService):
         super().__init__(service)
-        self.service = service
 
     class Meta:
         model = Event
@@ -83,7 +100,6 @@ class EasyCrudAPIController(CrudAPIController):
 
     def __init__(self, service: EventService):
         super().__init__(service)
-        self.service = service
 
     class Meta:
         model = Event

tests/demo_app/test_async_api_permissions.py

@@ -124,10 +124,12 @@ async def test_perm_auto_apis_delete(self, transactional_db, easy_api_client):
 
         # Super users
         client = easy_api_client(AutoGenCrudAPIController, is_superuser=True)
-        await client.delete(
+        response = await client.delete(
             f"/{event.id}",
         )
 
+        assert response.status_code == 200
+
         response = await client.get(
             f"/{event.id}",
         )

tests/demo_app/test_async_auto_crud_apis.py

@@ -10,6 +10,7 @@
     AutoGenCrudNoJoinAPIController,
     AutoGenCrudSomeFieldsAPIController,
     EventSchema,
+    InheritedRecursiveAPIController,
     RecursiveAPIController,
 )
 from tests.demo_app.models import Category, Client, Event, Type
@@ -58,7 +59,7 @@ async def test_crud_default_get_all(self, transactional_db, easy_api_client):
         event_schema = json.loads(EventSchema.from_orm(event).json())
         assert event_schema["start_date"] == data[0]["start_date"]
 
-        # Recursive = False
+        # Recursive = True
         client = easy_api_client(RecursiveAPIController)
         response = await client.get(
             "/", query=dict(maximum=100, filters=json.dumps(dict(id__gte=1)))
@@ -67,6 +68,20 @@ async def test_crud_default_get_all(self, transactional_db, easy_api_client):
 
         data = response.json().get("data")
         assert data[0]["title"] == "AsyncAdminAPIEvent_get_all"
+
+        assert data[0]["type"]["id"] == type.id
+        assert data[0]["category"]["status"] == 1
+
+        # Recursive = True, inherited class
+        client = easy_api_client(InheritedRecursiveAPIController)
+        response = await client.get(
+            "/", query=dict(maximum=100, filters=json.dumps(dict(id__gte=1)))
+        )
+        assert response.status_code == 200
+
+        data = response.json().get("data")
+        assert data[0]["title"] == "AsyncAdminAPIEvent_get_all"
+
         assert data[0]["type"]["id"] == type.id
         assert data[0]["category"]["status"] == 1
 
@@ -155,6 +170,7 @@ async def test_crud_default_create(self, transactional_db, easy_api_client):
         response = await client.get(
             f"/{event_id}",
         )
+
         assert response.status_code == 200
         assert response.json().get("data")["title"] == "AsyncAdminAPIEvent_create"