Refactor methods

Author: n0nSmoker

sqlalchemy_serializer/serializer.py

@@ -116,6 +116,8 @@ class Serializer:
     def __init__(self, **kwargs):
         self.set_serialization_depth(0)
         self.set_options(Options(**kwargs))
+        self.init_callbacks()
+
         self.schema = Schema()
 
     def __call__(self, value, only=(), extend=()):
@@ -136,10 +138,9 @@ def set_serialization_depth(self, value: int):
 
     def set_options(self, opts: Options):
         self.opts = opts
-        self.apply_opts()
 
-    def apply_opts(self):
-        """Apply current Options to callbacks"""
+    def init_callbacks(self):
+        """Initialize callbacks"""
         self.serialize_types = (
             *(self.opts.serialize_types or ()),
             (self.atomic_types, lambda x: x),  # Should be checked before any other type
@@ -187,17 +188,17 @@ def is_forkable(self, value):
             value, (Iterable, dict, SerializerMixin)
         )
 
-    def fork(self, value, key: str):
+    def fork(self, key: str) -> "Serializer":
         """
-        Process data in a separate serializer
+        Return new serializer for a key
         :return: serialized value
         """
         serializer = Serializer(**self.opts._asdict())
         serializer.set_serialization_depth(self.serialization_depth + 1)
         serializer.schema = self.schema.fork(key=key)
 
-        logger.debug("Fork serializer for type:%s key:%s", get_type(value), key)
-        return serializer(value)
+        logger.debug("Fork serializer for key:%s", key)
+        return serializer
 
     def serialize(self, value):
         if self.is_valid_callable(value):
@@ -225,10 +226,12 @@ def serialize_dict(self, value: dict) -> dict:
         for k, v in value.items():
             if self.schema.is_included(k):  # TODO: Skip check if is NOT greedy
                 logger.debug("Serialize key:%s type:%s of dict", k, get_type(v))
+
+                serializer = self
                 if self.is_forkable(v):
-                    res[k] = self.fork(key=k, value=v)
-                else:
-                    res[k] = self.serialize(v)
+                    serializer = self.fork(key=k)
+
+                res[k] = serializer.serialize(v)
             else:
                 logger.debug("Skip key:%s of dict", k)
         return res
@@ -247,10 +250,12 @@ def serialize_model(self, value) -> dict:
                 logger.debug(
                     "Serialize key:%s type:%s model:%s", k, get_type(v), get_type(value)
                 )
+
+                serializer = self
                 if self.is_forkable(v):
-                    res[k] = self.fork(key=k, value=v)
-                else:
-                    res[k] = self.serialize(v)
+                    serializer = self.fork(key=k)
+
+                res[k] = serializer.serialize(v)
 
             else:
                 logger.debug("Skip key:%s of model:%s", k, get_type(value))

tests/test_serializer_fork_function.py

@@ -1,28 +1,26 @@
+from sqlalchemy_serializer.serializer import Serializer
+
+
 def test_fork_with_key(mocker, get_serializer):
-    value, key, expected = "test_value", "test_key", "serialized"
+    key = "test_value"
     schema = mocker.MagicMock()
     serializer = get_serializer()
 
-    mocker.patch(
-        "sqlalchemy_serializer.serializer.Serializer.__call__", return_value=expected
-    )
-
     mocker.patch.object(serializer, "schema", schema)
-    result = serializer.fork(value=value, key=key)
+    result = serializer.fork(key=key)
 
-    assert result == expected
+    assert isinstance(result, Serializer)
+    assert result.opts == serializer.opts
     schema.fork.assert_called_once_with(key=key)
 
 
 def test_fork_logger(mocker, get_serializer):
-    value, key = "test_value", "test_key"
+    key = "test_key"
     mocked_logger = mocker.patch("sqlalchemy_serializer.serializer.logger")
     mocker.patch("sqlalchemy_serializer.serializer.Serializer.__call__")
     serializer = get_serializer()
 
     mocker.patch.object(serializer, "schema", mocker.MagicMock())
-    serializer.fork(value, key=key)
+    serializer.fork(key=key)
 
-    mocked_logger.debug.assert_called_once_with(
-        "Fork serializer for type:%s key:%s", "str", key
-    )
+    mocked_logger.debug.assert_called_once_with("Fork serializer for key:%s", key)