Revert "add max_depth arg to control recursion"

Author: n0nSmoker

README.md

@@ -11,7 +11,6 @@ this mixin definitely suits you.
 - [Advanced usage](#Advanced-usage)
 - [Custom formats](#Custom-formats)
 - [Custom types](#Custom-types)
-- [Custom Serializer](#Custom-serializer)
 - [Timezones](#Timezones)
 - [Troubleshooting](#Troubleshooting)
 - [Tests](#Tests)
@@ -187,42 +186,6 @@ item.to_dict('-children.children')
 In this case only the first level of `children` will be included
 See [Max recursion](#Max-recursion)
 
-Alternatively you can pass the `max_depth` kwarg, which allows to control recursion in general without having to explicitly list each attribute you don't want recursed.  
-Please note that this check is performed at the beginning of `serialize_model()`, which means every other nested Iterable is *not affected* by this setting.  
-The default value returned when recursion is no longer permitted is a string in the form `tablename.id` (e.g. `users.123`), with fallback to `repr(item)` in case the `id` attribute is not available for the model.  
-This option can be disabled using `max_depth=-1`, which is also the default.  
-```python
-# Stop recursion at top level, meaning all relationships will be "dropped"
-# For example:
-#  item = User(id=123, name="john", articles=[Article(id=10), Article(id=11)])
-# will be serialized to
-#  {
-#    "id": 123, "name": "john",
-#    "articles": ["articles.10", "articles.11"]
-#  }
-item.to_dict(max_depth=0)
-
-# Stop at first level, meaning only the first children will be processed
-# For example, the same user above will be serialized to:
-#  {
-#    "id": 123, "name": "john",
-#    "articles": [
-#      {"id": 10, "title": ...},
-#      {"id": 11, "title": ...},
-#    ]
-#  }
-item.to_dict(max_depth=1)
-```
-The `max_depth` option can be also configured at mixin level, setting the `serialize_max_depth` class attribute which avoids passing it to each `to_dict` call.
-```python
-# Set max_depth option in mixin
-class SomeModel(db.Model, SerializerMixin):
-  serialize_max_depth = 0
-
-# Call to_dict without max_depth arg
-item.to_dict()
-```
-
 # Custom formats
 If you want to change datetime/date/time/decimal format in one model you can specify it like below:
 ```python
@@ -341,27 +304,6 @@ Unfortunately you can not access formats or tzinfo in that functions.
 I'll implement this logic later if any of users needs it.
 
 
-# Custom Serializer
-To have full control over the Serializer, you can define your own subclass with custom logic, and then configure the mixin to use it.
-```python
-from sqlalchemy_serializer import Serializer, SerializerMixin
-
-
-class CustomSerializer(Serializer):
-
-    def serialize_model(self, value) -> dict:
-        """Custom override adding special case for a complex model."""
-        if isinstance(value, ComplexModel):
-            return complex_logic(value)
-        return super().serialize_model(value)
-
-
-class CustomSerializerMixin(SerializerMixin):
-
-    serialize_class = CustomSerializer
-```
-
-
 # Timezones
 To keep `datetimes` consistent its better to store it in the database normalized to **UTC**.
 But when you return response, sometimes (mostly in web, mobile applications can do it themselves)

sqlalchemy_serializer/serializer.py

@@ -19,18 +19,88 @@
 logger.setLevel(level="WARN")
 
 
-Options = namedtuple(
-    "Options",
-    "date_format datetime_format time_format decimal_format tzinfo serialize_types max_depth",
-)
+class SerializerMixin:
+    """
+    Mixin for retrieving public fields of sqlAlchemy-model in json-compatible format
+    with no pain
+    It can be inherited to redefine get_tzinfo callback, datetime formats or to add
+    some extra serialization logic
+    """
 
+    # Default exclusive schema.
+    # If left blank, serializer becomes greedy and takes all SQLAlchemy-model's attributes
+    serialize_only: tuple = ()
 
-class IsNotSerializable(Exception):
-    pass
+    # Additions to default schema. Can include negative rules
+    serialize_rules: tuple = ()
 
+    # Extra serialising functions
+    serialize_types: tuple = ()
 
-def get_type(value) -> str:
-    return type(value).__name__
+    # Custom list of fields to serialize in this model
+    serializable_keys: tuple = ()
+
+    date_format = "%Y-%m-%d"
+    datetime_format = "%Y-%m-%d %H:%M:%S"
+    time_format = "%H:%M"
+    decimal_format = "{}"
+
+    # Serialize fields of the model defined as @property automatically
+    auto_serialize_properties: bool = False
+
+    def get_tzinfo(self):
+        """
+        Callback to make serializer aware of user's timezone. Should be redefined if needed
+        Example:
+            return pytz.timezone('Africa/Abidjan')
+
+        :return: datetime.tzinfo
+        """
+        return None
+
+    def to_dict(
+        self,
+        only=(),
+        rules=(),
+        date_format=None,
+        datetime_format=None,
+        time_format=None,
+        tzinfo=None,
+        decimal_format=None,
+        serialize_types=None,
+    ):
+        """
+        Returns SQLAlchemy model's data in JSON compatible format
+
+        For details about datetime formats follow:
+        https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior
+
+        :param only: exclusive schema to replace the default one
+            always have higher priority than rules
+        :param rules: schema to extend default one or schema defined in "only"
+        :param date_format: str
+        :param datetime_format: str
+        :param time_format: str
+        :param decimal_format: str
+        :param serialize_types:
+        :param tzinfo: datetime.tzinfo converts datetimes to local user timezone
+        :return: data: dict
+        """
+        s = Serializer(
+            date_format=date_format or self.date_format,
+            datetime_format=datetime_format or self.datetime_format,
+            time_format=time_format or self.time_format,
+            decimal_format=decimal_format or self.decimal_format,
+            tzinfo=tzinfo or self.get_tzinfo(),
+            serialize_types=serialize_types or self.serialize_types,
+        )
+        return s(self, only=only, extend=rules)
+
+
+Options = namedtuple(
+    "Options",
+    "date_format datetime_format time_format decimal_format tzinfo serialize_types",
+)
 
 
 class Serializer:
@@ -123,7 +193,7 @@ def fork(self, key: str) -> "Serializer":
         Return new serializer for a key
         :return: serializer
         """
-        serializer = self.__class__(**self.opts._asdict())
+        serializer = Serializer(**self.opts._asdict())
         serializer.set_serialization_depth(self.serialization_depth + 1)
         serializer.schema = self.schema.fork(key=key)
 
@@ -197,12 +267,7 @@ def serialize_dict(self, value: dict) -> dict:
                 logger.debug("Skip key:%s of dict", k)
         return res
 
-    def serialize_model(self, value) -> t.Any:
-        # Check if user set a recursion limit and we can no longer recurse
-        if self.serialization_depth > self.opts.max_depth > -1:
-            # Return early calling internal helper
-            return self.serialize_model_fallback(value)
-
+    def serialize_model(self, value) -> dict:
         self.schema.update(only=value.serialize_only, extend=value.serialize_rules)
 
         res = {}
@@ -225,106 +290,14 @@ def serialize_model(self, value) -> t.Any:
                 logger.debug("Skip key:%s of model:%s", k, get_type(value))
         return res
 
-    def serialize_model_fallback(self, value) -> t.Any:
-        """
-        Called when serialization can no longer recurse.
-        Default output is a string like "tablename.id", e.g. "users.123", if attributes
-        are not available it will return "repr(value)".
-        Override this method to implement own logic.
-        :return: str
-        """
-        try:
-            return f'{value.__tablename__}.{value.id}'
-        except AttributeError:
-            return repr(value)
-
-
-def serialize_collection(iterable: t.Iterable, *args, **kwargs) -> list:
-    return [item.to_dict(*args, **kwargs) for item in iterable]
-
-
-class SerializerMixin:
-    """
-    Mixin for retrieving public fields of sqlAlchemy-model in json-compatible format
-    with no pain
-    It can be inherited to redefine get_tzinfo callback, datetime formats or to add
-    some extra serialization logic
-    """
-
-    # Default Serializer class
-    serialize_class: Serializer = Serializer
-
-    # Default exclusive schema.
-    # If left blank, serializer becomes greedy and takes all SQLAlchemy-model's attributes
-    serialize_only: tuple = ()
-
-    # Additions to default schema. Can include negative rules
-    serialize_rules: tuple = ()
 
-    # Extra serialising functions
-    serialize_types: tuple = ()
-
-    # Custom list of fields to serialize in this model
-    serializable_keys: tuple = ()
-
-    date_format = "%Y-%m-%d"
-    datetime_format = "%Y-%m-%d %H:%M:%S"
-    time_format = "%H:%M"
-    decimal_format = "{}"
-
-    # Maximum recursion depth, setting to "-1" disables logic
-    serialize_max_depth: int = -1
-
-    # Serialize fields of the model defined as @property automatically
-    auto_serialize_properties: bool = False
-
-    def get_tzinfo(self):
-        """
-        Callback to make serializer aware of user's timezone. Should be redefined if needed
-        Example:
-            return pytz.timezone('Africa/Abidjan')
+class IsNotSerializable(Exception):
+    pass
 
-        :return: datetime.tzinfo
-        """
-        return None
 
-    def to_dict(
-        self,
-        only=(),
-        rules=(),
-        date_format=None,
-        datetime_format=None,
-        time_format=None,
-        tzinfo=None,
-        decimal_format=None,
-        serialize_types=None,
-        max_depth=None
-    ):
-        """
-        Returns SQLAlchemy model's data in JSON compatible format
+def get_type(value) -> str:
+    return type(value).__name__
 
-        For details about datetime formats follow:
-        https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior
 
-        :param only: exclusive schema to replace the default one
-            always have higher priority than rules
-        :param rules: schema to extend default one or schema defined in "only"
-        :param date_format: str
-        :param datetime_format: str
-        :param time_format: str
-        :param decimal_format: str
-        :param serialize_types:
-        :param tzinfo: datetime.tzinfo converts datetimes to local user timezone
-        :param max_depth: int maximum recursion depth allowed, "-1" disables logic
-        :return: data: dict
-        """
-        s = self.serialize_class(
-            date_format=date_format or self.date_format,
-            datetime_format=datetime_format or self.datetime_format,
-            time_format=time_format or self.time_format,
-            decimal_format=decimal_format or self.decimal_format,
-            tzinfo=tzinfo or self.get_tzinfo(),
-            serialize_types=serialize_types or self.serialize_types,
-            max_depth=max_depth if max_depth is not None else self.serialize_max_depth,
-        )
-        return s(self, only=only, extend=rules)
+def serialize_collection(iterable: t.Iterable, *args, **kwargs) -> list:
+    return [item.to_dict(*args, **kwargs) for item in iterable]