Correct code style

Author: passren

pydynamodb/connection.py

@@ -144,8 +144,8 @@ def __init__(
         self._converter = converter
         self._retry_config = retry_config if retry_config else RetryConfig()
         self.cursor_class = cursor_class
-        self.cursor_kwargs = cursor_kwargs if cursor_kwargs else dict()
-        self._cursor_pool = list()
+        self.cursor_kwargs = cursor_kwargs if cursor_kwargs else {}
+        self._cursor_pool = []
         self._autocommit = True
         self._in_transaction = False
 

pydynamodb/executor.py

@@ -40,7 +40,7 @@ def __init__(
         self._metadata: Metadata = Metadata()
         self._is_predef_metadata: bool = False
         self._rows: Deque[Tuple[Any]] = deque()
-        self._errors: List[Dict[str, str]] = list()
+        self._errors: List[Dict[str, str]] = []
         self._kwargs = kwargs
         self.pre_execute()
 
@@ -205,7 +205,7 @@ def process_rows(self, response: Dict[str, Any]) -> None:
         if rows is None:
             raise DataError("KeyError `Items`")
 
-        processed_rows = list()
+        processed_rows = []
         for row in rows:
             if self._is_predef_metadata:
                 row_ = self._process_predef_row_item(row)
@@ -217,14 +217,14 @@ def process_rows(self, response: Dict[str, Any]) -> None:
         self._next_token = response.get("NextToken", None)
 
     def _process_undef_row_item(self, row) -> Optional[Tuple]:
-        row_ = dict()
+        row_ = {}
         for col, val in row.items():
             type_ = next(iter(val.keys()))
             val_ = self._converter.deserialize(val)
             col_index = self._process_metadata(col, type_)
             row_[col_index] = val_
 
-        row__ = list()
+        row__ = []
         for i in range(len(self._metadata)):
             row__.append(None)
         for i, v in row_.items():
@@ -310,15 +310,15 @@ def __init__(
         )
 
     def _process_undef_row_item(self, row) -> Optional[Dict[str, Any]]:
-        row_ = dict()
+        row_ = {}
         for col, val in row.items():
             val_ = self._converter.deserialize(val)
             row_[col] = val_
 
         return row_
 
     def _process_predef_row_item(self, row) -> Optional[Dict[str, Any]]:
-        row_ = dict()
+        row_ = {}
         for col, val in row.items():
             col_info = self.metadata.get(col, None)
             if col_info:
@@ -370,8 +370,8 @@ def process_rows(self, response: Dict[str, Any]) -> None:
         if rows is None:
             raise DataError("KeyError `Responses` in BatchStatementResponse")
 
-        processed_error_rows = list()
-        processed_rows = list()
+        processed_error_rows = []
+        processed_rows = []
         for row in rows:
             error = row.get("Error", None)
             if error:

pydynamodb/model.py

@@ -187,7 +187,7 @@ def __init__(self, statements: List[Statement] = None) -> None:
                 self._validate(statement_)
             self._statments = statements
         else:
-            self._statments = list()
+            self._statments = []
 
         self._query_type = None
         self._query_category = None

pydynamodb/sql/ddl_alter.py

@@ -212,12 +212,12 @@ def transform(self) -> Dict[str, Any]:
         if self.root_parse_results is None:
             raise ValueError("Statement was not parsed yet")
 
-        request = dict()
+        request = {}
         attr_def_ = None
 
         for attr in self.root_parse_results["attributes"]:
             if attr_def_ is None:
-                attr_def_ = list()
+                attr_def_ = []
             attr_name = attr["attribute_name"]
             data_type = attr["data_type"]
             attr_def_.append(self._construct_attr_def(attr_name, data_type))
@@ -237,7 +237,7 @@ def transform(self) -> Dict[str, Any]:
 
                 if index_type == "GLOBAL":
                     if gsis_ is None:
-                        gsis_ = list()
+                        gsis_ = []
 
                     if alter_ops == "CREATE" or alter_ops == "UPDATE":
                         gsis_.append(
@@ -266,7 +266,7 @@ def transform(self) -> Dict[str, Any]:
         if replicas is not None:
             for replica in replicas:
                 if replicas_ is None:
-                    replicas_ = list()
+                    replicas_ = []
                 alter_ops = replica["alter_ops"]
 
                 if alter_ops == "CREATE" or alter_ops == "UPDATE":
@@ -311,7 +311,7 @@ def _get_alter_operation(self, ops: str) -> Optional[str]:
             raise LookupError("Alter operation is invalid")
 
     def _construct_replica(self, replica: ParseResults) -> Dict[str, Any]:
-        replicas_ = dict()
+        replicas_ = {}
 
         region_name = replica["region_name"]
         replicas_.update({"RegionName": region_name})
@@ -323,7 +323,7 @@ def _construct_replica(self, replica: ParseResults) -> Dict[str, Any]:
         if replica_options is not None:
             for replica_option in replica_options:
                 if replica_options_ is None:
-                    replica_options_ = list()
+                    replica_options_ = []
 
                 if replica_option.get_name() == "replica_gsi_option":
                     replica_gsi_option_ = replica_option
@@ -358,7 +358,7 @@ def _construct_replica_gsi(
 
                 if len(gsi) == 3:
                     if gsis_ is None:
-                        gsis_ = list()
+                        gsis_ = []
 
                     option_path_name = gsi[1]
                     option_value = gsi[2]

pydynamodb/sql/ddl_create.py

@@ -139,7 +139,7 @@ def transform(self) -> Dict[str, Any]:
         if self.root_parse_results is None:
             raise ValueError("Statement was not parsed yet")
 
-        request = dict()
+        request = {}
         is_global_table = (
             True if self.root_parse_results.get("global", None) is not None else False
         )
@@ -148,8 +148,8 @@ def transform(self) -> Dict[str, Any]:
         if is_global_table:
             request.update({"GlobalTableName": table_name_})
         else:
-            attr_def_ = list()
-            key_schema_ = list()
+            attr_def_ = []
+            key_schema_ = []
 
             for attr in self.root_parse_results["attributes"]:
                 attr_name = attr["attribute_name"]
@@ -173,11 +173,11 @@ def transform(self) -> Dict[str, Any]:
 
                     if index_type == "GLOBAL":
                         if gsis_ is None:
-                            gsis_ = list()
+                            gsis_ = []
                         gsis_.append(self._construct_index(index))
                     elif index_type == "LOCAL":
                         if lsis_ is None:
-                            lsis_ = list()
+                            lsis_ = []
                         lsis_.append(self._construct_index(index))
                     else:
                         raise LookupError("Index type is invalid")

pydynamodb/sql/ddl_drop.py

@@ -51,7 +51,7 @@ def transform(self) -> Dict[str, Any]:
         if self.root_parse_results is None:
             raise ValueError("Statement was not parsed yet")
 
-        request = dict()
+        request = {}
         is_global_table = (
             True if self.root_parse_results.get("global", None) is not None else False
         )

pydynamodb/sql/ddl_sql.py

@@ -174,13 +174,13 @@ def _construct_key_schema(self, attr_name: str, key_type: str) -> Dict[str, str]
         return {"AttributeName": attr_name, "KeyType": converted_key_type}
 
     def _construct_index(self, index: ParseResults) -> Dict[str, Any]:
-        index_ = dict()
+        index_ = {}
         index_name = index["index_name"]
         index_.update({"IndexName": index_name})
 
         attrs = index.get("attributes", None)
         if attrs:
-            key_schema = list()
+            key_schema = []
 
             for attr in attrs:
                 attr_name = attr["attribute_name"]
@@ -197,7 +197,7 @@ def _construct_options(self, options: List[Any]) -> Optional[Dict[str, Any]]:
         converted_ = None
         for option in options:
             if converted_ is None:
-                converted_ = dict()
+                converted_ = {}
             option_name_path = option[0]
             option_value = option[1]
 
@@ -231,7 +231,7 @@ def _parse_option_path(
         return_dict: Dict[str, Any] = None,
     ) -> Dict[str, Any]:
         if return_dict is None:
-            return_dict = dict()
+            return_dict = {}
 
         names = option_name_path.split(".")
         names_size = len(names)

pydynamodb/sql/util.py

@@ -6,7 +6,7 @@
 
 
 def flatten_list(lst: List[Any]) -> List[Any]:
-    items = list()
+    items = []
     for item in lst:
         if isinstance(item, list):
             if len(item) > 2 and item[0] == "[" and item[-1] == "]":

pydynamodb/sql/util_sql.py

@@ -66,7 +66,7 @@ def transform(self) -> Dict[str, Any]:
         if self.root_parse_results is None:
             raise ValueError("Statement was not parsed yet")
 
-        request = dict()
+        request = {}
         is_global_table = (
             True if self.root_parse_results.get("global", None) is not None else False
         )
@@ -120,7 +120,7 @@ def transform(self) -> Dict[str, Any]:
         if self.root_parse_results is None:
             raise ValueError("Statement was not parsed yet")
 
-        request = dict()
+        request = {}
         table_name = self.root_parse_results["table"]
         is_global_table = (
             True if self.root_parse_results.get("global", None) is not None else False

pydynamodb/sqlalchemy_dynamodb/pydynamodb.py

@@ -651,7 +651,7 @@ class DynamoDBDialect(DefaultDialect):
         types.JSON: DynamoDBJSON,
     }
 
-    _connect_options = dict()  # type: ignore
+    _connect_options = {}  # type: ignore
 
     def __init__(
         self,