pyobvector 0.2.22__py3-none-any.whl → 0.2.24__py3-none-any.whl

pyobvector/client/partitions.py

@@ -1,4 +1,5 @@
 """A module to do compilation of OceanBase Parition Clause."""
+
 from typing import Optional, Union
 import logging
 from dataclasses import dataclass
@@ -11,6 +12,7 @@ logger.setLevel(logging.DEBUG)
 
 class PartType(IntEnum):
     """Partition type of table or collection for both ObVecClient and MilvusLikeClient"""
+
     Range = 0
     Hash = 1
     Key = 2
@@ -21,12 +23,13 @@ class PartType(IntEnum):
 
 class ObPartition:
     """Base class of all kind of Partition strategy
-    
+
     Attributes:
     part_type (PartType) : type of partition strategy
     sub_partition (ObPartition) : subpartition strategy
     is_sub (bool) : this partition strategy is a subpartition or not
     """
+
     def __init__(self, part_type: PartType):
         self.part_type = part_type
         self.sub_partition = None
@@ -38,7 +41,7 @@ class ObPartition:
 
     def add_subpartition(self, sub_part):
         """Add subpartition strategy to current partition.
-        
+
         Args:
             sub_part (ObPartition) : subpartition strategy
         """
@@ -60,14 +63,15 @@ class ObPartition:
 @dataclass
 class RangeListPartInfo:
     """Range/RangeColumns/List/ListColumns partition info for each partition.
-    
+
     Attributes:
     part_name (string) : partition name
-    part_upper_bound_expr (Union[List, str, int]) : 
-        For example, using `[1,2]`/`'DEFAULT'` as default case/`7` when create 
+    part_upper_bound_expr (Union[List, str, int]) :
+        For example, using `[1,2]`/`'DEFAULT'` as default case/`7` when create
         List/ListColumns partition.
         Using 100 / `MAXVALUE` when create Range/RangeColumns partition.
     """
+
     part_name: str
     part_upper_bound_expr: Union[list, str, int]
 
@@ -84,6 +88,7 @@ class RangeListPartInfo:
 
 class ObRangePartition(ObPartition):
     """Range/RangeColumns partition strategy."""
+
     def __init__(
         self,
         is_range_columns: bool,
@@ -117,18 +122,24 @@ class ObRangePartition(ObPartition):
             assert self.range_expr is not None
             if self.sub_partition is None:
                 return f"RANGE ({self.range_expr}) ({self._parse_range_part_list()})"
-            return f"RANGE ({self.range_expr}) {self.sub_partition.do_compile()} " \
-                    f"({self._parse_range_part_list()})"
+            return (
+                f"RANGE ({self.range_expr}) {self.sub_partition.do_compile()} "
+                f"({self._parse_range_part_list()})"
+            )
         assert self.col_name_list is not None
         if self.sub_partition is None:
-            return f"RANGE COLUMNS ({','.join(self.col_name_list)}) " \
-                    f"({self._parse_range_part_list()})"
-        return f"RANGE COLUMNS ({','.join(self.col_name_list)}) " \
-                f"{self.sub_partition.do_compile()} ({self._parse_range_part_list()})"
+            return (
+                f"RANGE COLUMNS ({','.join(self.col_name_list)}) "
+                f"({self._parse_range_part_list()})"
+            )
+        return (
+            f"RANGE COLUMNS ({','.join(self.col_name_list)}) "
+            f"{self.sub_partition.do_compile()} ({self._parse_range_part_list()})"
+        )
 
     def _parse_range_part_list(self) -> str:
         range_partitions_complied = [
-            f"PARTITION {range_part_info.part_name} VALUES LESS THAN " \
+            f"PARTITION {range_part_info.part_name} VALUES LESS THAN "
             f"({range_part_info.get_part_expr_str()})"
             for range_part_info in self.range_part_infos
         ]
@@ -137,6 +148,7 @@ class ObRangePartition(ObPartition):
 
 class ObSubRangePartition(ObRangePartition):
     """Range/RangeColumns subpartition strategy."""
+
     def __init__(
         self,
         is_range_columns: bool,
@@ -155,16 +167,20 @@ class ObSubRangePartition(ObRangePartition):
         if self.part_type == PartType.Range:
             assert self.range_expr is not None
             assert self.sub_partition is None
-            return f"RANGE ({self.range_expr}) SUBPARTITION TEMPLATE " \
-                   f"({self._parse_range_part_list()})"
+            return (
+                f"RANGE ({self.range_expr}) SUBPARTITION TEMPLATE "
+                f"({self._parse_range_part_list()})"
+            )
         assert self.col_name_list is not None
         assert self.sub_partition is None
-        return f"RANGE COLUMNS ({','.join(self.col_name_list)}) SUBPARTITION TEMPLATE " \
-                f"({self._parse_range_part_list()})"
+        return (
+            f"RANGE COLUMNS ({','.join(self.col_name_list)}) SUBPARTITION TEMPLATE "
+            f"({self._parse_range_part_list()})"
+        )
 
     def _parse_range_part_list(self) -> str:
         range_partitions_complied = [
-            f"SUBPARTITION {range_part_info.part_name} VALUES LESS THAN " \
+            f"SUBPARTITION {range_part_info.part_name} VALUES LESS THAN "
             f"({range_part_info.get_part_expr_str()})"
             for range_part_info in self.range_part_infos
         ]
@@ -173,6 +189,7 @@ class ObSubRangePartition(ObRangePartition):
 
 class ObListPartition(ObPartition):
     """List/ListColumns partition strategy."""
+
     def __init__(
         self,
         is_list_columns: bool,
@@ -206,14 +223,20 @@ class ObListPartition(ObPartition):
             assert self.list_expr is not None
             if self.sub_partition is None:
                 return f"LIST ({self.list_expr}) ({self._parse_list_part_list()})"
-            return f"LIST ({self.list_expr}) {self.sub_partition.do_compile()} " \
-                    f"({self._parse_list_part_list()})"
+            return (
+                f"LIST ({self.list_expr}) {self.sub_partition.do_compile()} "
+                f"({self._parse_list_part_list()})"
+            )
         assert self.col_name_list is not None
         if self.sub_partition is None:
-            return f"LIST COLUMNS ({','.join(self.col_name_list)}) " \
-                    f"({self._parse_list_part_list()})"
-        return f"LIST COLUMNS ({','.join(self.col_name_list)}) " \
-                f"{self.sub_partition.do_compile()} ({self._parse_list_part_list()})"
+            return (
+                f"LIST COLUMNS ({','.join(self.col_name_list)}) "
+                f"({self._parse_list_part_list()})"
+            )
+        return (
+            f"LIST COLUMNS ({','.join(self.col_name_list)}) "
+            f"{self.sub_partition.do_compile()} ({self._parse_list_part_list()})"
+        )
 
     def _parse_list_part_list(self) -> str:
         list_partitions_complied = [
@@ -225,6 +248,7 @@ class ObListPartition(ObPartition):
 
 class ObSubListPartition(ObListPartition):
     """List/ListColumns subpartition strategy."""
+
     def __init__(
         self,
         is_list_columns: bool,
@@ -246,12 +270,14 @@ class ObSubListPartition(ObListPartition):
             return f"LIST ({self.list_expr}) SUBPARTITION TEMPLATE ({self._parse_list_part_list()})"
         assert self.col_name_list is not None
         assert self.sub_partition is None
-        return f"LIST COLUMNS ({','.join(self.col_name_list)}) SUBPARTITION TEMPLATE " \
-                f"({self._parse_list_part_list()})"
+        return (
+            f"LIST COLUMNS ({','.join(self.col_name_list)}) SUBPARTITION TEMPLATE "
+            f"({self._parse_list_part_list()})"
+        )
 
     def _parse_list_part_list(self) -> str:
         list_partitions_complied = [
-            f"SUBPARTITION {list_part_info.part_name} VALUES IN " \
+            f"SUBPARTITION {list_part_info.part_name} VALUES IN "
             f"({list_part_info.get_part_expr_str()})"
             for list_part_info in self.list_part_infos
         ]
@@ -260,6 +286,7 @@ class ObSubListPartition(ObListPartition):
 
 class ObHashPartition(ObPartition):
     """Hash partition strategy."""
+
     def __init__(
         self,
         hash_expr: str,
@@ -279,7 +306,7 @@ class ObHashPartition(ObPartition):
 
         if self.part_count is not None and self.hash_part_name_list is not None:
             logging.warning(
-                "part_count & hash_part_name_list are both set, " \
+                "part_count & hash_part_name_list are both set, "
                 "hash_part_name_list will be override by part_count"
             )
 
@@ -291,13 +318,17 @@ class ObHashPartition(ObPartition):
         if self.part_count is not None:
             if self.sub_partition is None:
                 return f"HASH ({self.hash_expr}) PARTITIONS {self.part_count}"
-            return f"HASH ({self.hash_expr}) {self.sub_partition.do_compile()} " \
-                    f"PARTITIONS {self.part_count}"
+            return (
+                f"HASH ({self.hash_expr}) {self.sub_partition.do_compile()} "
+                f"PARTITIONS {self.part_count}"
+            )
         assert self.hash_part_name_list is not None
         if self.sub_partition is None:
             return f"HASH ({self.hash_expr}) ({self._parse_hash_part_list()})"
-        return f"HASH ({self.hash_expr}) {self.sub_partition.do_compile()} " \
-                f"({self._parse_hash_part_list()})"
+        return (
+            f"HASH ({self.hash_expr}) {self.sub_partition.do_compile()} "
+            f"({self._parse_hash_part_list()})"
+        )
 
     def _parse_hash_part_list(self):
         return ",".join([f"PARTITION {name}" for name in self.hash_part_name_list])
@@ -305,6 +336,7 @@ class ObHashPartition(ObPartition):
 
 class ObSubHashPartition(ObHashPartition):
     """Hash subpartition strategy."""
+
     def __init__(
         self,
         hash_expr: str,
@@ -332,6 +364,7 @@ class ObSubHashPartition(ObHashPartition):
 
 class ObKeyPartition(ObPartition):
     """Key partition strategy."""
+
     def __init__(
         self,
         col_name_list: list[str],
@@ -351,7 +384,7 @@ class ObKeyPartition(ObPartition):
 
         if self.part_count is not None and self.key_part_name_list is not None:
             logging.warning(
-                "part_count & key_part_name_list are both set, " \
+                "part_count & key_part_name_list are both set, "
                 "key_part_name_list will be override by part_count"
             )
 
@@ -365,13 +398,19 @@ class ObKeyPartition(ObPartition):
                 return (
                     f"KEY ({','.join(self.col_name_list)}) PARTITIONS {self.part_count}"
                 )
-            return f"KEY ({','.join(self.col_name_list)}) {self.sub_partition.do_compile()} " \
-                    f"PARTITIONS {self.part_count}"
+            return (
+                f"KEY ({','.join(self.col_name_list)}) {self.sub_partition.do_compile()} "
+                f"PARTITIONS {self.part_count}"
+            )
         assert self.key_part_name_list is not None
         if self.sub_partition is None:
-            return f"KEY ({','.join(self.col_name_list)}) ({self._parse_key_part_list()})"
-        return f"KEY ({','.join(self.col_name_list)}) {self.sub_partition.do_compile()} " \
-                f"({self._parse_key_part_list()})"
+            return (
+                f"KEY ({','.join(self.col_name_list)}) ({self._parse_key_part_list()})"
+            )
+        return (
+            f"KEY ({','.join(self.col_name_list)}) {self.sub_partition.do_compile()} "
+            f"({self._parse_key_part_list()})"
+        )
 
     def _parse_key_part_list(self):
         return ",".join([f"PARTITION {name}" for name in self.key_part_name_list])
@@ -379,6 +418,7 @@ class ObKeyPartition(ObPartition):
 
 class ObSubKeyPartition(ObKeyPartition):
     """Key subpartition strategy."""
+
     def __init__(
         self,
         col_name_list: list[str],
@@ -400,8 +440,10 @@ class ObSubKeyPartition(ObKeyPartition):
             )
         assert self.key_part_name_list is not None
         assert self.sub_partition is None
-        return f"KEY ({','.join(self.col_name_list)}) SUBPARTITION TEMPLATE " \
-                f"({self._parse_key_part_list()})"
+        return (
+            f"KEY ({','.join(self.col_name_list)}) SUBPARTITION TEMPLATE "
+            f"({self._parse_key_part_list()})"
+        )
 
     def _parse_key_part_list(self):
         return ",".join([f"SUBPARTITION {name}" for name in self.key_part_name_list])

pyobvector/client/schema_type.py

@@ -1,4 +1,5 @@
 """Data type module that compatible with Milvus."""
+
 from sqlalchemy import (
     Boolean,
     SmallInteger,
@@ -16,6 +17,7 @@ from ..schema import ARRAY, SPARSE_VECTOR, VECTOR
 
 class DataType(IntEnum):
     """Data type definition that compatible with Milvus."""
+
     # NONE = 0
     BOOL = 1
     INT8 = 2
@@ -40,7 +42,7 @@ class DataType(IntEnum):
 
 def convert_datatype_to_sqltype(datatype: DataType):
     """Convert Milvus data type to SQL type.
-    
+
     Args:
         datatype (DataType) : Milvus data type.
     """

pyobvector/json_table/__init__.py

@@ -12,7 +12,8 @@ from .virtual_data_type import (
 from .json_value_returning_func import json_value
 
 __all__ = [
-    "OceanBase", "ChangeColumn",
+    "OceanBase",
+    "ChangeColumn",
     "JType",
     "JsonTableDataType",
     "JsonTableBool",
@@ -21,5 +22,5 @@ __all__ = [
     "JsonTableDecimalFactory",
     "JsonTableInt",
     "val2json",
-    "json_value"
-]
+    "json_value",
+]

pyobvector/json_table/json_value_returning_func.py

@@ -7,6 +7,7 @@ from sqlalchemy import Text
 
 logger = logging.getLogger(__name__)
 
+
 class json_value(FunctionElement):
     type = Text()
     inherit_cache = True
@@ -15,6 +16,7 @@ class json_value(FunctionElement):
         super().__init__()
         self.args = args
 
+
 @compiles(json_value)
 def compile_json_value(element, compiler, **kwargs):
     args = []
@@ -23,25 +25,25 @@ def compile_json_value(element, compiler, **kwargs):
     args.append(compiler.process(element.args[0]))
     if not (isinstance(element.args[1], str) and isinstance(element.args[2], str)):
         raise ValueError("Invalid args for json_value")
-    
-    if element.args[2].startswith('TINYINT'):
+
+    if element.args[2].startswith("TINYINT"):
         returning_type = "SIGNED"
-    elif element.args[2].startswith('TIMESTAMP'):
+    elif element.args[2].startswith("TIMESTAMP"):
         returning_type = "DATETIME"
-    elif element.args[2].startswith('INT'):
+    elif element.args[2].startswith("INT"):
         returning_type = "SIGNED"
-    elif element.args[2].startswith('VARCHAR'):
-        if element.args[2] == 'VARCHAR':
+    elif element.args[2].startswith("VARCHAR"):
+        if element.args[2] == "VARCHAR":
             returning_type = "CHAR(255)"
         else:
-            varchar_pattern = r'VARCHAR\((\d+)\)'
+            varchar_pattern = r"VARCHAR\((\d+)\)"
             varchar_matches = re.findall(varchar_pattern, element.args[2])
             returning_type = f"CHAR({int(varchar_matches[0])})"
-    elif element.args[2].startswith('DECIMAL'):
-        if element.args[2] == 'DECIMAL':
+    elif element.args[2].startswith("DECIMAL"):
+        if element.args[2] == "DECIMAL":
             returning_type = "DECIMAL(10, 0)"
         else:
-            decimal_pattern = r'DECIMAL\((\d+),\s*(\d+)\)'
+            decimal_pattern = r"DECIMAL\((\d+),\s*(\d+)\)"
             decimal_matches = re.findall(decimal_pattern, element.args[2])
             x, y = decimal_matches[0]
             returning_type = f"DECIMAL({x}, {y})"

pyobvector/json_table/oceanbase_dialect.py

@@ -3,6 +3,7 @@ from sqlglot import parser, exp, Expression
 from sqlglot.dialects.mysql import MySQL
 from sqlglot.tokens import TokenType
 
+
 class ChangeColumn(Expression):
     arg_types = {
         "this": True,
@@ -14,12 +15,13 @@ class ChangeColumn(Expression):
     def origin_col_name(self) -> str:
         origin_col_name = self.args.get("origin_col_name")
         return origin_col_name
-    
+
     @property
     def dtype(self) -> Expression:
         dtype = self.args.get("dtype")
         return dtype
 
+
 class OceanBase(MySQL):
     class Parser(MySQL.Parser):
         ALTER_PARSERS = {
@@ -27,7 +29,7 @@ class OceanBase(MySQL):
             "MODIFY": lambda self: self._parse_alter_table_alter(),
             "CHANGE": lambda self: self._parse_change_table_column(),
         }
-        
+
         def _parse_alter_table_alter(self) -> t.Optional[exp.Expression]:
             if self._match_texts(self.ALTER_ALTER_PARSERS):
                 return self.ALTER_ALTER_PARSERS[self._prev.text.upper()](self)
@@ -38,9 +40,13 @@ class OceanBase(MySQL):
             if self._match_pair(TokenType.DROP, TokenType.DEFAULT):
                 return self.expression(exp.AlterColumn, this=column, drop=True)
             if self._match_pair(TokenType.SET, TokenType.DEFAULT):
-                return self.expression(exp.AlterColumn, this=column, default=self._parse_assignment())
+                return self.expression(
+                    exp.AlterColumn, this=column, default=self._parse_assignment()
+                )
             if self._match(TokenType.COMMENT):
-                return self.expression(exp.AlterColumn, this=column, comment=self._parse_string())
+                return self.expression(
+                    exp.AlterColumn, this=column, comment=self._parse_string()
+                )
             if self._match_text_seq("DROP", "NOT", "NULL"):
                 return self.expression(
                     exp.AlterColumn,
@@ -63,7 +69,7 @@ class OceanBase(MySQL):
                 collate=self._match(TokenType.COLLATE) and self._parse_term(),
                 using=self._match(TokenType.USING) and self._parse_assignment(),
             )
-        
+
         def _parse_drop(self, exists: bool = False) -> t.Union[exp.Drop, exp.Command]:
             temporary = self._match(TokenType.TEMPORARY)
             materialized = self._match_text_seq("MATERIALIZED")
@@ -79,7 +85,8 @@ class OceanBase(MySQL):
                 this = self._parse_column()
             else:
                 this = self._parse_table_parts(
-                    schema=True, is_db_reference=self._prev.token_type == TokenType.SCHEMA
+                    schema=True,
+                    is_db_reference=self._prev.token_type == TokenType.SCHEMA,
                 )
 
             cluster = self._parse_on_property() if self._match(TokenType.ON) else None
@@ -103,7 +110,7 @@ class OceanBase(MySQL):
                 cluster=cluster,
                 concurrently=concurrently,
             )
-        
+
         def _parse_change_table_column(self) -> t.Optional[exp.Expression]:
             self._match(TokenType.COLUMN)
             origin_col = self._parse_field(any_token=True)
@@ -113,4 +120,4 @@ class OceanBase(MySQL):
                 this=column,
                 origin_col_name=origin_col,
                 dtype=self._parse_types(),
-            )
+            )

pyobvector/json_table/virtual_data_type.py

@@ -10,6 +10,7 @@ from pydantic import BaseModel, Field, AfterValidator, create_model
 class IntEnum(int, Enum):
     """Int type enumerate definition."""
 
+
 class JType(IntEnum):
     J_BOOL = 1
     J_TIMESTAMP = 2
@@ -17,27 +18,32 @@ class JType(IntEnum):
     J_DECIMAL = 4
     J_INT = 5
 
+
 class JsonTableDataType(BaseModel):
     type: JType
 
+
 class JsonTableBool(JsonTableDataType):
     type: JType = Field(default=JType.J_BOOL)
     val: Optional[bool]
 
+
 class JsonTableTimestamp(JsonTableDataType):
     type: JType = Field(default=JType.J_TIMESTAMP)
     val: Optional[datetime]
 
+
 def check_varchar_len_with_length(length: int):
     def check_varchar_len(x: Optional[str]):
         if x is None:
             return None
         if len(x) > length:
-            raise ValueError(f'{x} is longer than {length}')
+            raise ValueError(f"{x} is longer than {length}")
         return x
-    
+
     return check_varchar_len
 
+
 class JsonTableVarcharFactory:
     def __init__(self, length: int):
         self.length = length
@@ -45,14 +51,17 @@ class JsonTableVarcharFactory:
     def get_json_table_varchar_type(self):
         model_name = f"JsonTableVarchar{self.length}"
         fields = {
-            'type': (JType, JType.J_VARCHAR),
-            'val': (Annotated[Optional[str], AfterValidator(check_varchar_len_with_length(self.length))], ...)
+            "type": (JType, JType.J_VARCHAR),
+            "val": (
+                Annotated[
+                    Optional[str],
+                    AfterValidator(check_varchar_len_with_length(self.length)),
+                ],
+                ...,
+            ),
         }
-        return create_model(
-            model_name,
-            __base__=JsonTableDataType,
-            **fields
-        )
+        return create_model(model_name, __base__=JsonTableDataType, **fields)
+
 
 def check_and_parse_decimal(x: int, y: int):
     def check_float(v):
@@ -62,47 +71,57 @@ def check_and_parse_decimal(x: int, y: int):
             decimal_value = Decimal(v)
         except InvalidOperation:
             raise ValueError(f"Value {v} cannot be converted to Decimal.")
-        
+
         decimal_str = str(decimal_value).strip()
-    
-        if '.' in decimal_str:
-            integer_part, decimal_part = decimal_str.split('.')
+
+        if "." in decimal_str:
+            integer_part, decimal_part = decimal_str.split(".")
         else:
-            integer_part, decimal_part = decimal_str, ''
-    
-        integer_count = len(integer_part.lstrip('-'))  # 去掉负号的长度
+            integer_part, decimal_part = decimal_str, ""
+
+        integer_count = len(integer_part.lstrip("-"))  # 去掉负号的长度
         decimal_count = len(decimal_part)
 
         if integer_count + min(decimal_count, y) > x:
             raise ValueError(f"'{v}' Range out of Decimal({x}, {y})")
-        
+
         if decimal_count > y:
-            quantize_str = '1.' + '0' * y
-            decimal_value = decimal_value.quantize(Decimal(quantize_str), rounding=ROUND_DOWN)
+            quantize_str = "1." + "0" * y
+            decimal_value = decimal_value.quantize(
+                Decimal(quantize_str), rounding=ROUND_DOWN
+            )
         return decimal_value
+
     return check_float
 
+
 class JsonTableDecimalFactory:
     def __init__(self, ndigits: int, decimal_p: int):
         self.ndigits = ndigits
         self.decimal_p = decimal_p
-    
+
     def get_json_table_decimal_type(self):
         model_name = f"JsonTableDecimal_{self.ndigits}_{self.decimal_p}"
         fields = {
-            'type': (JType, JType.J_DECIMAL),
-            'val': (Annotated[Optional[float], AfterValidator(check_and_parse_decimal(self.ndigits, self.decimal_p))], ...)
+            "type": (JType, JType.J_DECIMAL),
+            "val": (
+                Annotated[
+                    Optional[float],
+                    AfterValidator(
+                        check_and_parse_decimal(self.ndigits, self.decimal_p)
+                    ),
+                ],
+                ...,
+            ),
         }
-        return create_model(
-            model_name,
-            __base__=JsonTableDataType,
-            **fields
-        )
+        return create_model(model_name, __base__=JsonTableDataType, **fields)
+
 
 class JsonTableInt(JsonTableDataType):
     type: JType = Field(default=JType.J_INT)
     val: Optional[int]
 
+
 def val2json(val):
     if val is None:
         return None
@@ -111,4 +130,4 @@ def val2json(val):
     if isinstance(val, datetime):
         return val.isoformat()
     if isinstance(val, Decimal):
-        return float(val)
+        return float(val)

pyobvector/schema/__init__.py

@@ -20,13 +20,19 @@
 * CreateFtsIndex    Full Text Search Index Creation statement clause
 * MatchAgainst      Full Text Search clause
 """
+
 from .array import ARRAY
 from .vector import VECTOR
 from .sparse_vector import SPARSE_VECTOR
 from .geo_srid_point import POINT
 from .vector_index import VectorIndex, CreateVectorIndex
 from .ob_table import ObTable
-from .vec_dist_func import l2_distance, cosine_distance, inner_product, negative_inner_product
+from .vec_dist_func import (
+    l2_distance,
+    cosine_distance,
+    inner_product,
+    negative_inner_product,
+)
 from .gis_func import ST_GeomFromText, st_distance, st_dwithin, st_astext
 from .replace_stmt import ReplaceStmt
 from .dialect import OceanBaseDialect, AsyncOceanBaseDialect

pyobvector/schema/array.py

@@ -1,4 +1,5 @@
 """ARRAY: An extended data type for SQLAlchemy"""
+
 import json
 from typing import Any, Optional, Union
 from collections.abc import Sequence
@@ -9,6 +10,7 @@ from sqlalchemy.types import UserDefinedType, String
 
 class ARRAY(UserDefinedType):
     """ARRAY data type definition with support for up to 6 levels of nesting."""
+
     cache_ok = True
     _string = String()
 
@@ -32,7 +34,7 @@ class ARRAY(UserDefinedType):
 
     def get_col_spec(self, **kw):  # pylint: disable=unused-argument
         """Parse to array data type definition in text SQL."""
-        if hasattr(self.item_type, 'get_col_spec'):
+        if hasattr(self.item_type, "get_col_spec"):
             base_type = self.item_type.get_col_spec(**kw)
         else:
             base_type = str(self.item_type)
@@ -50,7 +52,9 @@ class ARRAY(UserDefinedType):
 
     def _validate_dimension(self, value: list[Any]):
         arr_depth = self._get_list_depth(value)
-        assert arr_depth == self.dim, f"Array dimension mismatch, expected {self.dim}, got {arr_depth}"
+        assert arr_depth == self.dim, (
+            f"Array dimension mismatch, expected {self.dim}, got {arr_depth}"
+        )
 
     def bind_processor(self, dialect):
         item_type = self.item_type