Merge pull request #77 from passren/0.8.0

passren · web-flow · commit 6572a15ed94e · 2025-12-05T10:46:17.000-05:00
0.8.0 - several fixes
diff --git a/README.rst b/README.rst
@@ -62,6 +62,7 @@ Features
 * MySQL-Like statements for Utility operations (LIST/SHOW TABLES, DESC TABLE)
 * Auto data type conversion for parameters and result set (Including date and datetime)
 * Transaction and Batch operations
+* Dict Resultset provided to support json conversion
 * SQLAlchemy dialect provided
 * Compatible for Superset SQL Lab and graphing
 
diff --git a/pydynamodb/__init__.py b/pydynamodb/__init__.py
@@ -6,7 +6,7 @@
 if TYPE_CHECKING:
     from .connection import Connection
 
-__version__: str = "0.7.6"
+__version__: str = "0.8.0"
 
 # Globals https://www.python.org/dev/peps/pep-0249/#globals
 apilevel: str = "2.0"
diff --git a/pydynamodb/connection.py b/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
 
diff --git a/pydynamodb/executor.py b/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():
@@ -309,27 +309,33 @@ def __init__(
             **kwargs,
         )
 
-    def process_rows(self, response: Dict[str, Any]) -> None:
-        rows = response.get("Items", None)
-        if rows is None:
-            raise DataError("KeyError `Items`")
-
-        processed_rows = list()
-        for row in rows:
-            row_ = self._process_row_item(row)
-            processed_rows.append(row_)
-
-        self._rows.extend(processed_rows)
-        self._next_token = response.get("NextToken", None)
-
-    def _process_row_item(self, row) -> Optional[Dict[str, Any]]:
-        row_ = dict()
+    def _process_undef_row_item(self, row) -> Optional[Dict[str, Any]]:
+        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_ = {}
+        for col, val in row.items():
+            col_info = self.metadata.get(col, None)
+            if col_info:
+                if col_info.function:
+                    val_ = self._converter.deserialize(
+                        val,
+                        function=col_info.function.name,
+                        function_params=col_info.function.params,
+                    )
+                else:
+                    val_ = self._converter.deserialize(val)
+
+                col_name_ = col if col_info.alias is None else col_info.alias
+                row_[col_name_] = val_
+
+        return row_
+
 
 class DmlBatchExecutor(DmlStatementExecutor):
     def __init__(
@@ -364,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:
diff --git a/pydynamodb/model.py b/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
diff --git a/pydynamodb/sql/ddl_alter.py b/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]
diff --git a/pydynamodb/sql/ddl_create.py b/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")
diff --git a/pydynamodb/sql/ddl_drop.py b/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
         )
diff --git a/pydynamodb/sql/ddl_sql.py b/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)
diff --git a/pydynamodb/sql/util.py b/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] == "]":
diff --git a/pydynamodb/sql/util_sql.py b/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
diff --git a/pydynamodb/sqlalchemy_dynamodb/pydynamodb.py b/pydynamodb/sqlalchemy_dynamodb/pydynamodb.py
@@ -48,7 +48,7 @@ def process(value):
             if value is None:
                 return None
 
-            if isinstance(value, dict):
+            if isinstance(value, dict) or isinstance(value, list):
                 return value
 
             if isinstance(value, str) and _SQLALCHEMY_MAJOR_VERSION < 2:
@@ -651,7 +651,7 @@ class DynamoDBDialect(DefaultDialect):
         types.JSON: DynamoDBJSON,
     }
 
-    _connect_options = dict()  # type: ignore
+    _connect_options = {}  # type: ignore
 
     def __init__(
         self,
diff --git a/pydynamodb/superset_dynamodb/querydb.py b/pydynamodb/superset_dynamodb/querydb.py
@@ -204,7 +204,7 @@ def init_cache_table(self) -> None:
             return
 
         if not self.has_table(QueryDB.CACHE_TABLE):
-            columns = list()
+            columns = []
             columns.append(
                 "%s %s PRIMARY KEY" % ("query_id", self.type_conversion(str))
             )
@@ -343,7 +343,7 @@ def _get_query_table_col_name(self, col_info: DmlSelectColumn) -> str:
 
     @synchronized
     def create_query_table(self, metadata: Metadata) -> None:
-        columns_with_type = list()
+        columns_with_type = []
 
         for col_info in metadata:
             col_type = self._get_col_type(col_info)
@@ -367,8 +367,8 @@ def drop_query_table(self) -> None:
     def write_raw_data(
         self, metadata: Metadata, raw_data: Optional[List[Tuple[Any]]]
     ) -> None:
-        columns = list()
-        values = list()
+        columns = []
+        values = []
         for col_info in metadata:
             columns.append('"' + self._get_query_table_col_name(col_info) + '"')
             values.append("?")
diff --git a/pydynamodb/superset_dynamodb/querydb_sqlite.py b/pydynamodb/superset_dynamodb/querydb_sqlite.py
@@ -1,16 +1,29 @@
 # -*- coding: utf-8 -*-
 import logging
-import sqlean as sqlite3
 from datetime import datetime, date
 from contextlib import closing
 from typing import Any, Type
 
+# Try to import sqlean first, fall back to native sqlite3
+try:
+    import sqlean as sqlite3
+
+    _SQLEAN_INSTALLED = True
+except ImportError:
+    import sqlite3
+
+    _SQLEAN_INSTALLED = False
+
 from .querydb import QueryDB, QueryDBConfig
 from ..model import Statement
 
 _logger = logging.getLogger(__name__)  # type: ignore
 
 
+def has_sqlean() -> bool:
+    return _SQLEAN_INSTALLED
+
+
 class SqliteFileQueryDB(QueryDB):
     def __init__(
         self,
@@ -24,7 +37,10 @@ def __init__(
     @property
     def connection(self):
         if self._connection is None:
-            sqlite3.extensions.enable("math", "regexp", "stats", "text")
+            # Enable extensions only if sqlean is available
+            if _SQLEAN_INSTALLED:
+                sqlite3.extensions.enable("math", "regexp", "stats", "text")
+
             self._connection = sqlite3.connect(
                 self.config.db_url,
                 detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
diff --git a/pydynamodb/util.py b/pydynamodb/util.py
@@ -45,7 +45,7 @@ def strtobool(val):
 def flatten_dict(
     d: Dict[str, Any], parent_key: str = "", separator: str = "."
 ) -> Dict[str, Any]:
-    items = list()
+    items = []
     for key, val in d.items():
         new_key = parent_key + separator + key if parent_key else key
         if isinstance(val, MutableMapping):
diff --git a/requirements.txt b/requirements.txt
diff --git a/setup.py b/setup.py
diff --git a/tests/test_cursor_dml_dict_rs.py b/tests/test_cursor_dml_dict_rs.py
diff --git a/tests/test_sqlalchemy_dynamodb.py b/tests/test_sqlalchemy_dynamodb.py
diff --git a/tests/test_superset_dynamodb.py b/tests/test_superset_dynamodb.py

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ def transform(self) -> Dict[str, Any]:`
`51`	`51`	`if self.root_parse_results is None:`
`52`	`52`	`raise ValueError("Statement was not parsed yet")`
`53`	`53`
`54`		`- request = dict()`
	`54`	`+ request = {}`
`55`	`55`	`is_global_table = (`
`56`	`56`	`True if self.root_parse_results.get("global", None) is not None else False`
`57`	`57`	`)`