diracx-client 0.0.1a44__py3-none-any.whl → 0.0.1a46__py3-none-any.whl

diracx/client/_generated/_utils/serialization.py

@@ -1,7 +1,7 @@
 # pylint: disable=line-too-long,useless-suppression,too-many-lines
 # coding=utf-8
 # --------------------------------------------------------------------------
-# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.10.4, generator: @autorest/python@6.34.1)
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.10.4, generator: @autorest/python@6.34.2)
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
@@ -58,9 +58,7 @@ class RawDeserializer:
     CONTEXT_NAME = "deserialized_data"
 
     @classmethod
-    def deserialize_from_text(
-        cls, data: Optional[Union[AnyStr, IO]], content_type: Optional[str] = None
-    ) -> Any:
+    def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: Optional[str] = None) -> Any:
         """Decode data according to content-type.
 
         Accept a stream of data as well, but will be load at once in memory for now.
@@ -93,9 +91,7 @@ class RawDeserializer:
             try:
                 return json.loads(data_as_str)
             except ValueError as err:
-                raise DeserializationError(
-                    "JSON is invalid: {}".format(err), err
-                ) from err
+                raise DeserializationError("JSON is invalid: {}".format(err), err) from err
         elif "xml" in (content_type or []):
             try:
 
@@ -129,14 +125,10 @@ class RawDeserializer:
                 raise DeserializationError("XML is invalid") from err
         elif content_type.startswith("text/"):
             return data_as_str
-        raise DeserializationError(
-            "Cannot deserialize content-type: {}".format(content_type)
-        )
+        raise DeserializationError("Cannot deserialize content-type: {}".format(content_type))
 
     @classmethod
-    def deserialize_from_http_generics(
-        cls, body_bytes: Optional[Union[AnyStr, IO]], headers: Mapping
-    ) -> Any:
+    def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]], headers: Mapping) -> Any:
         """Deserialize from HTTP response.
 
         Use bytes and headers to NOT use any requests/aiohttp or whatever
@@ -188,9 +180,7 @@ def attribute_transformer(key, attr_desc, value):  # pylint: disable=unused-argu
     return (key, value)
 
 
-def full_restapi_key_transformer(
-    key, attr_desc, value
-):  # pylint: disable=unused-argument
+def full_restapi_key_transformer(key, attr_desc, value):  # pylint: disable=unused-argument
     """A key transformer that returns the full RestAPI key path.
 
     :param str key: The attribute name
@@ -245,17 +235,9 @@ class Model:
         self.additional_properties: Optional[Dict[str, Any]] = {}
         for k in kwargs:  # pylint: disable=consider-using-dict-items
             if k not in self._attribute_map:
-                _LOGGER.warning(
-                    "%s is not a known attribute of class %s and will be ignored",
-                    k,
-                    self.__class__,
-                )
+                _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__)
             elif k in self._validation and self._validation[k].get("readonly", False):
-                _LOGGER.warning(
-                    "Readonly attribute %s will be ignored in class %s",
-                    k,
-                    self.__class__,
-                )
+                _LOGGER.warning("Readonly attribute %s will be ignored in class %s", k, self.__class__)
             else:
                 setattr(self, k, kwargs[k])
 
@@ -306,11 +288,7 @@ class Model:
         except AttributeError:
             xml_map = {}
 
-        return _create_xml_node(
-            xml_map.get("name", cls.__name__),
-            xml_map.get("prefix", None),
-            xml_map.get("ns", None),
-        )
+        return _create_xml_node(xml_map.get("name", cls.__name__), xml_map.get("prefix", None), xml_map.get("ns", None))
 
     def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON:
         """Return the JSON that would be sent to server from this model.
@@ -331,10 +309,8 @@ class Model:
     def as_dict(
         self,
         keep_readonly: bool = True,
-        key_transformer: Callable[
-            [str, Dict[str, Any], Any], Any
-        ] = attribute_transformer,
-        **kwargs: Any,
+        key_transformer: Callable[[str, Dict[str, Any], Any], Any] = attribute_transformer,
+        **kwargs: Any
     ) -> JSON:
         """Return a dict that can be serialized using json.dump.
 
@@ -377,9 +353,7 @@ class Model:
         try:
             str_models = cls.__module__.rsplit(".", 1)[0]
             models = sys.modules[str_models]
-            client_models = {
-                k: v for k, v in models.__dict__.items() if isinstance(v, type)
-            }
+            client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
             if cls.__name__ not in client_models:
                 raise ValueError("Not Autorest generated code")
         except Exception:  # pylint: disable=broad-exception-caught
@@ -438,9 +412,7 @@ class Model:
             return {}
         result = dict(cls._subtype_map[key])
         for valuetype in cls._subtype_map[key].values():
-            result.update(
-                objects[valuetype]._flatten_subtype(key, objects)
-            )  # pylint: disable=protected-access
+            result.update(objects[valuetype]._flatten_subtype(key, objects))  # pylint: disable=protected-access
         return result
 
     @classmethod
@@ -458,13 +430,9 @@ class Model:
 
             if not isinstance(response, ET.Element):
                 rest_api_response_key = cls._get_rest_key_parts(subtype_key)[-1]
-                subtype_value = response.get(
-                    rest_api_response_key, None
-                ) or response.get(subtype_key, None)
+                subtype_value = response.get(rest_api_response_key, None) or response.get(subtype_key, None)
             else:
-                subtype_value = xml_key_extractor(
-                    subtype_key, cls._attribute_map[subtype_key], response
-                )
+                subtype_value = xml_key_extractor(subtype_key, cls._attribute_map[subtype_key], response)
             if subtype_value:
                 # Try to match base class. Can be class name only
                 # (bug to fix in Autorest to support x-ms-discriminator-name)
@@ -481,11 +449,7 @@ class Model:
                     )
                     break
             else:
-                _LOGGER.warning(
-                    "Discriminator %s is absent or null, use base class %s.",
-                    subtype_key,
-                    cls.__name__,
-                )
+                _LOGGER.warning("Discriminator %s is absent or null, use base class %s.", subtype_key, cls.__name__)
                 break
         return cls
 
@@ -597,25 +561,18 @@ class Serializer:  # pylint: disable=too-many-public-methods
         try:
             is_xml_model_serialization = kwargs["is_xml"]
         except KeyError:
-            is_xml_model_serialization = kwargs.setdefault(
-                "is_xml", target_obj.is_xml_model()
-            )
+            is_xml_model_serialization = kwargs.setdefault("is_xml", target_obj.is_xml_model())
 
         serialized = {}
         if is_xml_model_serialization:
-            serialized = (
-                target_obj._create_xml_node()
-            )  # pylint: disable=protected-access
+            serialized = target_obj._create_xml_node()  # pylint: disable=protected-access
         try:
             attributes = target_obj._attribute_map  # pylint: disable=protected-access
             for attr, attr_desc in attributes.items():
                 attr_name = attr
-                if (
-                    not keep_readonly
-                    and target_obj._validation.get(  # pylint: disable=protected-access
-                        attr_name, {}
-                    ).get("readonly", False)
-                ):
+                if not keep_readonly and target_obj._validation.get(  # pylint: disable=protected-access
+                    attr_name, {}
+                ).get("readonly", False):
                     continue
 
                 if attr_name == "additional_properties" and attr_desc["key"] == "":
@@ -628,15 +585,11 @@ class Serializer:  # pylint: disable=too-many-public-methods
                     if is_xml_model_serialization:
                         pass  # Don't provide "transformer" for XML for now. Keep "orig_attr"
                     else:  # JSON
-                        keys, orig_attr = key_transformer(
-                            attr, attr_desc.copy(), orig_attr
-                        )
+                        keys, orig_attr = key_transformer(attr, attr_desc.copy(), orig_attr)
                         keys = keys if isinstance(keys, list) else [keys]
 
                     kwargs["serialization_ctxt"] = attr_desc
-                    new_attr = self.serialize_data(
-                        orig_attr, attr_desc["type"], **kwargs
-                    )
+                    new_attr = self.serialize_data(orig_attr, attr_desc["type"], **kwargs)
 
                     if is_xml_model_serialization:
                         xml_desc = attr_desc.get("xml", {})
@@ -685,9 +638,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
                         raise
 
         except (AttributeError, KeyError, TypeError) as err:
-            msg = "Attribute {} in object {} cannot be serialized.\n{}".format(
-                attr_name, class_name, str(target_obj)
-            )
+            msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj))
             raise SerializationError(msg) from err
         return serialized
 
@@ -709,9 +660,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
             is_xml_model_serialization = kwargs["is_xml"]
         except KeyError:
             if internal_data_type and issubclass(internal_data_type, Model):
-                is_xml_model_serialization = kwargs.setdefault(
-                    "is_xml", internal_data_type.is_xml_model()
-                )
+                is_xml_model_serialization = kwargs.setdefault("is_xml", internal_data_type.is_xml_model())
             else:
                 is_xml_model_serialization = False
         if internal_data_type and not isinstance(internal_data_type, Enum):
@@ -730,13 +679,9 @@ class Serializer:  # pylint: disable=too-many-public-methods
                         attribute_key_case_insensitive_extractor,
                         last_rest_key_case_insensitive_extractor,
                     ]
-                data = deserializer._deserialize(
-                    data_type, data
-                )  # pylint: disable=protected-access
+                data = deserializer._deserialize(data_type, data)  # pylint: disable=protected-access
             except DeserializationError as err:
-                raise SerializationError(
-                    "Unable to build a model: " + str(err)
-                ) from err
+                raise SerializationError("Unable to build a model: " + str(err)) from err
 
         return self._serialize(data, data_type, **kwargs)
 
@@ -781,9 +726,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
             if data_type.startswith("["):
                 internal_data_type = data_type[1:-1]
                 do_quote = not kwargs.get("skip_quote", False)
-                return self.serialize_iter(
-                    data, internal_data_type, do_quote=do_quote, **kwargs
-                )
+                return self.serialize_iter(data, internal_data_type, do_quote=do_quote, **kwargs)
 
             # Not a list, regular serialization
             output = self.serialize_data(data, data_type, **kwargs)
@@ -858,9 +801,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
         return self._serialize(data, **kwargs)
 
     @classmethod
-    def _get_custom_serializers(
-        cls, data_type, **kwargs
-    ):  # pylint: disable=inconsistent-return-statements
+    def _get_custom_serializers(cls, data_type, **kwargs):  # pylint: disable=inconsistent-return-statements
         custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type)
         if custom_serializer:
             return custom_serializer
@@ -943,9 +884,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
                 serialized.append(None)
 
         if kwargs.get("do_quote", False):
-            serialized = [
-                "" if s is None else quote(str(s), safe="") for s in serialized
-            ]
+            serialized = ["" if s is None else quote(str(s), safe="") for s in serialized]
 
         if div:
             serialized = ["" if s is None else str(s) for s in serialized]
@@ -962,9 +901,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
             is_wrapped = xml_desc.get("wrapped", False)
             node_name = xml_desc.get("itemsName", xml_name)
             if is_wrapped:
-                final_result = _create_xml_node(
-                    xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None)
-                )
+                final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None))
             else:
                 final_result = []
             # All list elements to "local_node"
@@ -972,11 +909,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
                 if isinstance(el, ET.Element):
                     el_node = el
                 else:
-                    el_node = _create_xml_node(
-                        node_name,
-                        xml_desc.get("prefix", None),
-                        xml_desc.get("ns", None),
-                    )
+                    el_node = _create_xml_node(node_name, xml_desc.get("prefix", None), xml_desc.get("ns", None))
                     if el is not None:  # Otherwise it writes "None" :-p
                         el_node.text = str(el)
                 final_result.append(el_node)
@@ -995,9 +928,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
         serialized = {}
         for key, value in attr.items():
             try:
-                serialized[self.serialize_unicode(key)] = self.serialize_data(
-                    value, dict_type, **kwargs
-                )
+                serialized[self.serialize_unicode(key)] = self.serialize_data(value, dict_type, **kwargs)
             except ValueError as err:
                 if isinstance(err, SerializationError):
                     raise
@@ -1008,18 +939,14 @@ class Serializer:  # pylint: disable=too-many-public-methods
             xml_desc = serialization_ctxt["xml"]
             xml_name = xml_desc["name"]
 
-            final_result = _create_xml_node(
-                xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None)
-            )
+            final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None))
             for key, value in serialized.items():
                 ET.SubElement(final_result, key).text = value
             return final_result
 
         return serialized
 
-    def serialize_object(
-        self, attr, **kwargs
-    ):  # pylint: disable=too-many-return-statements
+    def serialize_object(self, attr, **kwargs):  # pylint: disable=too-many-return-statements
         """Serialize a generic object.
         This will be handled as a dictionary. If object passed in is not
         a basic type (str, int, float, dict, list) it will simply be
@@ -1059,9 +986,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
             serialized = {}
             for key, value in attr.items():
                 try:
-                    serialized[self.serialize_unicode(key)] = self.serialize_object(
-                        value, **kwargs
-                    )
+                    serialized[self.serialize_unicode(key)] = self.serialize_object(value, **kwargs)
                 except ValueError:
                     serialized[self.serialize_unicode(key)] = None
             return serialized
@@ -1221,12 +1146,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
             if microseconds:
                 microseconds = "." + microseconds
             date = "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}".format(
-                utc.tm_year,
-                utc.tm_mon,
-                utc.tm_mday,
-                utc.tm_hour,
-                utc.tm_min,
-                utc.tm_sec,
+                utc.tm_year, utc.tm_mon, utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec
             )
             return date + microseconds + "Z"
         except (ValueError, OverflowError) as err:
@@ -1289,9 +1209,7 @@ def rest_key_case_insensitive_extractor(  # pylint: disable=unused-argument, inc
             key = _decode_attribute_map_key(dict_keys[0])
             break
         working_key = _decode_attribute_map_key(dict_keys[0])
-        working_data = attribute_key_case_insensitive_extractor(
-            working_key, None, working_data
-        )
+        working_data = attribute_key_case_insensitive_extractor(working_key, None, working_data)
         if working_data is None:
             # If at any point while following flatten JSON path see None, it means
             # that all properties under are None as well
@@ -1316,9 +1234,7 @@ def last_rest_key_extractor(attr, attr_desc, data):  # pylint: disable=unused-ar
     return attribute_key_extractor(dict_keys[-1], None, data)
 
 
-def last_rest_key_case_insensitive_extractor(
-    attr, attr_desc, data
-):  # pylint: disable=unused-argument
+def last_rest_key_case_insensitive_extractor(attr, attr_desc, data):  # pylint: disable=unused-argument
     """Extract the attribute in "data" based on the last part of the JSON path key.
 
     This is the case insensitive version of "last_rest_key_extractor"
@@ -1363,9 +1279,7 @@ def _extract_name_from_internal_type(internal_type):
     return xml_name
 
 
-def xml_key_extractor(
-    attr, attr_desc, data
-):  # pylint: disable=unused-argument,too-many-return-statements
+def xml_key_extractor(attr, attr_desc, data):  # pylint: disable=unused-argument,too-many-return-statements
     if isinstance(data, dict):
         return None
 
@@ -1399,10 +1313,7 @@ def xml_key_extractor(
     # - Wrapped node
     # - Internal type is an enum (considered basic types)
     # - Internal type has no XML/Name node
-    if is_wrapped or (
-        internal_type
-        and (issubclass(internal_type, Enum) or "name" not in internal_type_xml_map)
-    ):
+    if is_wrapped or (internal_type and (issubclass(internal_type, Enum) or "name" not in internal_type_xml_map)):
         children = data.findall(xml_name)
     # If internal type has a local name and it's not a list, I use that name
     elif not is_iter_type and internal_type and "name" in internal_type_xml_map:
@@ -1410,9 +1321,7 @@ def xml_key_extractor(
         children = data.findall(xml_name)
     # That's an array
     else:
-        if (
-            internal_type
-        ):  # Complex type, ignore itemsName and use the complex type name
+        if internal_type:  # Complex type, ignore itemsName and use the complex type name
             items_name = _extract_name_from_internal_type(internal_type)
         else:
             items_name = xml_desc.get("itemsName", xml_name)
@@ -1440,9 +1349,7 @@ def xml_key_extractor(
 
     # Here it's not a itertype, we should have found one element only or empty
     if len(children) > 1:
-        raise DeserializationError(
-            "Find several XML '{}' where it was not expected".format(xml_name)
-        )
+        raise DeserializationError("Find several XML '{}' where it was not expected".format(xml_name))
     return children[0]
 
 
@@ -1455,9 +1362,7 @@ class Deserializer:
 
     basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
 
-    valid_date = re.compile(
-        r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?"
-    )
+    valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
 
     def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
         self.deserialize_type = {
@@ -1502,9 +1407,7 @@ class Deserializer:
         data = self._unpack_content(response_data, content_type)
         return self._deserialize(target_obj, data)
 
-    def _deserialize(
-        self, target_obj, data
-    ):  # pylint: disable=inconsistent-return-statements
+    def _deserialize(self, target_obj, data):  # pylint: disable=inconsistent-return-statements
         """Call the deserializer on a model.
 
         Data needs to be already deserialized as JSON or XML ElementTree
@@ -1517,16 +1420,9 @@ class Deserializer:
         """
         # This is already a model, go recursive just in case
         if hasattr(data, "_attribute_map"):
-            constants = [
-                name
-                for name, config in getattr(data, "_validation", {}).items()
-                if config.get("constant")
-            ]
+            constants = [name for name, config in getattr(data, "_validation", {}).items() if config.get("constant")]
             try:
-                for (
-                    attr,
-                    mapconfig,
-                ) in data._attribute_map.items():  # pylint: disable=protected-access
+                for attr, mapconfig in data._attribute_map.items():  # pylint: disable=protected-access
                     if attr in constants:
                         continue
                     value = getattr(data, attr)
@@ -1534,9 +1430,7 @@ class Deserializer:
                         continue
                     local_type = mapconfig["type"]
                     internal_data_type = local_type.strip("[]{}")
-                    if internal_data_type not in self.dependencies or isinstance(
-                        internal_data_type, Enum
-                    ):
+                    if internal_data_type not in self.dependencies or isinstance(internal_data_type, Enum):
                         continue
                     setattr(data, attr, self._deserialize(local_type, value))
                 return data
@@ -1589,10 +1483,7 @@ class Deserializer:
     def _build_additional_properties(self, attribute_map, data):
         if not self.additional_properties_detection:
             return None
-        if (
-            "additional_properties" in attribute_map
-            and attribute_map.get("additional_properties", {}).get("key") != ""
-        ):
+        if "additional_properties" in attribute_map and attribute_map.get("additional_properties", {}).get("key") != "":
             # Check empty string. If it's not empty, someone has a real "additionalProperties"
             return None
         if isinstance(data, ET.Element):
@@ -1649,8 +1540,7 @@ class Deserializer:
             return self(target_obj, data, content_type=content_type)
         except:  # pylint: disable=bare-except
             _LOGGER.debug(
-                "Ran into a deserialization error. Ignoring since this is failsafe deserialization",
-                exc_info=True,
+                "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True
             )
             return None
 
@@ -1678,21 +1568,15 @@ class Deserializer:
         if context:
             if RawDeserializer.CONTEXT_NAME in context:
                 return context[RawDeserializer.CONTEXT_NAME]
-            raise ValueError(
-                "This pipeline didn't have the RawDeserializer policy; can't deserialize"
-            )
+            raise ValueError("This pipeline didn't have the RawDeserializer policy; can't deserialize")
 
         # Assume this is enough to recognize universal_http.ClientResponse without importing it
         if hasattr(raw_data, "body"):
-            return RawDeserializer.deserialize_from_http_generics(
-                raw_data.text(), raw_data.headers
-            )
+            return RawDeserializer.deserialize_from_http_generics(raw_data.text(), raw_data.headers)
 
         # Assume this enough to recognize requests.Response without importing it.
         if hasattr(raw_data, "_content_consumed"):
-            return RawDeserializer.deserialize_from_http_generics(
-                raw_data.text, raw_data.headers
-            )
+            return RawDeserializer.deserialize_from_http_generics(raw_data.text, raw_data.headers)
 
         if isinstance(raw_data, (str, bytes)) or hasattr(raw_data, "read"):
             return RawDeserializer.deserialize_from_text(raw_data, content_type)  # type: ignore
@@ -1720,11 +1604,7 @@ class Deserializer:
                     for k, v in response._validation.items()  # pylint: disable=protected-access  # type: ignore
                     if v.get("constant")
                 ]
-                kwargs = {
-                    k: v
-                    for k, v in attrs.items()
-                    if k not in subtype and k not in readonly + const
-                }
+                kwargs = {k: v for k, v in attrs.items() if k not in subtype and k not in readonly + const}
                 response_obj = response(**kwargs)
                 for attr in readonly:
                     setattr(response_obj, attr, attrs.get(attr))
@@ -1744,9 +1624,7 @@ class Deserializer:
                 msg += "Type: {}, Error: {}".format(type(response), exp)
                 raise DeserializationError(msg) from exp
 
-    def deserialize_data(
-        self, data, data_type
-    ):  # pylint: disable=too-many-return-statements
+    def deserialize_data(self, data, data_type):  # pylint: disable=too-many-return-statements
         """Process data for deserialization according to data type.
 
         :param str data: The response string to be deserialized.
@@ -1764,24 +1642,15 @@ class Deserializer:
             if data_type in self.basic_types.values():
                 return self.deserialize_basic(data, data_type)
             if data_type in self.deserialize_type:
-                if isinstance(
-                    data, self.deserialize_expected_types.get(data_type, tuple())
-                ):
+                if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())):
                     return data
 
-                is_a_text_parsing_type = (
-                    lambda x: x
-                    not in [  # pylint: disable=unnecessary-lambda-assignment
-                        "object",
-                        "[]",
-                        r"{}",
-                    ]
-                )
-                if (
-                    isinstance(data, ET.Element)
-                    and is_a_text_parsing_type(data_type)
-                    and not data.text
-                ):
+                is_a_text_parsing_type = lambda x: x not in [  # pylint: disable=unnecessary-lambda-assignment
+                    "object",
+                    "[]",
+                    r"{}",
+                ]
+                if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text:
                     return None
                 data_val = self.deserialize_type[data_type](data)
                 return data_val
@@ -1812,16 +1681,10 @@ class Deserializer:
         """
         if attr is None:
             return None
-        if isinstance(
-            attr, ET.Element
-        ):  # If I receive an element here, get the children
+        if isinstance(attr, ET.Element):  # If I receive an element here, get the children
             attr = list(attr)
         if not isinstance(attr, (list, set)):
-            raise DeserializationError(
-                "Cannot deserialize as [{}] an object of type {}".format(
-                    iter_type, type(attr)
-                )
-            )
+            raise DeserializationError("Cannot deserialize as [{}] an object of type {}".format(iter_type, type(attr)))
         return [self.deserialize_data(a, iter_type) for a in attr]
 
     def deserialize_dict(self, attr, dict_type):
@@ -1834,18 +1697,14 @@ class Deserializer:
         :rtype: dict
         """
         if isinstance(attr, list):
-            return {
-                x["key"]: self.deserialize_data(x["value"], dict_type) for x in attr
-            }
+            return {x["key"]: self.deserialize_data(x["value"], dict_type) for x in attr}
 
         if isinstance(attr, ET.Element):
             # Transform <Key>value</Key> into {"Key": "value"}
             attr = {el.tag: el.text for el in attr}
         return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()}
 
-    def deserialize_object(
-        self, attr, **kwargs
-    ):  # pylint: disable=too-many-return-statements
+    def deserialize_object(self, attr, **kwargs):  # pylint: disable=too-many-return-statements
         """Deserialize a generic object.
         This will be handled as a dictionary.
 
@@ -1888,9 +1747,7 @@ class Deserializer:
         error = "Cannot deserialize generic object with type: "
         raise TypeError(error + str(obj_type))
 
-    def deserialize_basic(
-        self, attr, data_type
-    ):  # pylint: disable=too-many-return-statements
+    def deserialize_basic(self, attr, data_type):  # pylint: disable=too-many-return-statements
         """Deserialize basic builtin data type from string.
         Will attempt to convert to str, int, float and bool.
         This function will also accept '1', '0', 'true' and 'false' as
@@ -1981,11 +1838,7 @@ class Deserializer:
                 if enum_value.value.lower() == str(data).lower():
                     return enum_value
             # We don't fail anymore for unknown value, we deserialize as a string
-            _LOGGER.warning(
-                "Deserializer is not able to find %s as valid enum in %s",
-                data,
-                enum_obj,
-            )
+            _LOGGER.warning("Deserializer is not able to find %s as valid enum in %s", data, enum_obj)
             return Deserializer.deserialize_unicode(data)
 
     @staticmethod
@@ -2077,9 +1930,7 @@ class Deserializer:
         if isinstance(attr, ET.Element):
             attr = attr.text
         if re.search(r"[^\W\d_]", attr, re.I + re.U):  # type: ignore
-            raise DeserializationError(
-                "Date must have only digits and -. Received: %s" % attr
-            )
+            raise DeserializationError("Date must have only digits and -. Received: %s" % attr)
         # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.
         return isodate.parse_date(attr, defaultmonth=0, defaultday=0)
 
@@ -2095,9 +1946,7 @@ class Deserializer:
         if isinstance(attr, ET.Element):
             attr = attr.text
         if re.search(r"[^\W\d_]", attr, re.I + re.U):  # type: ignore
-            raise DeserializationError(
-                "Date must have only digits and -. Received: %s" % attr
-            )
+            raise DeserializationError("Date must have only digits and -. Received: %s" % attr)
         return isodate.parse_time(attr)
 
     @staticmethod
@@ -2114,10 +1963,7 @@ class Deserializer:
         try:
             parsed_date = email.utils.parsedate_tz(attr)  # type: ignore
             date_obj = datetime.datetime(
-                *parsed_date[:6],
-                tzinfo=datetime.timezone(
-                    datetime.timedelta(minutes=(parsed_date[9] or 0) / 60)
-                ),
+                *parsed_date[:6], tzinfo=datetime.timezone(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60))
             )
             if not date_obj.tzinfo:
                 date_obj = date_obj.astimezone(tz=TZ_UTC)