duckdb 1.4.1__cp39-cp39-macosx_10_9_universal2.whl → 1.5.0.dev44__cp39-cp39-macosx_10_9_universal2.whl

duckdb/experimental/spark/sql/types.py

@@ -1,28 +1,28 @@
-# ruff: noqa: D100
-# This code is based on code from Apache Spark under the license found in the LICENSE
-# file located in the 'spark' folder.
+# This code is based on code from Apache Spark under the license found in the LICENSE file located in the 'spark' folder.
 
-import calendar
-import datetime
-import math
-import re
-import time
-from builtins import tuple
-from collections.abc import Iterator, Mapping
-from types import MappingProxyType
 from typing import (
-    Any,
-    ClassVar,
-    NoReturn,
-    Optional,
-    TypeVar,
-    Union,
     cast,
     overload,
+    Dict,
+    Optional,
+    List,
+    Tuple,
+    Any,
+    Union,
+    Type,
+    TypeVar,
+    ClassVar,
+    Iterator,
 )
+from builtins import tuple
+import datetime
+import calendar
+import time
+import math
+import re
 
 import duckdb
-from duckdb.sqltypes import DuckDBPyType
+from duckdb.typing import DuckDBPyType
 
 from ..exception import ContributionsAcceptedError
 
@@ -30,100 +30,105 @@ T = TypeVar("T")
 U = TypeVar("U")
 
 __all__ = [
-    "ArrayType",
+    "DataType",
+    "NullType",
+    "StringType",
     "BinaryType",
+    "UUIDType",
     "BitstringType",
     "BooleanType",
-    "ByteType",
-    "DataType",
     "DateType",
-    "DayTimeIntervalType",
+    "TimestampType",
+    "TimestampNTZType",
+    "TimestampNanosecondNTZType",
+    "TimestampMilisecondNTZType",
+    "TimestampSecondNTZType",
+    "TimeType",
+    "TimeNTZType",
     "DecimalType",
     "DoubleType",
     "FloatType",
-    "HugeIntegerType",
+    "ByteType",
+    "UnsignedByteType",
+    "ShortType",
+    "UnsignedShortType",
     "IntegerType",
+    "UnsignedIntegerType",
     "LongType",
-    "MapType",
-    "NullType",
+    "UnsignedLongType",
+    "HugeIntegerType",
+    "UnsignedHugeIntegerType",
+    "DayTimeIntervalType",
     "Row",
-    "ShortType",
-    "StringType",
+    "ArrayType",
+    "MapType",
     "StructField",
     "StructType",
-    "TimeNTZType",
-    "TimeType",
-    "TimestampMilisecondNTZType",
-    "TimestampNTZType",
-    "TimestampNanosecondNTZType",
-    "TimestampSecondNTZType",
-    "TimestampType",
-    "UUIDType",
-    "UnsignedByteType",
-    "UnsignedHugeIntegerType",
-    "UnsignedIntegerType",
-    "UnsignedLongType",
-    "UnsignedShortType",
 ]
 
 
 class DataType:
     """Base class for data types."""
 
-    def __init__(self, duckdb_type: DuckDBPyType) -> None:  # noqa: D107
+    def __init__(self, duckdb_type):
         self.duckdb_type = duckdb_type
 
-    def __repr__(self) -> str:  # noqa: D105
+    def __repr__(self) -> str:
         return self.__class__.__name__ + "()"
 
-    def __hash__(self) -> int:  # noqa: D105
+    def __hash__(self) -> int:
         return hash(str(self))
 
-    def __eq__(self, other: object) -> bool:  # noqa: D105
+    def __eq__(self, other: Any) -> bool:
         return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 
-    def __ne__(self, other: object) -> bool:  # noqa: D105
+    def __ne__(self, other: Any) -> bool:
         return not self.__eq__(other)
 
     @classmethod
-    def typeName(cls) -> str:  # noqa: D102
+    def typeName(cls) -> str:
         return cls.__name__[:-4].lower()
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return self.typeName()
 
-    def jsonValue(self) -> Union[str, dict[str, Any]]:  # noqa: D102
+    def jsonValue(self) -> Union[str, Dict[str, Any]]:
         raise ContributionsAcceptedError
 
-    def json(self) -> str:  # noqa: D102
+    def json(self) -> str:
         raise ContributionsAcceptedError
 
     def needConversion(self) -> bool:
-        """Does this type needs conversion between Python object and internal SQL object.
+        """
+        Does this type needs conversion between Python object and internal SQL object.
 
         This is used to avoid the unnecessary conversion for ArrayType/MapType/StructType.
         """
         return False
 
-    def toInternal(self, obj: Any) -> Any:  # noqa: ANN401
-        """Converts a Python object into an internal SQL object."""
+    def toInternal(self, obj: Any) -> Any:
+        """
+        Converts a Python object into an internal SQL object.
+        """
         return obj
 
-    def fromInternal(self, obj: Any) -> Any:  # noqa: ANN401
-        """Converts an internal SQL object into a native Python object."""
+    def fromInternal(self, obj: Any) -> Any:
+        """
+        Converts an internal SQL object into a native Python object.
+        """
         return obj
 
 
 # This singleton pattern does not work with pickle, you will get
 # another object after pickle and unpickle
 class DataTypeSingleton(type):
-    """Metaclass for DataType."""
+    """Metaclass for DataType"""
 
-    _instances: ClassVar[dict[type["DataTypeSingleton"], "DataTypeSingleton"]] = {}
+    _instances: ClassVar[Dict[Type["DataTypeSingleton"], "DataTypeSingleton"]] = {}
 
-    def __call__(cls: type[T]) -> T:  # type: ignore[override]
+    def __call__(cls: Type[T]) -> T:  # type: ignore[override]
         if cls not in cls._instances:  # type: ignore[attr-defined]
-            cls._instances[cls] = super().__call__()  # type: ignore[misc, attr-defined]
+            cls._instances[cls] = super(DataTypeSingleton, cls).__call__()  # type: ignore[misc, attr-defined]
         return cls._instances[cls]  # type: ignore[attr-defined]
 
 
@@ -133,18 +138,17 @@ class NullType(DataType, metaclass=DataTypeSingleton):
     The data type representing None, used for the types that cannot be inferred.
     """
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("NULL"))
 
     @classmethod
-    def typeName(cls) -> str:  # noqa: D102
+    def typeName(cls) -> str:
         return "void"
 
 
 class AtomicType(DataType):
     """An internal type used to represent everything that is not
-    null, UDTs, arrays, structs, and maps.
-    """  # noqa: D205
+    null, UDTs, arrays, structs, and maps."""
 
 
 class NumericType(AtomicType):
@@ -162,54 +166,54 @@ class FractionalType(NumericType):
 class StringType(AtomicType, metaclass=DataTypeSingleton):
     """String data type."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("VARCHAR"))
 
 
 class BitstringType(AtomicType, metaclass=DataTypeSingleton):
     """Bitstring data type."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("BIT"))
 
 
 class UUIDType(AtomicType, metaclass=DataTypeSingleton):
     """UUID data type."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("UUID"))
 
 
 class BinaryType(AtomicType, metaclass=DataTypeSingleton):
     """Binary (byte array) data type."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("BLOB"))
 
 
 class BooleanType(AtomicType, metaclass=DataTypeSingleton):
     """Boolean data type."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("BOOLEAN"))
 
 
 class DateType(AtomicType, metaclass=DataTypeSingleton):
     """Date (datetime.date) data type."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("DATE"))
 
     EPOCH_ORDINAL = datetime.datetime(1970, 1, 1).toordinal()
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return True
 
-    def toInternal(self, d: datetime.date) -> int:  # noqa: D102
+    def toInternal(self, d: datetime.date) -> int:
         if d is not None:
             return d.toordinal() - self.EPOCH_ORDINAL
 
-    def fromInternal(self, v: int) -> datetime.date:  # noqa: D102
+    def fromInternal(self, v: int) -> datetime.date:
         if v is not None:
             return datetime.date.fromordinal(v + self.EPOCH_ORDINAL)
 
@@ -217,22 +221,22 @@ class DateType(AtomicType, metaclass=DataTypeSingleton):
 class TimestampType(AtomicType, metaclass=DataTypeSingleton):
     """Timestamp (datetime.datetime) data type."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("TIMESTAMPTZ"))
 
     @classmethod
-    def typeName(cls) -> str:  # noqa: D102
+    def typeName(cls) -> str:
         return "timestamptz"
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return True
 
-    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
+    def toInternal(self, dt: datetime.datetime) -> int:
         if dt is not None:
             seconds = calendar.timegm(dt.utctimetuple()) if dt.tzinfo else time.mktime(dt.timetuple())
             return int(seconds) * 1000000 + dt.microsecond
 
-    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
+    def fromInternal(self, ts: int) -> datetime.datetime:
         if ts is not None:
             # using int to avoid precision loss in float
             return datetime.datetime.fromtimestamp(ts // 1000000).replace(microsecond=ts % 1000000)
@@ -241,22 +245,22 @@ class TimestampType(AtomicType, metaclass=DataTypeSingleton):
 class TimestampNTZType(AtomicType, metaclass=DataTypeSingleton):
     """Timestamp (datetime.datetime) data type without timezone information with microsecond precision."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("TIMESTAMP"))
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return True
 
     @classmethod
-    def typeName(cls) -> str:  # noqa: D102
+    def typeName(cls) -> str:
         return "timestamp"
 
-    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
+    def toInternal(self, dt: datetime.datetime) -> int:
         if dt is not None:
             seconds = calendar.timegm(dt.timetuple())
             return int(seconds) * 1000000 + dt.microsecond
 
-    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
+    def fromInternal(self, ts: int) -> datetime.datetime:
         if ts is not None:
             # using int to avoid precision loss in float
             return datetime.datetime.utcfromtimestamp(ts // 1000000).replace(microsecond=ts % 1000000)
@@ -265,60 +269,60 @@ class TimestampNTZType(AtomicType, metaclass=DataTypeSingleton):
 class TimestampSecondNTZType(AtomicType, metaclass=DataTypeSingleton):
     """Timestamp (datetime.datetime) data type without timezone information with second precision."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("TIMESTAMP_S"))
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return True
 
     @classmethod
-    def typeName(cls) -> str:  # noqa: D102
+    def typeName(cls) -> str:
         return "timestamp_s"
 
-    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
+    def toInternal(self, dt: datetime.datetime) -> int:
         raise ContributionsAcceptedError
 
-    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
+    def fromInternal(self, ts: int) -> datetime.datetime:
         raise ContributionsAcceptedError
 
 
 class TimestampMilisecondNTZType(AtomicType, metaclass=DataTypeSingleton):
     """Timestamp (datetime.datetime) data type without timezone information with milisecond precision."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("TIMESTAMP_MS"))
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return True
 
     @classmethod
-    def typeName(cls) -> str:  # noqa: D102
+    def typeName(cls) -> str:
         return "timestamp_ms"
 
-    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
+    def toInternal(self, dt: datetime.datetime) -> int:
         raise ContributionsAcceptedError
 
-    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
+    def fromInternal(self, ts: int) -> datetime.datetime:
         raise ContributionsAcceptedError
 
 
 class TimestampNanosecondNTZType(AtomicType, metaclass=DataTypeSingleton):
     """Timestamp (datetime.datetime) data type without timezone information with nanosecond precision."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("TIMESTAMP_NS"))
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return True
 
     @classmethod
-    def typeName(cls) -> str:  # noqa: D102
+    def typeName(cls) -> str:
         return "timestamp_ns"
 
-    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
+    def toInternal(self, dt: datetime.datetime) -> int:
         raise ContributionsAcceptedError
 
-    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
+    def fromInternal(self, ts: int) -> datetime.datetime:
         raise ContributionsAcceptedError
 
 
@@ -342,90 +346,90 @@ class DecimalType(FractionalType):
         the number of digits on right side of dot. (default: 0)
     """
 
-    def __init__(self, precision: int = 10, scale: int = 0) -> None:  # noqa: D107
+    def __init__(self, precision: int = 10, scale: int = 0):
         super().__init__(duckdb.decimal_type(precision, scale))
         self.precision = precision
         self.scale = scale
         self.hasPrecisionInfo = True  # this is a public API
 
-    def simpleString(self) -> str:  # noqa: D102
-        return f"decimal({int(self.precision):d},{int(self.scale):d})"
+    def simpleString(self) -> str:
+        return "decimal(%d,%d)" % (self.precision, self.scale)
 
-    def __repr__(self) -> str:  # noqa: D105
-        return f"DecimalType({int(self.precision):d},{int(self.scale):d})"
+    def __repr__(self) -> str:
+        return "DecimalType(%d,%d)" % (self.precision, self.scale)
 
 
 class DoubleType(FractionalType, metaclass=DataTypeSingleton):
     """Double data type, representing double precision floats."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("DOUBLE"))
 
 
 class FloatType(FractionalType, metaclass=DataTypeSingleton):
     """Float data type, representing single precision floats."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("FLOAT"))
 
 
 class ByteType(IntegralType):
     """Byte data type, i.e. a signed integer in a single byte."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("TINYINT"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "tinyint"
 
 
 class UnsignedByteType(IntegralType):
     """Unsigned byte data type, i.e. a unsigned integer in a single byte."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("UTINYINT"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "utinyint"
 
 
 class ShortType(IntegralType):
     """Short data type, i.e. a signed 16-bit integer."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("SMALLINT"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "smallint"
 
 
 class UnsignedShortType(IntegralType):
     """Unsigned short data type, i.e. a unsigned 16-bit integer."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("USMALLINT"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "usmallint"
 
 
 class IntegerType(IntegralType):
     """Int data type, i.e. a signed 32-bit integer."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("INTEGER"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "integer"
 
 
 class UnsignedIntegerType(IntegralType):
     """Unsigned int data type, i.e. a unsigned 32-bit integer."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("UINTEGER"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "uinteger"
 
 
@@ -436,10 +440,10 @@ class LongType(IntegralType):
     please use :class:`DecimalType`.
     """
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("BIGINT"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "bigint"
 
 
@@ -450,24 +454,24 @@ class UnsignedLongType(IntegralType):
     please use :class:`HugeIntegerType`.
     """
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("UBIGINT"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "ubigint"
 
 
 class HugeIntegerType(IntegralType):
     """Huge integer data type, i.e. a signed 128-bit integer.
 
-    If the values are beyond the range of [-170141183460469231731687303715884105728,
-    170141183460469231731687303715884105727], please use :class:`DecimalType`.
+    If the values are beyond the range of [-170141183460469231731687303715884105728, 170141183460469231731687303715884105727],
+    please use :class:`DecimalType`.
     """
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("HUGEINT"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "hugeint"
 
 
@@ -478,30 +482,30 @@ class UnsignedHugeIntegerType(IntegralType):
     please use :class:`DecimalType`.
     """
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("UHUGEINT"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "uhugeint"
 
 
 class TimeType(IntegralType):
     """Time (datetime.time) data type."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("TIMETZ"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "timetz"
 
 
 class TimeNTZType(IntegralType):
     """Time (datetime.time) data type without timezone information."""
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self):
         super().__init__(DuckDBPyType("TIME"))
 
-    def simpleString(self) -> str:  # noqa: D102
+    def simpleString(self) -> str:
         return "time"
 
 
@@ -513,18 +517,16 @@ class DayTimeIntervalType(AtomicType):
     MINUTE = 2
     SECOND = 3
 
-    _fields: Mapping[str, int] = MappingProxyType(
-        {
-            DAY: "day",
-            HOUR: "hour",
-            MINUTE: "minute",
-            SECOND: "second",
-        }
-    )
+    _fields = {
+        DAY: "day",
+        HOUR: "hour",
+        MINUTE: "minute",
+        SECOND: "second",
+    }
 
-    _inverted_fields: Mapping[int, str] = MappingProxyType(dict(zip(_fields.values(), _fields.keys())))
+    _inverted_fields = dict(zip(_fields.values(), _fields.keys()))
 
-    def __init__(self, startField: Optional[int] = None, endField: Optional[int] = None) -> None:  # noqa: D107
+    def __init__(self, startField: Optional[int] = None, endField: Optional[int] = None):
         super().__init__(DuckDBPyType("INTERVAL"))
         if startField is None and endField is None:
             # Default matched to scala side.
@@ -534,34 +536,33 @@ class DayTimeIntervalType(AtomicType):
             endField = startField
 
         fields = DayTimeIntervalType._fields
-        if startField not in fields or endField not in fields:
-            msg = f"interval {startField} to {endField} is invalid"
-            raise RuntimeError(msg)
-        self.startField = cast("int", startField)
-        self.endField = cast("int", endField)
+        if startField not in fields.keys() or endField not in fields.keys():
+            raise RuntimeError("interval %s to %s is invalid" % (startField, endField))
+        self.startField = cast(int, startField)
+        self.endField = cast(int, endField)
 
     def _str_repr(self) -> str:
         fields = DayTimeIntervalType._fields
         start_field_name = fields[self.startField]
         end_field_name = fields[self.endField]
         if start_field_name == end_field_name:
-            return f"interval {start_field_name}"
+            return "interval %s" % start_field_name
         else:
-            return f"interval {start_field_name} to {end_field_name}"
+            return "interval %s to %s" % (start_field_name, end_field_name)
 
     simpleString = _str_repr
 
-    def __repr__(self) -> str:  # noqa: D105
-        return f"{type(self).__name__}({int(self.startField):d}, {int(self.endField):d})"
+    def __repr__(self) -> str:
+        return "%s(%d, %d)" % (type(self).__name__, self.startField, self.endField)
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return True
 
-    def toInternal(self, dt: datetime.timedelta) -> Optional[int]:  # noqa: D102
+    def toInternal(self, dt: datetime.timedelta) -> Optional[int]:
         if dt is not None:
             return (math.floor(dt.total_seconds()) * 1000000) + dt.microseconds
 
-    def fromInternal(self, micros: int) -> Optional[datetime.timedelta]:  # noqa: D102
+    def fromInternal(self, micros: int) -> Optional[datetime.timedelta]:
         if micros is not None:
             return datetime.timedelta(microseconds=micros)
 
@@ -576,7 +577,7 @@ class ArrayType(DataType):
     containsNull : bool, optional
         whether the array can contain null (None) values.
 
-    Examples:
+    Examples
     --------
     >>> ArrayType(StringType()) == ArrayType(StringType(), True)
     True
@@ -584,27 +585,30 @@ class ArrayType(DataType):
     False
     """
 
-    def __init__(self, elementType: DataType, containsNull: bool = True) -> None:  # noqa: D107
+    def __init__(self, elementType: DataType, containsNull: bool = True):
         super().__init__(duckdb.list_type(elementType.duckdb_type))
-        assert isinstance(elementType, DataType), f"elementType {elementType} should be an instance of {DataType}"
+        assert isinstance(elementType, DataType), "elementType %s should be an instance of %s" % (
+            elementType,
+            DataType,
+        )
         self.elementType = elementType
         self.containsNull = containsNull
 
-    def simpleString(self) -> str:  # noqa: D102
-        return f"array<{self.elementType.simpleString()}>"
+    def simpleString(self) -> str:
+        return "array<%s>" % self.elementType.simpleString()
 
-    def __repr__(self) -> str:  # noqa: D105
-        return f"ArrayType({self.elementType}, {self.containsNull!s})"
+    def __repr__(self) -> str:
+        return "ArrayType(%s, %s)" % (self.elementType, str(self.containsNull))
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return self.elementType.needConversion()
 
-    def toInternal(self, obj: list[Optional[T]]) -> list[Optional[T]]:  # noqa: D102
+    def toInternal(self, obj: List[Optional[T]]) -> List[Optional[T]]:
         if not self.needConversion():
             return obj
         return obj and [self.elementType.toInternal(v) for v in obj]
 
-    def fromInternal(self, obj: list[Optional[T]]) -> list[Optional[T]]:  # noqa: D102
+    def fromInternal(self, obj: List[Optional[T]]) -> List[Optional[T]]:
         if not self.needConversion():
             return obj
         return obj and [self.elementType.fromInternal(v) for v in obj]
@@ -622,44 +626,59 @@ class MapType(DataType):
     valueContainsNull : bool, optional
         indicates whether values can contain null (None) values.
 
-    Notes:
+    Notes
     -----
     Keys in a map data type are not allowed to be null (None).
 
-    Examples:
+    Examples
     --------
-    >>> (MapType(StringType(), IntegerType()) == MapType(StringType(), IntegerType(), True))
+    >>> (MapType(StringType(), IntegerType())
+    ...        == MapType(StringType(), IntegerType(), True))
     True
-    >>> (MapType(StringType(), IntegerType(), False) == MapType(StringType(), FloatType()))
+    >>> (MapType(StringType(), IntegerType(), False)
+    ...        == MapType(StringType(), FloatType()))
     False
     """
 
-    def __init__(self, keyType: DataType, valueType: DataType, valueContainsNull: bool = True) -> None:  # noqa: D107
+    def __init__(self, keyType: DataType, valueType: DataType, valueContainsNull: bool = True):
         super().__init__(duckdb.map_type(keyType.duckdb_type, valueType.duckdb_type))
-        assert isinstance(keyType, DataType), f"keyType {keyType} should be an instance of {DataType}"
-        assert isinstance(valueType, DataType), f"valueType {valueType} should be an instance of {DataType}"
+        assert isinstance(keyType, DataType), "keyType %s should be an instance of %s" % (
+            keyType,
+            DataType,
+        )
+        assert isinstance(valueType, DataType), "valueType %s should be an instance of %s" % (
+            valueType,
+            DataType,
+        )
         self.keyType = keyType
         self.valueType = valueType
         self.valueContainsNull = valueContainsNull
 
-    def simpleString(self) -> str:  # noqa: D102
-        return f"map<{self.keyType.simpleString()},{self.valueType.simpleString()}>"
+    def simpleString(self) -> str:
+        return "map<%s,%s>" % (
+            self.keyType.simpleString(),
+            self.valueType.simpleString(),
+        )
 
-    def __repr__(self) -> str:  # noqa: D105
-        return f"MapType({self.keyType}, {self.valueType}, {self.valueContainsNull!s})"
+    def __repr__(self) -> str:
+        return "MapType(%s, %s, %s)" % (
+            self.keyType,
+            self.valueType,
+            str(self.valueContainsNull),
+        )
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return self.keyType.needConversion() or self.valueType.needConversion()
 
-    def toInternal(self, obj: dict[T, Optional[U]]) -> dict[T, Optional[U]]:  # noqa: D102
+    def toInternal(self, obj: Dict[T, Optional[U]]) -> Dict[T, Optional[U]]:
         if not self.needConversion():
             return obj
-        return obj and {self.keyType.toInternal(k): self.valueType.toInternal(v) for k, v in obj.items()}
+        return obj and dict((self.keyType.toInternal(k), self.valueType.toInternal(v)) for k, v in obj.items())
 
-    def fromInternal(self, obj: dict[T, Optional[U]]) -> dict[T, Optional[U]]:  # noqa: D102
+    def fromInternal(self, obj: Dict[T, Optional[U]]) -> Dict[T, Optional[U]]:
         if not self.needConversion():
             return obj
-        return obj and {self.keyType.fromInternal(k): self.valueType.fromInternal(v) for k, v in obj.items()}
+        return obj and dict((self.keyType.fromInternal(k), self.valueType.fromInternal(v)) for k, v in obj.items())
 
 
 class StructField(DataType):
@@ -676,58 +695,66 @@ class StructField(DataType):
     metadata : dict, optional
         a dict from string to simple type that can be toInternald to JSON automatically
 
-    Examples:
+    Examples
     --------
-    >>> (StructField("f1", StringType(), True) == StructField("f1", StringType(), True))
+    >>> (StructField("f1", StringType(), True)
+    ...      == StructField("f1", StringType(), True))
     True
-    >>> (StructField("f1", StringType(), True) == StructField("f2", StringType(), True))
+    >>> (StructField("f1", StringType(), True)
+    ...      == StructField("f2", StringType(), True))
     False
     """
 
-    def __init__(  # noqa: D107
+    def __init__(
         self,
         name: str,
         dataType: DataType,
         nullable: bool = True,
-        metadata: Optional[dict[str, Any]] = None,
-    ) -> None:
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
         super().__init__(dataType.duckdb_type)
-        assert isinstance(dataType, DataType), f"dataType {dataType} should be an instance of {DataType}"
-        assert isinstance(name, str), f"field name {name} should be a string"
+        assert isinstance(dataType, DataType), "dataType %s should be an instance of %s" % (
+            dataType,
+            DataType,
+        )
+        assert isinstance(name, str), "field name %s should be a string" % (name)
         self.name = name
         self.dataType = dataType
         self.nullable = nullable
         self.metadata = metadata or {}
 
-    def simpleString(self) -> str:  # noqa: D102
-        return f"{self.name}:{self.dataType.simpleString()}"
+    def simpleString(self) -> str:
+        return "%s:%s" % (self.name, self.dataType.simpleString())
 
-    def __repr__(self) -> str:  # noqa: D105
-        return f"StructField('{self.name}', {self.dataType}, {self.nullable!s})"
+    def __repr__(self) -> str:
+        return "StructField('%s', %s, %s)" % (
+            self.name,
+            self.dataType,
+            str(self.nullable),
+        )
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         return self.dataType.needConversion()
 
-    def toInternal(self, obj: T) -> T:  # noqa: D102
+    def toInternal(self, obj: T) -> T:
         return self.dataType.toInternal(obj)
 
-    def fromInternal(self, obj: T) -> T:  # noqa: D102
+    def fromInternal(self, obj: T) -> T:
         return self.dataType.fromInternal(obj)
 
-    def typeName(self) -> str:  # type: ignore[override]  # noqa: D102
-        msg = "StructField does not have typeName. Use typeName on its type explicitly instead."
-        raise TypeError(msg)
+    def typeName(self) -> str:  # type: ignore[override]
+        raise TypeError("StructField does not have typeName. " "Use typeName on its type explicitly instead.")
 
 
 class StructType(DataType):
-    r"""Struct type, consisting of a list of :class:`StructField`.
+    """Struct type, consisting of a list of :class:`StructField`.
 
     This is the data type representing a :class:`Row`.
 
     Iterating a :class:`StructType` will iterate over its :class:`StructField`\\s.
     A contained :class:`StructField` can be accessed by its name or position.
 
-    Examples:
+    Examples
     --------
     >>> struct1 = StructType([StructField("f1", StringType(), True)])
     >>> struct1["f1"]
@@ -740,17 +767,16 @@ class StructType(DataType):
     >>> struct1 == struct2
     True
     >>> struct1 = StructType([StructField("f1", StringType(), True)])
-    >>> struct2 = StructType(
-    ...     [StructField("f1", StringType(), True), StructField("f2", IntegerType(), False)]
-    ... )
+    >>> struct2 = StructType([StructField("f1", StringType(), True),
+    ...     StructField("f2", IntegerType(), False)])
     >>> struct1 == struct2
     False
     """
 
-    def _update_internal_duckdb_type(self) -> None:
+    def _update_internal_duckdb_type(self):
         self.duckdb_type = duckdb.struct_type(dict(zip(self.names, [x.duckdb_type for x in self.fields])))
 
-    def __init__(self, fields: Optional[list[StructField]] = None) -> None:  # noqa: D107
+    def __init__(self, fields: Optional[List[StructField]] = None):
         if not fields:
             self.fields = []
             self.names = []
@@ -769,20 +795,23 @@ class StructType(DataType):
         field: str,
         data_type: Union[str, DataType],
         nullable: bool = True,
-        metadata: Optional[dict[str, Any]] = None,
-    ) -> "StructType": ...
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> "StructType":
+        ...
 
     @overload
-    def add(self, field: StructField) -> "StructType": ...
+    def add(self, field: StructField) -> "StructType":
+        ...
 
     def add(
         self,
         field: Union[str, StructField],
         data_type: Optional[Union[str, DataType]] = None,
         nullable: bool = True,
-        metadata: Optional[dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> "StructType":
-        r"""Construct a :class:`StructType` by adding new elements to it, to define the schema.
+        """
+        Construct a :class:`StructType` by adding new elements to it, to define the schema.
         The method accepts either:
 
             a) A single parameter which is a :class:`StructField` object.
@@ -801,11 +830,11 @@ class StructType(DataType):
         metadata : dict, optional
             Any additional metadata (default None)
 
-        Returns:
+        Returns
         -------
         :class:`StructType`
 
-        Examples:
+        Examples
         --------
         >>> struct1 = StructType().add("f1", StringType(), True).add("f2", StringType(), True, None)
         >>> struct2 = StructType([StructField("f1", StringType(), True), \\
@@ -820,14 +849,13 @@ class StructType(DataType):
         >>> struct2 = StructType([StructField("f1", StringType(), True)])
         >>> struct1 == struct2
         True
-        """  # noqa: D205, D415
+        """
         if isinstance(field, StructField):
             self.fields.append(field)
             self.names.append(field.name)
         else:
             if isinstance(field, str) and data_type is None:
-                msg = "Must specify DataType if passing name of struct_field to create."
-                raise ValueError(msg)
+                raise ValueError("Must specify DataType if passing name of struct_field to create.")
             else:
                 data_type_f = data_type
             self.fields.append(StructField(field, data_type_f, nullable, metadata))
@@ -839,7 +867,7 @@ class StructType(DataType):
         return self
 
     def __iter__(self) -> Iterator[StructField]:
-        """Iterate the fields."""
+        """Iterate the fields"""
         return iter(self.fields)
 
     def __len__(self) -> int:
@@ -852,30 +880,27 @@ class StructType(DataType):
             for field in self:
                 if field.name == key:
                     return field
-            msg = f"No StructField named {key}"
-            raise KeyError(msg)
+            raise KeyError("No StructField named {0}".format(key))
         elif isinstance(key, int):
             try:
                 return self.fields[key]
             except IndexError:
-                msg = "StructType index out of range"
-                raise IndexError(msg)  # noqa: B904
+                raise IndexError("StructType index out of range")
         elif isinstance(key, slice):
             return StructType(self.fields[key])
         else:
-            msg = "StructType keys should be strings, integers or slices"
-            raise TypeError(msg)
+            raise TypeError("StructType keys should be strings, integers or slices")
 
-    def simpleString(self) -> str:  # noqa: D102
-        return "struct<{}>".format(",".join(f.simpleString() for f in self))
+    def simpleString(self) -> str:
+        return "struct<%s>" % (",".join(f.simpleString() for f in self))
 
-    def __repr__(self) -> str:  # noqa: D105
-        return "StructType([{}])".format(", ".join(str(field) for field in self))
+    def __repr__(self) -> str:
+        return "StructType([%s])" % ", ".join(str(field) for field in self)
 
-    def __contains__(self, item: str) -> bool:  # noqa: D105
+    def __contains__(self, item: Any) -> bool:
         return item in self.names
 
-    def extract_types_and_names(self) -> tuple[list[str], list[str]]:  # noqa: D102
+    def extract_types_and_names(self) -> Tuple[List[str], List[str]]:
         names = []
         types = []
         for f in self.fields:
@@ -883,10 +908,11 @@ class StructType(DataType):
             names.append(f.name)
         return (types, names)
 
-    def fieldNames(self) -> list[str]:
-        """Returns all field names in a list.
+    def fieldNames(self) -> List[str]:
+        """
+        Returns all field names in a list.
 
-        Examples:
+        Examples
         --------
         >>> struct = StructType([StructField("f1", StringType(), True)])
         >>> struct.fieldNames()
@@ -894,11 +920,11 @@ class StructType(DataType):
         """
         return list(self.names)
 
-    def needConversion(self) -> bool:  # noqa: D102
+    def needConversion(self) -> bool:
         # We need convert Row()/namedtuple into tuple()
         return True
 
-    def toInternal(self, obj: tuple) -> tuple:  # noqa: D102
+    def toInternal(self, obj: Tuple) -> Tuple:
         if obj is None:
             return
 
@@ -918,8 +944,7 @@ class StructType(DataType):
                     for n, f, c in zip(self.names, self.fields, self._needConversion)
                 )
             else:
-                msg = f"Unexpected tuple {obj!r} with StructType"
-                raise ValueError(msg)
+                raise ValueError("Unexpected tuple %r with StructType" % obj)
         else:
             if isinstance(obj, dict):
                 return tuple(obj.get(n) for n in self.names)
@@ -929,17 +954,16 @@ class StructType(DataType):
                 d = obj.__dict__
                 return tuple(d.get(n) for n in self.names)
             else:
-                msg = f"Unexpected tuple {obj!r} with StructType"
-                raise ValueError(msg)
+                raise ValueError("Unexpected tuple %r with StructType" % obj)
 
-    def fromInternal(self, obj: tuple) -> "Row":  # noqa: D102
+    def fromInternal(self, obj: Tuple) -> "Row":
         if obj is None:
             return
         if isinstance(obj, Row):
             # it's already converted by pickler
             return obj
 
-        values: Union[tuple, list]
+        values: Union[Tuple, List]
         if self._needSerializeAnyField:
             # Only calling fromInternal function for fields that need conversion
             values = [f.fromInternal(v) if c else v for f, v, c in zip(self.fields, obj, self._needConversion)]
@@ -949,7 +973,7 @@ class StructType(DataType):
 
 
 class UnionType(DataType):
-    def __init__(self) -> None:
+    def __init__(self):
         raise ContributionsAcceptedError
 
 
@@ -959,7 +983,7 @@ class UserDefinedType(DataType):
     .. note:: WARN: Spark Internal Use Only
     """
 
-    def __init__(self) -> None:
+    def __init__(self):
         raise ContributionsAcceptedError
 
     @classmethod
@@ -968,21 +992,24 @@ class UserDefinedType(DataType):
 
     @classmethod
     def sqlType(cls) -> DataType:
-        """Underlying SQL storage type for this UDT."""
-        msg = "UDT must implement sqlType()."
-        raise NotImplementedError(msg)
+        """
+        Underlying SQL storage type for this UDT.
+        """
+        raise NotImplementedError("UDT must implement sqlType().")
 
     @classmethod
     def module(cls) -> str:
-        """The Python module of the UDT."""
-        msg = "UDT must implement module()."
-        raise NotImplementedError(msg)
+        """
+        The Python module of the UDT.
+        """
+        raise NotImplementedError("UDT must implement module().")
 
     @classmethod
     def scalaUDT(cls) -> str:
-        """The class name of the paired Scala UDT (could be '', if there
+        """
+        The class name of the paired Scala UDT (could be '', if there
         is no corresponding one).
-        """  # noqa: D205
+        """
         return ""
 
     def needConversion(self) -> bool:
@@ -990,38 +1017,42 @@ class UserDefinedType(DataType):
 
     @classmethod
     def _cachedSqlType(cls) -> DataType:
-        """Cache the sqlType() into class, because it's heavily used in `toInternal`."""
+        """
+        Cache the sqlType() into class, because it's heavily used in `toInternal`.
+        """
         if not hasattr(cls, "_cached_sql_type"):
             cls._cached_sql_type = cls.sqlType()  # type: ignore[attr-defined]
         return cls._cached_sql_type  # type: ignore[attr-defined]
 
-    def toInternal(self, obj: Any) -> Any:  # noqa: ANN401
+    def toInternal(self, obj: Any) -> Any:
         if obj is not None:
             return self._cachedSqlType().toInternal(self.serialize(obj))
 
-    def fromInternal(self, obj: Any) -> Any:  # noqa: ANN401
+    def fromInternal(self, obj: Any) -> Any:
         v = self._cachedSqlType().fromInternal(obj)
         if v is not None:
             return self.deserialize(v)
 
-    def serialize(self, obj: Any) -> NoReturn:  # noqa: ANN401
-        """Converts a user-type object into a SQL datum."""
-        msg = "UDT must implement toInternal()."
-        raise NotImplementedError(msg)
+    def serialize(self, obj: Any) -> Any:
+        """
+        Converts a user-type object into a SQL datum.
+        """
+        raise NotImplementedError("UDT must implement toInternal().")
 
-    def deserialize(self, datum: Any) -> NoReturn:  # noqa: ANN401
-        """Converts a SQL datum into a user-type object."""
-        msg = "UDT must implement fromInternal()."
-        raise NotImplementedError(msg)
+    def deserialize(self, datum: Any) -> Any:
+        """
+        Converts a SQL datum into a user-type object.
+        """
+        raise NotImplementedError("UDT must implement fromInternal().")
 
     def simpleString(self) -> str:
         return "udt"
 
-    def __eq__(self, other: object) -> bool:
-        return type(self) is type(other)
+    def __eq__(self, other: Any) -> bool:
+        return type(self) == type(other)
 
 
-_atomic_types: list[type[DataType]] = [
+_atomic_types: List[Type[DataType]] = [
     StringType,
     BinaryType,
     BooleanType,
@@ -1037,28 +1068,32 @@ _atomic_types: list[type[DataType]] = [
     TimestampNTZType,
     NullType,
 ]
-_all_atomic_types: dict[str, type[DataType]] = {t.typeName(): t for t in _atomic_types}
+_all_atomic_types: Dict[str, Type[DataType]] = dict((t.typeName(), t) for t in _atomic_types)
 
-_complex_types: list[type[Union[ArrayType, MapType, StructType]]] = [
+_complex_types: List[Type[Union[ArrayType, MapType, StructType]]] = [
     ArrayType,
     MapType,
     StructType,
 ]
-_all_complex_types: dict[str, type[Union[ArrayType, MapType, StructType]]] = {v.typeName(): v for v in _complex_types}
+_all_complex_types: Dict[str, Type[Union[ArrayType, MapType, StructType]]] = dict(
+    (v.typeName(), v) for v in _complex_types
+)
 
 
 _FIXED_DECIMAL = re.compile(r"decimal\(\s*(\d+)\s*,\s*(-?\d+)\s*\)")
 _INTERVAL_DAYTIME = re.compile(r"interval (day|hour|minute|second)( to (day|hour|minute|second))?")
 
 
-def _create_row(fields: Union["Row", list[str]], values: Union[tuple[Any, ...], list[Any]]) -> "Row":
+def _create_row(fields: Union["Row", List[str]], values: Union[Tuple[Any, ...], List[Any]]) -> "Row":
     row = Row(*values)
     row.__fields__ = fields
     return row
 
 
 class Row(tuple):
-    """A row in :class:`DataFrame`.
+
+    """
+    A row in :class:`DataFrame`.
     The fields in it can be accessed:
 
     * like attributes (``row.key``)
@@ -1075,18 +1110,18 @@ class Row(tuple):
         field names sorted alphabetically and will be ordered in the position as
         entered.
 
-    Examples:
+    Examples
     --------
     >>> row = Row(name="Alice", age=11)
     >>> row
     Row(name='Alice', age=11)
-    >>> row["name"], row["age"]
+    >>> row['name'], row['age']
     ('Alice', 11)
     >>> row.name, row.age
     ('Alice', 11)
-    >>> "name" in row
+    >>> 'name' in row
     True
-    >>> "wrong_key" in row
+    >>> 'wrong_key' in row
     False
 
     Row also can be used to create another Row like class, then it
@@ -1095,9 +1130,9 @@ class Row(tuple):
     >>> Person = Row("name", "age")
     >>> Person
     <Row('name', 'age')>
-    >>> "name" in Person
+    >>> 'name' in Person
     True
-    >>> "wrong_key" in Person
+    >>> 'wrong_key' in Person
     False
     >>> Person("Alice", 11)
     Row(name='Alice', age=11)
@@ -1109,18 +1144,19 @@ class Row(tuple):
     >>> row2 = Row(name="Alice", age=11)
     >>> row1 == row2
     True
-    """  # noqa: D205, D415
+    """
 
     @overload
-    def __new__(cls, *args: str) -> "Row": ...
+    def __new__(cls, *args: str) -> "Row":
+        ...
 
     @overload
-    def __new__(cls, **kwargs: Any) -> "Row": ...  # noqa: ANN401
+    def __new__(cls, **kwargs: Any) -> "Row":
+        ...
 
-    def __new__(cls, *args: Optional[str], **kwargs: Optional[Any]) -> "Row":  # noqa: D102
+    def __new__(cls, *args: Optional[str], **kwargs: Optional[Any]) -> "Row":
         if args and kwargs:
-            msg = "Can not use both args and kwargs to create Row"
-            raise ValueError(msg)
+            raise ValueError("Can not use both args " "and kwargs to create Row")
         if kwargs:
             # create row objects
             row = tuple.__new__(cls, list(kwargs.values()))
@@ -1130,15 +1166,16 @@ class Row(tuple):
             # create row class or objects
             return tuple.__new__(cls, args)
 
-    def asDict(self, recursive: bool = False) -> dict[str, Any]:
-        """Return as a dict.
+    def asDict(self, recursive: bool = False) -> Dict[str, Any]:
+        """
+        Return as a dict
 
         Parameters
         ----------
         recursive : bool, optional
             turns the nested Rows to dict (default: False).
 
-        Notes:
+        Notes
         -----
         If a row contains duplicate field names, e.g., the rows of a join
         between two :class:`DataFrame` that both have the fields of same names,
@@ -1146,29 +1183,28 @@ class Row(tuple):
         will also return one of the duplicate fields, however returned value might
         be different to ``asDict``.
 
-        Examples:
+        Examples
         --------
-        >>> Row(name="Alice", age=11).asDict() == {"name": "Alice", "age": 11}
+        >>> Row(name="Alice", age=11).asDict() == {'name': 'Alice', 'age': 11}
         True
-        >>> row = Row(key=1, value=Row(name="a", age=2))
-        >>> row.asDict() == {"key": 1, "value": Row(name="a", age=2)}
+        >>> row = Row(key=1, value=Row(name='a', age=2))
+        >>> row.asDict() == {'key': 1, 'value': Row(name='a', age=2)}
         True
-        >>> row.asDict(True) == {"key": 1, "value": {"name": "a", "age": 2}}
+        >>> row.asDict(True) == {'key': 1, 'value': {'name': 'a', 'age': 2}}
         True
         """
         if not hasattr(self, "__fields__"):
-            msg = "Cannot convert a Row class into dict"
-            raise TypeError(msg)
+            raise TypeError("Cannot convert a Row class into dict")
 
         if recursive:
 
-            def conv(obj: Union[Row, list, dict, object]) -> Union[list, dict, object]:
+            def conv(obj: Any) -> Any:
                 if isinstance(obj, Row):
                     return obj.asDict(True)
                 elif isinstance(obj, list):
                     return [conv(o) for o in obj]
                 elif isinstance(obj, dict):
-                    return {k: conv(v) for k, v in obj.items()}
+                    return dict((k, conv(v)) for k, v in obj.items())
                 else:
                     return obj
 
@@ -1176,34 +1212,35 @@ class Row(tuple):
         else:
             return dict(zip(self.__fields__, self))
 
-    def __contains__(self, item: Any) -> bool:  # noqa: D105, ANN401
+    def __contains__(self, item: Any) -> bool:
         if hasattr(self, "__fields__"):
             return item in self.__fields__
         else:
-            return super().__contains__(item)
+            return super(Row, self).__contains__(item)
 
     # let object acts like class
-    def __call__(self, *args: Any) -> "Row":  # noqa: ANN401
-        """Create new Row object."""
+    def __call__(self, *args: Any) -> "Row":
+        """create new Row object"""
         if len(args) > len(self):
-            msg = f"Can not create Row with fields {self}, expected {len(self):d} values but got {args}"
-            raise ValueError(msg)
+            raise ValueError(
+                "Can not create Row with fields %s, expected %d values " "but got %s" % (self, len(self), args)
+            )
         return _create_row(self, args)
 
-    def __getitem__(self, item: Any) -> Any:  # noqa: D105, ANN401
+    def __getitem__(self, item: Any) -> Any:
         if isinstance(item, (int, slice)):
-            return super().__getitem__(item)
+            return super(Row, self).__getitem__(item)
         try:
             # it will be slow when it has many fields,
             # but this will not be used in normal cases
             idx = self.__fields__.index(item)
-            return super().__getitem__(idx)
+            return super(Row, self).__getitem__(idx)
         except IndexError:
-            raise KeyError(item)  # noqa: B904
+            raise KeyError(item)
         except ValueError:
-            raise ValueError(item)  # noqa: B904
+            raise ValueError(item)
 
-    def __getattr__(self, item: str) -> Any:  # noqa: D105, ANN401
+    def __getattr__(self, item: str) -> Any:
         if item.startswith("__"):
             raise AttributeError(item)
         try:
@@ -1212,19 +1249,18 @@ class Row(tuple):
             idx = self.__fields__.index(item)
             return self[idx]
         except IndexError:
-            raise AttributeError(item)  # noqa: B904
+            raise AttributeError(item)
         except ValueError:
-            raise AttributeError(item)  # noqa: B904
+            raise AttributeError(item)
 
-    def __setattr__(self, key: Any, value: Any) -> None:  # noqa: D105, ANN401
+    def __setattr__(self, key: Any, value: Any) -> None:
         if key != "__fields__":
-            msg = "Row is read-only"
-            raise RuntimeError(msg)
+            raise RuntimeError("Row is read-only")
         self.__dict__[key] = value
 
     def __reduce__(
         self,
-    ) -> Union[str, tuple[Any, ...]]:
+    ) -> Union[str, Tuple[Any, ...]]:
         """Returns a tuple so Python knows how to pickle Row."""
         if hasattr(self, "__fields__"):
             return (_create_row, (self.__fields__, tuple(self)))
@@ -1234,6 +1270,6 @@ class Row(tuple):
     def __repr__(self) -> str:
         """Printable representation of Row used in Python REPL."""
         if hasattr(self, "__fields__"):
-            return "Row({})".format(", ".join(f"{k}={v!r}" for k, v in zip(self.__fields__, tuple(self))))
+            return "Row(%s)" % ", ".join("%s=%r" % (k, v) for k, v in zip(self.__fields__, tuple(self)))
         else:
-            return "<Row({})>".format(", ".join(f"{field!r}" for field in self))
+            return "<Row(%s)>" % ", ".join("%r" % field for field in self)