Merge pull request #7 from Mng-dev-ai/add-call-to-schema-trait

Add call to schema trait

Author: Mng-dev-ai

schemars/__init__.py

@@ -40,6 +40,7 @@ def __new__(cls, **kwargs):
             strict=kwargs.get("strict", False),
             default=kwargs.get("default", None),
             source=kwargs.get("source", None),
+            call=kwargs.get("call", False),
             serialize_func=kwargs.get("serialize_func", None),
             context=kwargs.get("context", {}),
         )
@@ -60,6 +61,7 @@ def __init__(self, **kwargs):
         self.source = kwargs.get("source", None)
         self.write_only = kwargs.get("write_only", False)
         self.strict = kwargs.get("strict", False)
+        self.call = kwargs.get("call", False)
         self.default = kwargs.get("default", None)
         self.serialize_func = kwargs.get("serialize_func", None)
         self.context = kwargs.get("context", {})

src/schema.rs

@@ -76,10 +76,15 @@ impl_py_methods!(Schema, required, { fields: HashMap<String, Field>, context: Ha
         many: Option<bool>,
         parent: Option<PyObject>,
     ) -> PyResult<PyObject> {
+        if instance.is_none() {
+            return Ok(py.None());
+        }
+
         if let Some(callback) = &self.base.serialize_func {
             let result = callback.call1(py, (instance,))?;
             return Ok(result);
         }
+
         if let Some(true) = many {
             let pylist = instance.downcast::<PyList>()?;
             let mut results: Vec<PyObject> = Vec::with_capacity(pylist.len());
@@ -153,4 +158,7 @@ impl FieldTrait for Schema {
     fn is_method_field(&self) -> bool {
         self.base.is_method_field
     }
+    fn call(&self) -> bool {
+        self.base.call
+    }
 }

tests/test_schema.py

@@ -1,154 +1,185 @@
 import pytest
 import schemars
 
+
 def test_serialize_many():
     class Product:
         def __init__(self, name):
             self.name = name
+
     class ProductSchema(schemars.Schema):
         name = schemars.Str()
-        
+
     schema = ProductSchema()
     products = [
         Product("Product 1"),
         Product("Product 2"),
     ]
-    result = schema.serialize(products,many=True)
+    result = schema.serialize(products, many=True)
     assert result == [{"name": "Product 1"}, {"name": "Product 2"}]
 
+
 def test_serialize_with_default():
     class Product:
         def __init__(self, name=None):
             self.name = name
+
     class ProductSchema(schemars.Schema):
         name = schemars.Str(default="Product 1")
-        
+
     schema = ProductSchema()
     product = Product()
     result = schema.serialize(product)
     assert result == {"name": "Product 1"}
-    
+
+
 def test_serialize_with_default_none():
     class Product:
         def __init__(self, name=None):
             self.name = name
+
     class ProductSchema(schemars.Schema):
         name = schemars.Str(default=None)
-        
+
     schema = ProductSchema()
     product = Product()
     result = schema.serialize(product)
     assert result == {"name": None}
-    
+
+
 def test_serialize_with_write_only():
     class Product:
         def __init__(self, name):
             self.name = name
+
     class ProductSchema(schemars.Schema):
         name = schemars.Str(write_only=True)
-        
+
     schema = ProductSchema()
     product = Product("Product 1")
     result = schema.serialize(product)
     assert result == {}
-    
+
+
 def test_serialize_with_source():
     class User:
         def __init__(self, name, age):
             self.name = name
             self.age = age
-            
+
     class Product:
         def __init__(self, user):
             self.user = user
-            
+
     class ProductSchema(schemars.Schema):
         name = schemars.Str(source="user.name")
         age = schemars.Int(source="user.age")
-        
 
     schema = ProductSchema()
     user = User("John", 30)
     product = Product(user)
     result = schema.serialize(product)
     assert result == {"name": "John", "age": 30}
-    
+
+
 def test_serialize_with_call():
     def custom_func():
         return "test"
-    
+
+    def get_tags():
+        return [
+            Tag("tag1"),
+            Tag("tag2"),
+        ]
+
     class Product:
         @property
         def test(self):
             return custom_func
-                
+
+        @property
+        def tags(self):
+            return get_tags
+
+    class Tag:
+        def __init__(self, name):
+            self.name = name
+
+    class TagSchema(schemars.Schema):
+        name = schemars.Str()
+
     class ProductSchema(schemars.Schema):
         test = schemars.Str(call=True)
-            
+        tags = TagSchema(many=True, call=True)
+
     schema = ProductSchema()
     product = Product()
     result = schema.serialize(product)
-    assert result == {"test": "test"}
-    
+    assert result == {"test": "test", "tags": [{"name": "tag1"}, {"name": "tag2"}]}
+
+
 def test_serialize_with_serialize_func():
     class ProductSchema(schemars.Schema):
         name = schemars.Str(serialize_func=lambda name: name.upper())
-        
+
     class Product:
         def __init__(self, name):
             self.name = name
-            
+
     schema = ProductSchema()
     product = Product("Product 1")
     result = schema.serialize(product)
     assert result == {"name": "PRODUCT 1"}
-    
+
+
 def test_serialize_with_nested():
     class User:
         def __init__(self, name, age):
             self.name = name
             self.age = age
-    
+
     class Product:
         def __init__(self, user):
             self.user = user
-            
+
     class UserSchema(schemars.Schema):
         name = schemars.Str()
         age = schemars.Int()
-        
+
     class ProductSchema(schemars.Schema):
         user = UserSchema()
-        
+
     schema = ProductSchema()
     user = User("John", 30)
     product = Product(user)
     result = schema.serialize(product)
     assert result == {"user": {"name": "John", "age": 30}}
-    
+
+
 def test_serialize_with_nested_many():
     class User:
         def __init__(self, name, age):
             self.name = name
             self.age = age
-            
+
     class Product:
         def __init__(self, users):
             self.users = users
-            
+
     class UserSchema(schemars.Schema):
         name = schemars.Str()
         age = schemars.Int()
-        
+
     class ProductSchema(schemars.Schema):
         users = UserSchema(many=True)
-        
+
     schema = ProductSchema()
     user = User("John", 30)
     product = Product([user])
     result = schema.serialize(product)
     assert result == {"users": [{"name": "John", "age": 30}]}
 
+
 def test_serialize_with_context():
     class Product:
         def __init__(self, name):
@@ -158,16 +189,16 @@ class ProductSchema(schemars.Schema):
         name = schemars.Str()
 
         def serialize(self, instance, many=None):
-            context_suffix = self.context.get('suffix') if self.context else ''
+            context_suffix = self.context.get("suffix") if self.context else ""
             result = super().serialize(instance, many)
             if not many:
-                result['name'] += context_suffix
+                result["name"] += context_suffix
             else:
                 for item in result:
-                    item['name'] += context_suffix
+                    item["name"] += context_suffix
             return result
-    
-    schema = ProductSchema(context={'suffix': ' - Context'})
+
+    schema = ProductSchema(context={"suffix": " - Context"})
     product = Product("Product 1")
     result = schema.serialize(product)
     assert result == {"name": "Product 1 - Context"}