simplify loops with comprehension

Author: jaymccon

python/rpdk/python/resolver.py

@@ -38,6 +38,4 @@ def translate_type(resolved_type):
 def contains_model(resolved_type):
     if resolved_type.container in [ContainerType.LIST, ContainerType.SET]:
         return contains_model(resolved_type.type)
-    if resolved_type.container == ContainerType.MODEL:
-        return True
-    return False
+    return resolved_type.container == ContainerType.MODEL

src/cloudformation_cli_python_lib/interface.py

@@ -59,31 +59,21 @@ class HandlerErrorCode(str, _AutoName):
 
 class BaseResourceModel:
     def _serialize(self) -> Mapping[str, Any]:
-        ser = self.__dict__
-        del_keys = []
-        for k, v in ser.items():
-            if isinstance(v, list):
-                ser[k] = self._serialize_list(v)
-            elif isinstance(v, BaseResourceModel):
-                ser[k] = v._serialize()  # pylint: disable=protected-access
-            elif v is None:
-                del_keys.append(k)
-            else:
-                ser[k] = v
-        for k in del_keys:
-            del ser[k]
-        return ser
-
-    def _serialize_list(self, v: List[Any]) -> List[Any]:
-        ser: List[Any] = []
-        for i in v:
-            if isinstance(i, list):
-                ser.append(self._serialize_list(i))
-            elif isinstance(i, BaseResourceModel):
-                ser.append(i._serialize())  # pylint: disable=protected-access
-            else:
-                ser.append(i)
-        return ser
+        return {
+            k: self._serialize_item(v)
+            for k, v in self.__dict__.items()
+            if v is not None
+        }
+
+    def _serialize_item(self, v: Any) -> Any:
+        if isinstance(v, list):
+            return self._serialize_list(v)
+        if isinstance(v, BaseResourceModel):
+            return v._serialize()  # pylint: disable=protected-access
+        return v
+
+    def _serialize_list(self, src_list: List[Any]) -> List[Any]:
+        return [self._serialize_item(i) for i in src_list]
 
     @classmethod
     def _deserialize(

src/cloudformation_cli_python_lib/recast.py

@@ -33,23 +33,17 @@ def _recast_lists(cls: Any, k: str, v: List[Any], classes: Dict[str, Any]) -> Li
     # Leave as is if type is Any
     if cls == typing.Any:
         return v
-    casted_list: List[Any] = []
     if "__dataclass_fields__" not in dir(cls):
         pass
     elif k in cls.__dataclass_fields__:
         cls = _field_to_type(cls.__dataclass_fields__[k].type, k, classes)
-    for item in v:
-        casted_list.append(cast_sequence_item(cls, k, item, classes))
-    return casted_list
+    return [cast_sequence_item(cls, k, item, classes) for item in v]
 
 
 def _recast_sets(cls: Any, k: str, v: Set[Any], classes: Dict[str, Any]) -> Set[Any]:
-    casted_set: Set[Any] = set()
     if "__dataclass_fields__" in dir(cls):
         cls = _field_to_type(cls.__dataclass_fields__[k].type, k, classes)
-    for item in v:
-        casted_set.add(cast_sequence_item(cls, k, item, classes))
-    return casted_set
+    return {cast_sequence_item(cls, k, item, classes) for item in v}
 
 
 def cast_sequence_item(cls: Any, k: str, item: Any, classes: Dict[str, Any]) -> Any:

src/cloudformation_cli_python_lib/utils.py

@@ -139,13 +139,12 @@ def deserialize_list(
 ) -> Optional[List[Any]]:
     if not json_data:
         return None
-    output = []
-    for item in json_data:
-        if isinstance(item, list):
-            output.append(deserialize_list(item, inner_dataclass))
-        elif isinstance(item, dict):
-            # pylint: disable=protected-access
-            output.append(inner_dataclass._deserialize(item))
-        else:
-            raise InvalidRequest(f"cannot deserialize lists of {type(item)}")
-    return output
+    return [_deser_item(item, inner_dataclass) for item in json_data]
+
+
+def _deser_item(item: Any, inner_dataclass: Any) -> Any:
+    if isinstance(item, list):
+        return deserialize_list(item, inner_dataclass)
+    if isinstance(item, dict):
+        return inner_dataclass._deserialize(item)  # pylint: disable=protected-access
+    raise InvalidRequest(f"cannot deserialize lists of {type(item)}")