Remove skip parameter in _Serializer::parse, add flat argument in _Serializer::__init__. Add _Serializer::__flatten class method. Fix small bugs in bfxapi.rest.endpoints.rest_public_endpoints and bfxapi.rest.endpoints.rest_authenticated_endpoints.

bfxapi/labeler.py

@@ -1,4 +1,4 @@
-from typing import Type, Generic, TypeVar, Iterable, Optional, Dict, List, Tuple, Any, cast
+from typing import Type, Generic, TypeVar, Iterable, Dict, List, Tuple, Any, cast
 
 from .exceptions import LabelerSerializerException
 
@@ -35,53 +35,63 @@ class _Type:
 
 class _Serializer(Generic[T]):
     def __init__(self, name: str, klass: Type[_Type], labels: List[str],
-                 *, ignore: List[str] = [ "_PLACEHOLDER" ]):
-        self.name, self.klass, self.__labels, self.__ignore = name, klass, labels, ignore
+                 *, flat: bool = False, ignore: List[str] = [ "_PLACEHOLDER" ]):
+        self.name, self.klass, self.__labels, self.__flat, self.__ignore = name, klass, labels, flat, ignore
 
-    def _serialize(self, *args: Any, skip: Optional[List[str]] = None) -> Iterable[Tuple[str, Any]]:
-        labels, skips = [], []
+    def _serialize(self, *args: Any) -> Iterable[Tuple[str, Any]]:
+        if self.__flat:
+            args = tuple(_Serializer.__flatten(list(args)))
 
-        for label in self.__labels:
-            (labels, skips)[label in (skip or [])].append(label)
-
-        if len(labels) > len(args):
+        if len(self.__labels) > len(args):
             raise LabelerSerializerException(f"{self.name} -> <labels> and <*args> " \
                 "arguments should contain the same amount of elements.")
 
-        for index, label in enumerate(labels):
+        for index, label in enumerate(self.__labels):
             if label not in self.__ignore:
                 yield label, args[index]
 
-        for skip in skips:
-            yield skip, None
-
-    def parse(self, *values: Any, skip: Optional[List[str]] = None) -> T:
-        return cast(T, self.klass(**dict(self._serialize(*values, skip=skip))))
+    def parse(self, *values: Any) -> T:
+        return cast(T, self.klass(**dict(self._serialize(*values))))
 
     def get_labels(self) -> List[str]:
         return [ label for label in self.__labels if label not in self.__ignore ]
 
+    @classmethod
+    def __flatten(cls, array: List[Any]) -> List[Any]:
+        if len(array) == 0:
+            return array
+
+        if isinstance(array[0], list):
+            return cls.__flatten(array[0]) + cls.__flatten(array[1:])
+
+        return array[:1] + cls.__flatten(array[1:])
+
 class _RecursiveSerializer(_Serializer, Generic[T]):
     def __init__(self, name: str, klass: Type[_Type], labels: List[str],
-                 *, serializers: Dict[str, _Serializer[Any]], ignore: List[str] = ["_PLACEHOLDER"]):
-        super().__init__(name, klass, labels, ignore = ignore)
+                 *, serializers: Dict[str, _Serializer[Any]],
+                     flat: bool = False, ignore: List[str] = [ "_PLACEHOLDER" ]):
+        super().__init__(name, klass, labels, flat=flat, ignore=ignore)
 
         self.serializers = serializers
 
-    def parse(self, *values: Any, skip: Optional[List[str]] = None) -> T:
-        serialization = dict(self._serialize(*values, skip=skip))
+    def parse(self, *values: Any) -> T:
+        serialization = dict(self._serialize(*values))
 
         for key in serialization:
             if key in self.serializers.keys():
-                serialization[key] = self.serializers[key].parse(*serialization[key], skip=skip)
+                serialization[key] = self.serializers[key].parse(*serialization[key])
 
         return cast(T, self.klass(**serialization))
 
 def generate_labeler_serializer(name: str, klass: Type[T], labels: List[str],
-                                *, ignore: List[str] = [ "_PLACEHOLDER" ]) -> _Serializer[T]:
-    return _Serializer[T](name, klass, labels, ignore=ignore)
+                                *, flat: bool = False, ignore: List[str] = [ "_PLACEHOLDER" ]
+                               ) -> _Serializer[T]:
+    return _Serializer[T](name, klass, labels, \
+        flat=flat, ignore=ignore)
 
 def generate_recursive_serializer(name: str, klass: Type[T], labels: List[str],
-                                  *, serializers: Dict[str, _Serializer[Any]], ignore: List[str] = [ "_PLACEHOLDER" ]
-                                  ) -> _RecursiveSerializer[T]:
-    return _RecursiveSerializer[T](name, klass, labels, serializers=serializers, ignore=ignore)
+                                  *, serializers: Dict[str, _Serializer[Any]],
+                                      flat: bool = False, ignore: List[str] = [ "_PLACEHOLDER" ]
+                                 ) -> _RecursiveSerializer[T]:
+    return _RecursiveSerializer[T](name, klass, labels, \
+        serializers=serializers, flat=flat, ignore=ignore)