fixes thnee#1

Author: notvad

examples/complete_db/blueprints/api_v1/views.py

@@ -18,7 +18,7 @@ class AuthorsIndex(af.List, af.Create):
     Same body schema for List and Create.
     """
 
-    body_schema = AuthorSchema()
+    body_schema_cls = AuthorSchema
 
     def get_instances(self):
         return Author.query.all()
@@ -29,8 +29,8 @@ class AuthorsBooksList(af.List):
     List all books for a specific author defined by a view arg.
     """
 
-    kwargs_schema = AuthorsBooksListKwargsSchema()
-    body_schema = BookListSchema()
+    kwargs_schema_cls = AuthorsBooksListKwargsSchema
+    body_schema_cls = BookListSchema
 
     def get_instances(self):
         q = Book.query
@@ -45,8 +45,8 @@ class BooksIndex(af.List, af.Create):
     Different body schemas for List and Create.
     """
 
-    list_body_schema = BookListSchema()
-    create_body_schema = BookCreateSchema()
+    list_body_schema_cls = BookListSchema
+    create_body_schema_cls = BookCreateSchema
 
     def get_instances(self):
         return Book.query.all()
@@ -58,5 +58,5 @@ class BookDetail(af.Read, af.Update, af.Delete):
     Same body schema for Read, Update, Delete.
     """
 
-    kwargs_schema = BookDetailKwargsSchema()
-    body_schema = BookDetailBodySchema()
+    kwargs_schema_cls = BookDetailKwargsSchema
+    body_schema_cls = BookDetailBodySchema

examples/minimal_db/main.py

@@ -28,7 +28,7 @@ class Meta:
 
 
 class Books(af.Create, af.List):
-    body_schema = BookSchema()
+    body_schema_cls = BookSchema
 
     def get_instances(self):
         return Book.query.all()

src/flask_api_framework/views.py

@@ -34,9 +34,9 @@ def __init__(cls, name, bases, d):
         for _ in bases:
             for action in actions:
                 for name, fallbacks in schema_names.items():
-                    name = f"{name}_schema".format(action=action)
+                    name = f"{name}_schema_cls".format(action=action)
                     fallbacks = [
-                        f"{fallback}_schema".format(action=action)
+                        f"{fallback}_schema_cls".format(action=action)
                         for fallback in fallbacks
                     ]
                     attr = getattr_fallback(cls, name, *fallbacks)
@@ -45,9 +45,9 @@ def __init__(cls, name, bases, d):
 
 
 class BaseView(flask.views.View, metaclass=BaseViewType):
-    kwargs_schema = None
-    args_schema = None
-    body_schema = None
+    kwargs_schema_cls = None
+    args_schema_cls = None
+    body_schema_cls = None
 
     loaded_kwargs = None
     loaded_args = None
@@ -65,15 +65,15 @@ def dispatch_request(self, *args, **kwargs):
             raise ApiError(status_code=400, source="body") from e
 
     def load_kwargs_schema(self):
-        self.loaded_kwargs = self.kwargs_schema.load(data=flask.request.view_args)
+        self.loaded_kwargs = self.kwargs_schema_cls().load(data=flask.request.view_args)
 
     def load_args_schema(self):
-        self.loaded_args = self.args_schema.load(data=flask.request.args)
+        self.loaded_args = self.args_schema_cls().load(data=flask.request.args)
 
-    def handle_kwargs(self, schema):
+    def handle_kwargs(self, schema_cls):
         try:
-            if schema is not None:
-                self.kwargs_schema = schema
+            if schema_cls is not None:
+                self.kwargs_schema_cls = schema_cls
                 self.load_kwargs_schema()
         except marshmallow.exceptions.ValidationError as e:
             raise ApiError(status_code=400, source="kwargs") from e
@@ -83,10 +83,10 @@ def handle_kwargs(self, schema):
         ):
             raise ApiError(status_code=404)
 
-    def handle_args(self, schema):
+    def handle_args(self, schema_cls):
         try:
-            if schema is not None:
-                self.args_schema = schema
+            if schema_cls is not None:
+                self.args_schema_cls = schema_cls
                 self.load_args_schema()
         except marshmallow.exceptions.ValidationError as e:
             raise ApiError(status_code=400, source="args") from e
@@ -98,7 +98,7 @@ def handle_args(self, schema):
 
     def get_schema_success_data(
         self,
-        schema,
+        schema_cls,
         data,
         status_code=200,
         data_wrapper=None,
@@ -109,29 +109,29 @@ def noop_data_wrapper(x):
 
         if data_wrapper is None:
             data_wrapper = noop_data_wrapper
-        if schema is not None:
+        if schema_cls is not None:
             return (
-                flask.jsonify(data_wrapper(schema.dump(data, many=many))),
+                flask.jsonify(data_wrapper(schema_cls().dump(data, many=many))),
                 status_code,
             )
-        elif schema is None and data is not None:
+        elif schema_cls is None and data is not None:
             return flask.jsonify(data_wrapper(data)), status_code
         else:
             return "", 204
 
 
 class List(BaseView):
-    list_kwargs_schema = None
-    list_args_schema = None
-    list_body_schema = None
-    list_response_body_schema = None
-    response_body_schema = None
+    list_kwargs_schema_cls = None
+    list_args_schema_cls = None
+    list_body_schema_cls = None
+    list_response_body_schema_cls = None
+    response_body_schema_cls = None
 
     instances = None
 
     def handle_get(self, *args, **kwargs):
-        self.handle_kwargs(self.list_kwargs_schema)
-        self.handle_args(self.list_args_schema)
+        self.handle_kwargs(self.list_kwargs_schema_cls)
+        self.handle_args(self.list_args_schema_cls)
         self.instances = self.get_instances()
         return self.get_list_response()
 
@@ -140,25 +140,25 @@ def get_instances(self):
 
     def get_list_response(self):
         return self.get_schema_success_data(
-            schema=self.list_response_body_schema,
+            schema_cls=self.list_response_body_schema_cls,
             data=self.instances,
             data_wrapper=lambda data: dict(items=data),
             many=True,
         )
 
 
 class Read(BaseView):
-    read_kwargs_schema = None
-    read_args_schema = None
-    read_body_schema = None
-    read_response_body_schema = None
-    response_body_schema = None
+    read_kwargs_schema_cls = None
+    read_args_schema_cls = None
+    read_body_schema_cls = None
+    read_response_body_schema_cls = None
+    response_body_schema_cls = None
 
     instance = None
 
     def handle_get(self, *args, **kwargs):
-        self.handle_kwargs(self.read_kwargs_schema)
-        self.handle_args(self.read_args_schema)
+        self.handle_kwargs(self.read_kwargs_schema_cls)
+        self.handle_args(self.read_args_schema_cls)
         self.instance = self.get_instance()
         return self.get_read_response()
 
@@ -167,35 +167,37 @@ def get_instance(self):
 
     def get_read_response(self):
         return self.get_schema_success_data(
-            schema=self.read_response_body_schema,
+            schema_cls=self.read_response_body_schema_cls,
             data=self.instance,
         )
 
 
 class Create(BaseView):
-    create_kwargs_schema = None
-    create_args_schema = None
-    create_body_schema = None
-    create_request_body_schema = None
-    create_response_body_schema = None
-    request_body_schema = None
-    response_body_schema = None
+    create_kwargs_schema_cls = None
+    create_args_schema_cls = None
+    create_body_schema_cls = None
+    create_request_body_schema_cls = None
+    create_response_body_schema_cls = None
+    request_body_schema_cls = None
+    response_body_schema_cls = None
 
     loaded_body = None
     instance = None
 
     def handle_post(self, *args, **kwargs):
-        self.handle_kwargs(self.create_kwargs_schema)
-        self.handle_args(self.create_args_schema)
-        if self.create_request_body_schema is not None:
-            self.body_schema = self.create_request_body_schema
+        self.handle_kwargs(self.create_kwargs_schema_cls)
+        self.handle_args(self.create_args_schema_cls)
+        if self.create_request_body_schema_cls is not None:
+            self.body_schema_cls = self.create_request_body_schema_cls
             self.load_create_request_body_schema()
         self.instance = self.create()
         self.db.session.commit()
         return self.get_create_response()
 
     def load_create_request_body_schema(self):
-        self.loaded_body = self.create_request_body_schema.load(data=flask.request.json)
+        self.loaded_body = self.create_request_body_schema_cls().load(
+            data=flask.request.json
+        )
 
     def create(self):
         if is_sa_mapped(self.loaded_body):
@@ -204,20 +206,20 @@ def create(self):
 
     def get_create_response(self):
         return self.get_schema_success_data(
-            schema=self.create_response_body_schema,
+            schema_cls=self.create_response_body_schema_cls,
             data=self.instance,
             status_code=201,
         )
 
 
 class Update(BaseView):
-    update_kwargs_schema = None
-    update_args_schema = None
-    update_body_schema = None
-    update_request_body_schema = None
-    update_response_body_schema = None
-    request_body_schema = None
-    response_body_schema = None
+    update_kwargs_schema_cls = None
+    update_args_schema_cls = None
+    update_body_schema_cls = None
+    update_request_body_schema_cls = None
+    update_response_body_schema_cls = None
+    request_body_schema_cls = None
+    response_body_schema_cls = None
 
     loaded_body = None
     instance = None
@@ -229,11 +231,11 @@ def handle_put(self, *args, **kwargs):
         return self.handle_update(*args, partial=False, **kwargs)
 
     def handle_update(self, *args, partial, **kwargs):
-        self.handle_kwargs(self.update_kwargs_schema)
-        self.handle_args(self.update_args_schema)
+        self.handle_kwargs(self.update_kwargs_schema_cls)
+        self.handle_args(self.update_args_schema_cls)
         self.instance = self.get_instance()
-        if self.update_request_body_schema is not None:
-            self.body_schema = self.load_update_request_body_schema
+        if self.update_request_body_schema_cls is not None:
+            self.body_schema_cls = self.update_request_body_schema_cls
             self.load_update_request_body_schema(partial=partial)
         self.instance = self.update()
         self.db.session.commit()
@@ -247,13 +249,13 @@ def load_update_request_body_schema(self, partial):
             data=flask.request.json,
             partial=partial,
         )
-        if self.get_schema_load_instance(self.update_request_body_schema):
+        if self.get_schema_load_instance(self.update_request_body_schema_cls):
             kwargs["instance"] = self.instance
-        self.loaded_body = self.update_request_body_schema.load(**kwargs)
+        self.loaded_body = self.update_request_body_schema_cls().load(**kwargs)
 
-    def get_schema_load_instance(self, schema):
+    def get_schema_load_instance(self, schema_cls):
         try:
-            return schema.Meta.load_instance
+            return schema_cls.Meta.load_instance
         except AttributeError:
             return False
 
@@ -262,23 +264,23 @@ def update(self):
 
     def get_update_response(self):
         return self.get_schema_success_data(
-            schema=self.update_response_body_schema,
+            schema_cls=self.update_response_body_schema_cls,
             data=self.instance,
         )
 
 
 class Delete(BaseView):
-    delete_kwargs_schema = None
-    delete_args_schema = None
-    delete_body_schema = None
-    delete_response_body_schema = None
-    response_body_schema = None
+    delete_kwargs_schema_cls = None
+    delete_args_schema_cls = None
+    delete_body_schema_cls = None
+    delete_response_body_schema_cls = None
+    response_body_schema_cls = None
 
     instance = None
 
     def handle_delete(self, *args, **kwargs):
-        self.handle_kwargs(self.delete_kwargs_schema)
-        self.handle_args(self.delete_args_schema)
+        self.handle_kwargs(self.delete_kwargs_schema_cls)
+        self.handle_args(self.delete_args_schema_cls)
         self.instance = self.get_instance()
         self.instance = self.delete()
         self.db.session.commit()
@@ -294,6 +296,6 @@ def delete(self):
 
     def get_delete_response(self):
         return self.get_schema_success_data(
-            schema=self.delete_response_body_schema,
+            schema_cls=self.delete_response_body_schema_cls,
             data=self.instance,
         )