chore: Include callables with default args in serialization

Author: n0nSmoker

sqlalchemy_serializer/serializer.py

@@ -86,7 +86,7 @@ def to_dict(
         exclude_values=None,
         max_serialization_depth=None,
         serialize_columns=None,
-    ):
+    ) -> dict:
         """Returns SQLAlchemy model's data in JSON compatible format
 
         For details about datetime formats follow:
@@ -224,16 +224,28 @@ def init_callbacks(self):
     @staticmethod
     def is_valid_callable(func) -> bool:
         """Determines objects that should be called before serialization"""
-        if callable(func):
-            i = inspect.getfullargspec(func)
-            if (
-                i.args == ["self"]
-                and isinstance(func, MethodType)
-                and not any([i.varargs, i.varkw])
-            ):
-                return True
-            return not any([i.args, i.varargs, i.varkw])
-        return False
+        if not callable(func):
+            return False
+
+        i = inspect.getfullargspec(func)
+
+        # Check for varargs/varkw
+        # (methods with *args or **kwargs are not callable without args)
+        if any([i.varargs, i.varkw]):
+            return False
+
+        # For methods: check if all args except 'self' have defaults
+        if isinstance(func, MethodType):
+            if not i.args or i.args[0] != "self":
+                return False
+            # All args except self must have defaults
+            args_count = len(i.args) - 1
+        else:
+            # For functions: all args must have defaults
+            args_count = len(i.args) if i.args else 0
+
+        defaults_count = len(i.defaults) if i.defaults else 0
+        return args_count == defaults_count
 
     def is_forkable(self, value):
         """Determines if object should be processed in a separate serializer"""

tests/test_flat_model.py

@@ -1,4 +1,6 @@
-from .models import DATE, DATETIME, MONEY, TIME, FlatModel
+import sqlalchemy as sa
+
+from .models import DATE, DATETIME, MONEY, TIME, Base, FlatModel, SerializerMixin
 
 
 def test_no_defaults_no_rules(get_instance):
@@ -345,3 +347,66 @@ def test_rules_for_nested_dicts_and_lists(get_instance):
 
     assert "prop" in data
     assert data["prop"] == i.prop
+
+
+def test_method_with_default_argument():
+    """Test that methods with default arguments are serialized"""
+
+    class ModelWithDefaultMethod(Base, SerializerMixin):
+        __tablename__ = "model_with_default_method"
+        serialize_only = ()
+        serialize_rules = ()
+
+        id = sa.Column(sa.Integer, primary_key=True)
+        string = sa.Column(sa.String(256), default="test")
+
+        def is_liked(self, user=None):
+            return user is not None
+
+    i = ModelWithDefaultMethod(id=1, string="test")
+    data = i.to_dict(rules=("is_liked",))
+
+    assert "is_liked" in data
+    assert data["is_liked"] is False  # Called without args, user=None
+
+
+def test_method_with_multiple_defaults():
+    """Test method with multiple default arguments"""
+
+    class ModelWithMultiDefaults(Base, SerializerMixin):
+        __tablename__ = "model_with_multi_defaults"
+        serialize_only = ()
+        serialize_rules = ()
+
+        id = sa.Column(sa.Integer, primary_key=True)
+        string = sa.Column(sa.String(256), default="test")
+
+        def compute(self, a=1, b=2):
+            return a + b
+
+    i = ModelWithMultiDefaults(id=1, string="test")
+    data = i.to_dict(rules=("compute",))
+
+    assert "compute" in data
+    assert data["compute"] == 3  # 1 + 2
+
+
+def test_method_with_required_arg_rejected():
+    """Test that methods with required args are still rejected"""
+
+    class ModelWithRequiredArg(Base, SerializerMixin):
+        __tablename__ = "model_with_required_arg"
+        serialize_only = ()
+        serialize_rules = ()
+
+        id = sa.Column(sa.Integer, primary_key=True)
+        string = sa.Column(sa.String(256), default="test")
+
+        def method_required(self, user):  # No default
+            return user
+
+    i = ModelWithRequiredArg(id=1, string="test")
+    data = i.to_dict(rules=("method_required",))
+
+    # Should not be serialized (not callable without args)
+    assert "method_required" not in data