duckdb 0.8.2.dev3007__cp311-cp311-win_amd64.whl → 1.4.3.dev8__cp311-cp311-win_amd64.whl

{pyduckdb → duckdb/experimental}/spark/sql/types.py

@@ -1,28 +1,28 @@
-# This code is based on code from Apache Spark under the license found in the LICENSE file located in the 'spark' folder.
+# 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.
 
+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 (
-    cast,
-    overload,
-    Dict,
-    Optional,
-    List,
-    Tuple,
     Any,
-    Union,
-    Type,
-    TypeVar,
     ClassVar,
-    Iterator,
-    TYPE_CHECKING,
+    NoReturn,
+    Optional,
+    TypeVar,
+    Union,
+    cast,
+    overload,
 )
-from builtins import tuple
-import datetime
-import calendar
-import time
-import math
 
 import duckdb
-from duckdb.typing import DuckDBPyType
+from duckdb.sqltypes import DuckDBPyType
 
 from ..exception import ContributionsAcceptedError
 
@@ -30,104 +30,100 @@ T = TypeVar("T")
 U = TypeVar("U")
 
 __all__ = [
-    "DataType",
-    "NullType",
-    "StringType",
+    "ArrayType",
     "BinaryType",
-    "UUIDType",
     "BitstringType",
     "BooleanType",
+    "ByteType",
+    "DataType",
     "DateType",
-    "TimestampType",
-    "TimestampNTZType",
-    "TimestampNanosecondNTZType",
-    "TimestampMilisecondNTZType",
-    "TimestampSecondNTZType",
-    "TimeType",
-    "TimeNTZType",
+    "DayTimeIntervalType",
     "DecimalType",
     "DoubleType",
     "FloatType",
-    "ByteType",
-    "UnsignedByteType",
-    "ShortType",
-    "UnsignedShortType",
+    "HugeIntegerType",
     "IntegerType",
-    "UnsignedIntegerType",
     "LongType",
-    "UnsignedLongType",
-    "HugeIntegerType",
-    "DayTimeIntervalType",
-    "Row",
-    "ArrayType",
     "MapType",
+    "NullType",
+    "Row",
+    "ShortType",
+    "StringType",
     "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):
+    def __init__(self, duckdb_type: DuckDBPyType) -> None:  # noqa: D107
         self.duckdb_type = duckdb_type
 
-    def __repr__(self) -> str:
+    def __repr__(self) -> str:  # noqa: D105
         return self.__class__.__name__ + "()"
 
-    def __hash__(self) -> int:
+    def __hash__(self) -> int:  # noqa: D105
         return hash(str(self))
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:  # noqa: D105
         return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 
-    def __ne__(self, other: Any) -> bool:
+    def __ne__(self, other: object) -> bool:  # noqa: D105
         return not self.__eq__(other)
 
     @classmethod
-    def typeName(cls) -> str:
+    def typeName(cls) -> str:  # noqa: D102
         return cls.__name__[:-4].lower()
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return self.typeName()
 
-    def jsonValue(self) -> Union[str, Dict[str, Any]]:
+    def jsonValue(self) -> Union[str, dict[str, Any]]:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def json(self) -> str:
+    def json(self) -> str:  # noqa: D102
         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:
-        """
-        Converts a Python object into an internal SQL object.
-        """
+    def toInternal(self, obj: Any) -> Any:  # noqa: ANN401
+        """Converts a Python object into an internal SQL object."""
         return obj
 
-    def fromInternal(self, obj: Any) -> Any:
-        """
-        Converts an internal SQL object into a native Python object.
-        """
+    def fromInternal(self, obj: Any) -> Any:  # noqa: ANN401
+        """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(DataTypeSingleton, cls).__call__()  # type: ignore[misc, attr-defined]
+            cls._instances[cls] = super().__call__()  # type: ignore[misc, attr-defined]
         return cls._instances[cls]  # type: ignore[attr-defined]
 
 
@@ -137,17 +133,18 @@ class NullType(DataType, metaclass=DataTypeSingleton):
     The data type representing None, used for the types that cannot be inferred.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("NULL"))
 
     @classmethod
-    def typeName(cls) -> str:
+    def typeName(cls) -> str:  # noqa: D102
         return "void"
 
 
 class AtomicType(DataType):
     """An internal type used to represent everything that is not
-    null, UDTs, arrays, structs, and maps."""
+    null, UDTs, arrays, structs, and maps.
+    """  # noqa: D205
 
 
 class NumericType(AtomicType):
@@ -165,54 +162,54 @@ class FractionalType(NumericType):
 class StringType(AtomicType, metaclass=DataTypeSingleton):
     """String data type."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("VARCHAR"))
 
 
 class BitstringType(AtomicType, metaclass=DataTypeSingleton):
     """Bitstring data type."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("BIT"))
 
 
 class UUIDType(AtomicType, metaclass=DataTypeSingleton):
     """UUID data type."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("UUID"))
 
 
 class BinaryType(AtomicType, metaclass=DataTypeSingleton):
     """Binary (byte array) data type."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("BLOB"))
 
 
 class BooleanType(AtomicType, metaclass=DataTypeSingleton):
     """Boolean data type."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("BOOLEAN"))
 
 
 class DateType(AtomicType, metaclass=DataTypeSingleton):
     """Date (datetime.date) data type."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("DATE"))
 
     EPOCH_ORDINAL = datetime.datetime(1970, 1, 1).toordinal()
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return True
 
-    def toInternal(self, d: datetime.date) -> int:
+    def toInternal(self, d: datetime.date) -> int:  # noqa: D102
         if d is not None:
             return d.toordinal() - self.EPOCH_ORDINAL
 
-    def fromInternal(self, v: int) -> datetime.date:
+    def fromInternal(self, v: int) -> datetime.date:  # noqa: D102
         if v is not None:
             return datetime.date.fromordinal(v + self.EPOCH_ORDINAL)
 
@@ -220,22 +217,22 @@ class DateType(AtomicType, metaclass=DataTypeSingleton):
 class TimestampType(AtomicType, metaclass=DataTypeSingleton):
     """Timestamp (datetime.datetime) data type."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("TIMESTAMPTZ"))
 
     @classmethod
-    def typeName(cls) -> str:
+    def typeName(cls) -> str:  # noqa: D102
         return "timestamptz"
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return True
 
-    def toInternal(self, dt: datetime.datetime) -> int:
+    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
         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:
+    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
         if ts is not None:
             # using int to avoid precision loss in float
             return datetime.datetime.fromtimestamp(ts // 1000000).replace(microsecond=ts % 1000000)
@@ -244,22 +241,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):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("TIMESTAMP"))
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return True
 
     @classmethod
-    def typeName(cls) -> str:
+    def typeName(cls) -> str:  # noqa: D102
         return "timestamp"
 
-    def toInternal(self, dt: datetime.datetime) -> int:
+    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
         if dt is not None:
             seconds = calendar.timegm(dt.timetuple())
             return int(seconds) * 1000000 + dt.microsecond
 
-    def fromInternal(self, ts: int) -> datetime.datetime:
+    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
         if ts is not None:
             # using int to avoid precision loss in float
             return datetime.datetime.utcfromtimestamp(ts // 1000000).replace(microsecond=ts % 1000000)
@@ -268,60 +265,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):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("TIMESTAMP_S"))
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return True
 
     @classmethod
-    def typeName(cls) -> str:
+    def typeName(cls) -> str:  # noqa: D102
         return "timestamp_s"
 
-    def toInternal(self, dt: datetime.datetime) -> int:
+    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def fromInternal(self, ts: int) -> datetime.datetime:
+    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
         raise ContributionsAcceptedError
 
 
 class TimestampMilisecondNTZType(AtomicType, metaclass=DataTypeSingleton):
     """Timestamp (datetime.datetime) data type without timezone information with milisecond precision."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("TIMESTAMP_MS"))
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return True
 
     @classmethod
-    def typeName(cls) -> str:
+    def typeName(cls) -> str:  # noqa: D102
         return "timestamp_ms"
 
-    def toInternal(self, dt: datetime.datetime) -> int:
+    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def fromInternal(self, ts: int) -> datetime.datetime:
+    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
         raise ContributionsAcceptedError
 
 
 class TimestampNanosecondNTZType(AtomicType, metaclass=DataTypeSingleton):
     """Timestamp (datetime.datetime) data type without timezone information with nanosecond precision."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("TIMESTAMP_NS"))
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return True
 
     @classmethod
-    def typeName(cls) -> str:
+    def typeName(cls) -> str:  # noqa: D102
         return "timestamp_ns"
 
-    def toInternal(self, dt: datetime.datetime) -> int:
+    def toInternal(self, dt: datetime.datetime) -> int:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def fromInternal(self, ts: int) -> datetime.datetime:
+    def fromInternal(self, ts: int) -> datetime.datetime:  # noqa: D102
         raise ContributionsAcceptedError
 
 
@@ -345,90 +342,90 @@ class DecimalType(FractionalType):
         the number of digits on right side of dot. (default: 0)
     """
 
-    def __init__(self, precision: int = 10, scale: int = 0):
+    def __init__(self, precision: int = 10, scale: int = 0) -> None:  # noqa: D107
         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:
-        return "decimal(%d,%d)" % (self.precision, self.scale)
+    def simpleString(self) -> str:  # noqa: D102
+        return f"decimal({int(self.precision):d},{int(self.scale):d})"
 
-    def __repr__(self) -> str:
-        return "DecimalType(%d,%d)" % (self.precision, self.scale)
+    def __repr__(self) -> str:  # noqa: D105
+        return f"DecimalType({int(self.precision):d},{int(self.scale):d})"
 
 
 class DoubleType(FractionalType, metaclass=DataTypeSingleton):
     """Double data type, representing double precision floats."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("DOUBLE"))
 
 
 class FloatType(FractionalType, metaclass=DataTypeSingleton):
     """Float data type, representing single precision floats."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("FLOAT"))
 
 
 class ByteType(IntegralType):
     """Byte data type, i.e. a signed integer in a single byte."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("TINYINT"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "tinyint"
 
 
 class UnsignedByteType(IntegralType):
     """Unsigned byte data type, i.e. a unsigned integer in a single byte."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("UTINYINT"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "utinyint"
 
 
 class ShortType(IntegralType):
     """Short data type, i.e. a signed 16-bit integer."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("SMALLINT"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "smallint"
 
 
 class UnsignedShortType(IntegralType):
     """Unsigned short data type, i.e. a unsigned 16-bit integer."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("USMALLINT"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "usmallint"
 
 
 class IntegerType(IntegralType):
     """Int data type, i.e. a signed 32-bit integer."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("INTEGER"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "integer"
 
 
 class UnsignedIntegerType(IntegralType):
     """Unsigned int data type, i.e. a unsigned 32-bit integer."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("UINTEGER"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "uinteger"
 
 
@@ -439,10 +436,10 @@ class LongType(IntegralType):
     please use :class:`DecimalType`.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("BIGINT"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "bigint"
 
 
@@ -453,44 +450,58 @@ class UnsignedLongType(IntegralType):
     please use :class:`HugeIntegerType`.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("UBIGINT"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "ubigint"
 
 
 class HugeIntegerType(IntegralType):
     """Huge integer data type, i.e. a signed 128-bit integer.
 
-    If the values are beyond the range of [-170141183460469231731687303715884105727, 170141183460469231731687303715884105727],
-    please use :class:`DecimalType`.
+    If the values are beyond the range of [-170141183460469231731687303715884105728,
+    170141183460469231731687303715884105727], please use :class:`DecimalType`.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("HUGEINT"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "hugeint"
 
 
+class UnsignedHugeIntegerType(IntegralType):
+    """Unsigned huge integer data type, i.e. a unsigned 128-bit integer.
+
+    If the values are beyond the range of [0, 340282366920938463463374607431768211455],
+    please use :class:`DecimalType`.
+    """
+
+    def __init__(self) -> None:  # noqa: D107
+        super().__init__(DuckDBPyType("UHUGEINT"))
+
+    def simpleString(self) -> str:  # noqa: D102
+        return "uhugeint"
+
+
 class TimeType(IntegralType):
     """Time (datetime.time) data type."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("TIMETZ"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "timetz"
 
 
 class TimeNTZType(IntegralType):
     """Time (datetime.time) data type without timezone information."""
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("TIME"))
 
-    def simpleString(self) -> str:
+    def simpleString(self) -> str:  # noqa: D102
         return "time"
 
 
@@ -502,16 +513,18 @@ class DayTimeIntervalType(AtomicType):
     MINUTE = 2
     SECOND = 3
 
-    _fields = {
-        DAY: "day",
-        HOUR: "hour",
-        MINUTE: "minute",
-        SECOND: "second",
-    }
+    _fields: Mapping[str, int] = MappingProxyType(
+        {
+            DAY: "day",
+            HOUR: "hour",
+            MINUTE: "minute",
+            SECOND: "second",
+        }
+    )
 
-    _inverted_fields = dict(zip(_fields.values(), _fields.keys()))
+    _inverted_fields: Mapping[int, str] = MappingProxyType(dict(zip(_fields.values(), _fields.keys())))
 
-    def __init__(self, startField: Optional[int] = None, endField: Optional[int] = None):
+    def __init__(self, startField: Optional[int] = None, endField: Optional[int] = None) -> None:  # noqa: D107
         super().__init__(DuckDBPyType("INTERVAL"))
         if startField is None and endField is None:
             # Default matched to scala side.
@@ -521,33 +534,34 @@ class DayTimeIntervalType(AtomicType):
             endField = startField
 
         fields = DayTimeIntervalType._fields
-        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)
+        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)
 
     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 "interval %s" % start_field_name
+            return f"interval {start_field_name}"
         else:
-            return "interval %s to %s" % (start_field_name, end_field_name)
+            return f"interval {start_field_name} to {end_field_name}"
 
     simpleString = _str_repr
 
-    def __repr__(self) -> str:
-        return "%s(%d, %d)" % (type(self).__name__, self.startField, self.endField)
+    def __repr__(self) -> str:  # noqa: D105
+        return f"{type(self).__name__}({int(self.startField):d}, {int(self.endField):d})"
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return True
 
-    def toInternal(self, dt: datetime.timedelta) -> Optional[int]:
+    def toInternal(self, dt: datetime.timedelta) -> Optional[int]:  # noqa: D102
         if dt is not None:
             return (math.floor(dt.total_seconds()) * 1000000) + dt.microseconds
 
-    def fromInternal(self, micros: int) -> Optional[datetime.timedelta]:
+    def fromInternal(self, micros: int) -> Optional[datetime.timedelta]:  # noqa: D102
         if micros is not None:
             return datetime.timedelta(microseconds=micros)
 
@@ -562,7 +576,7 @@ class ArrayType(DataType):
     containsNull : bool, optional
         whether the array can contain null (None) values.
 
-    Examples
+    Examples:
     --------
     >>> ArrayType(StringType()) == ArrayType(StringType(), True)
     True
@@ -570,30 +584,27 @@ class ArrayType(DataType):
     False
     """
 
-    def __init__(self, elementType: DataType, containsNull: bool = True):
+    def __init__(self, elementType: DataType, containsNull: bool = True) -> None:  # noqa: D107
         super().__init__(duckdb.list_type(elementType.duckdb_type))
-        assert isinstance(elementType, DataType), "elementType %s should be an instance of %s" % (
-            elementType,
-            DataType,
-        )
+        assert isinstance(elementType, DataType), f"elementType {elementType} should be an instance of {DataType}"
         self.elementType = elementType
         self.containsNull = containsNull
 
-    def simpleString(self) -> str:
-        return "array<%s>" % self.elementType.simpleString()
+    def simpleString(self) -> str:  # noqa: D102
+        return f"array<{self.elementType.simpleString()}>"
 
-    def __repr__(self) -> str:
-        return "ArrayType(%s, %s)" % (self.elementType, str(self.containsNull))
+    def __repr__(self) -> str:  # noqa: D105
+        return f"ArrayType({self.elementType}, {self.containsNull!s})"
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return self.elementType.needConversion()
 
-    def toInternal(self, obj: List[Optional[T]]) -> List[Optional[T]]:
+    def toInternal(self, obj: list[Optional[T]]) -> list[Optional[T]]:  # noqa: D102
         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]]:
+    def fromInternal(self, obj: list[Optional[T]]) -> list[Optional[T]]:  # noqa: D102
         if not self.needConversion():
             return obj
         return obj and [self.elementType.fromInternal(v) for v in obj]
@@ -611,59 +622,44 @@ 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):
+    def __init__(self, keyType: DataType, valueType: DataType, valueContainsNull: bool = True) -> None:  # noqa: D107
         super().__init__(duckdb.map_type(keyType.duckdb_type, valueType.duckdb_type))
-        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,
-        )
+        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}"
         self.keyType = keyType
         self.valueType = valueType
         self.valueContainsNull = valueContainsNull
 
-    def simpleString(self) -> str:
-        return "map<%s,%s>" % (
-            self.keyType.simpleString(),
-            self.valueType.simpleString(),
-        )
+    def simpleString(self) -> str:  # noqa: D102
+        return f"map<{self.keyType.simpleString()},{self.valueType.simpleString()}>"
 
-    def __repr__(self) -> str:
-        return "MapType(%s, %s, %s)" % (
-            self.keyType,
-            self.valueType,
-            str(self.valueContainsNull),
-        )
+    def __repr__(self) -> str:  # noqa: D105
+        return f"MapType({self.keyType}, {self.valueType}, {self.valueContainsNull!s})"
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return self.keyType.needConversion() or self.valueType.needConversion()
 
-    def toInternal(self, obj: Dict[T, Optional[U]]) -> Dict[T, Optional[U]]:
+    def toInternal(self, obj: dict[T, Optional[U]]) -> dict[T, Optional[U]]:  # noqa: D102
         if not self.needConversion():
             return obj
-        return obj and dict((self.keyType.toInternal(k), self.valueType.toInternal(v)) for k, v in obj.items())
+        return obj and {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]]:
+    def fromInternal(self, obj: dict[T, Optional[U]]) -> dict[T, Optional[U]]:  # noqa: D102
         if not self.needConversion():
             return obj
-        return obj and dict((self.keyType.fromInternal(k), self.valueType.fromInternal(v)) for k, v in obj.items())
+        return obj and {self.keyType.fromInternal(k): self.valueType.fromInternal(v) for k, v in obj.items()}
 
 
 class StructField(DataType):
@@ -680,66 +676,58 @@ 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__(
+    def __init__(  # noqa: D107
         self,
         name: str,
         dataType: DataType,
         nullable: bool = True,
-        metadata: Optional[Dict[str, Any]] = None,
-    ):
+        metadata: Optional[dict[str, Any]] = None,
+    ) -> None:
         super().__init__(dataType.duckdb_type)
-        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)
+        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"
         self.name = name
         self.dataType = dataType
         self.nullable = nullable
         self.metadata = metadata or {}
 
-    def simpleString(self) -> str:
-        return "%s:%s" % (self.name, self.dataType.simpleString())
+    def simpleString(self) -> str:  # noqa: D102
+        return f"{self.name}:{self.dataType.simpleString()}"
 
-    def __repr__(self) -> str:
-        return "StructField('%s', %s, %s)" % (
-            self.name,
-            self.dataType,
-            str(self.nullable),
-        )
+    def __repr__(self) -> str:  # noqa: D105
+        return f"StructField('{self.name}', {self.dataType}, {self.nullable!s})"
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         return self.dataType.needConversion()
 
-    def toInternal(self, obj: T) -> T:
+    def toInternal(self, obj: T) -> T:  # noqa: D102
         return self.dataType.toInternal(obj)
 
-    def fromInternal(self, obj: T) -> T:
+    def fromInternal(self, obj: T) -> T:  # noqa: D102
         return self.dataType.fromInternal(obj)
 
-    def typeName(self) -> str:  # type: ignore[override]
-        raise TypeError("StructField does not have typeName. " "Use typeName on its type explicitly instead.")
+    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)
 
 
 class StructType(DataType):
-    """Struct type, consisting of a list of :class:`StructField`.
+    r"""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"]
@@ -752,16 +740,17 @@ 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):
+    def _update_internal_duckdb_type(self) -> None:
         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):
+    def __init__(self, fields: Optional[list[StructField]] = None) -> None:  # noqa: D107
         if not fields:
             self.fields = []
             self.names = []
@@ -780,23 +769,20 @@ 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":
-        """
-        Construct a :class:`StructType` by adding new elements to it, to define the schema.
+        r"""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.
@@ -815,11 +801,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), \\
@@ -834,13 +820,14 @@ 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:
-                raise ValueError("Must specify DataType if passing name of struct_field to create.")
+                msg = "Must specify DataType if passing name of struct_field to create."
+                raise ValueError(msg)
             else:
                 data_type_f = data_type
             self.fields.append(StructField(field, data_type_f, nullable, metadata))
@@ -852,7 +839,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:
@@ -865,24 +852,30 @@ class StructType(DataType):
             for field in self:
                 if field.name == key:
                     return field
-            raise KeyError("No StructField named {0}".format(key))
+            msg = f"No StructField named {key}"
+            raise KeyError(msg)
         elif isinstance(key, int):
             try:
                 return self.fields[key]
             except IndexError:
-                raise IndexError("StructType index out of range")
+                msg = "StructType index out of range"
+                raise IndexError(msg)  # noqa: B904
         elif isinstance(key, slice):
             return StructType(self.fields[key])
         else:
-            raise TypeError("StructType keys should be strings, integers or slices")
+            msg = "StructType keys should be strings, integers or slices"
+            raise TypeError(msg)
 
-    def simpleString(self) -> str:
-        return "struct<%s>" % (",".join(f.simpleString() for f in self))
+    def simpleString(self) -> str:  # noqa: D102
+        return "struct<{}>".format(",".join(f.simpleString() for f in self))
 
-    def __repr__(self) -> str:
-        return "StructType([%s])" % ", ".join(str(field) for field in self)
+    def __repr__(self) -> str:  # noqa: D105
+        return "StructType([{}])".format(", ".join(str(field) for field in self))
 
-    def extract_types_and_names(self) -> Tuple[List[str], List[str]]:
+    def __contains__(self, item: str) -> bool:  # noqa: D105
+        return item in self.names
+
+    def extract_types_and_names(self) -> tuple[list[str], list[str]]:  # noqa: D102
         names = []
         types = []
         for f in self.fields:
@@ -890,11 +883,10 @@ 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()
@@ -902,11 +894,11 @@ class StructType(DataType):
         """
         return list(self.names)
 
-    def needConversion(self) -> bool:
+    def needConversion(self) -> bool:  # noqa: D102
         # We need convert Row()/namedtuple into tuple()
         return True
 
-    def toInternal(self, obj: Tuple) -> Tuple:
+    def toInternal(self, obj: tuple) -> tuple:  # noqa: D102
         if obj is None:
             return
 
@@ -926,7 +918,8 @@ class StructType(DataType):
                     for n, f, c in zip(self.names, self.fields, self._needConversion)
                 )
             else:
-                raise ValueError("Unexpected tuple %r with StructType" % obj)
+                msg = f"Unexpected tuple {obj!r} with StructType"
+                raise ValueError(msg)
         else:
             if isinstance(obj, dict):
                 return tuple(obj.get(n) for n in self.names)
@@ -936,16 +929,17 @@ class StructType(DataType):
                 d = obj.__dict__
                 return tuple(d.get(n) for n in self.names)
             else:
-                raise ValueError("Unexpected tuple %r with StructType" % obj)
+                msg = f"Unexpected tuple {obj!r} with StructType"
+                raise ValueError(msg)
 
-    def fromInternal(self, obj: Tuple) -> "Row":
+    def fromInternal(self, obj: tuple) -> "Row":  # noqa: D102
         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)]
@@ -955,7 +949,7 @@ class StructType(DataType):
 
 
 class UnionType(DataType):
-    def __init__(self):
+    def __init__(self) -> None:
         raise ContributionsAcceptedError
 
 
@@ -965,7 +959,7 @@ class UserDefinedType(DataType):
     .. note:: WARN: Spark Internal Use Only
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         raise ContributionsAcceptedError
 
     @classmethod
@@ -974,24 +968,21 @@ class UserDefinedType(DataType):
 
     @classmethod
     def sqlType(cls) -> DataType:
-        """
-        Underlying SQL storage type for this UDT.
-        """
-        raise NotImplementedError("UDT must implement sqlType().")
+        """Underlying SQL storage type for this UDT."""
+        msg = "UDT must implement sqlType()."
+        raise NotImplementedError(msg)
 
     @classmethod
     def module(cls) -> str:
-        """
-        The Python module of the UDT.
-        """
-        raise NotImplementedError("UDT must implement module().")
+        """The Python module of the UDT."""
+        msg = "UDT must implement module()."
+        raise NotImplementedError(msg)
 
     @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:
@@ -999,42 +990,38 @@ 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:
+    def toInternal(self, obj: Any) -> Any:  # noqa: ANN401
         if obj is not None:
             return self._cachedSqlType().toInternal(self.serialize(obj))
 
-    def fromInternal(self, obj: Any) -> Any:
+    def fromInternal(self, obj: Any) -> Any:  # noqa: ANN401
         v = self._cachedSqlType().fromInternal(obj)
         if v is not None:
             return self.deserialize(v)
 
-    def serialize(self, obj: Any) -> Any:
-        """
-        Converts a user-type object into a SQL datum.
-        """
-        raise NotImplementedError("UDT must implement toInternal().")
+    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 deserialize(self, datum: Any) -> Any:
-        """
-        Converts a SQL datum into a user-type object.
-        """
-        raise NotImplementedError("UDT must implement fromInternal().")
+    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 simpleString(self) -> str:
         return "udt"
 
-    def __eq__(self, other: Any) -> bool:
-        return type(self) == type(other)
+    def __eq__(self, other: object) -> bool:
+        return type(self) is type(other)
 
 
-_atomic_types: List[Type[DataType]] = [
+_atomic_types: list[type[DataType]] = [
     StringType,
     BinaryType,
     BooleanType,
@@ -1050,33 +1037,28 @@ _atomic_types: List[Type[DataType]] = [
     TimestampNTZType,
     NullType,
 ]
-_all_atomic_types: Dict[str, Type[DataType]] = dict((t.typeName(), t) for t in _atomic_types)
+_all_atomic_types: dict[str, type[DataType]] = {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]]] = dict(
-    (v.typeName(), v) for v in _complex_types
-)
+_all_complex_types: dict[str, type[Union[ArrayType, MapType, StructType]]] = {v.typeName(): v for v in _complex_types}
 
-import re
 
 _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``)
@@ -1093,18 +1075,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
@@ -1113,9 +1095,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)
@@ -1127,19 +1109,18 @@ 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":
-        ...
+    def __new__(cls, **kwargs: Any) -> "Row": ...  # noqa: ANN401
 
-    def __new__(cls, *args: Optional[str], **kwargs: Optional[Any]) -> "Row":
+    def __new__(cls, *args: Optional[str], **kwargs: Optional[Any]) -> "Row":  # noqa: D102
         if args and kwargs:
-            raise ValueError("Can not use both args " "and kwargs to create Row")
+            msg = "Can not use both args and kwargs to create Row"
+            raise ValueError(msg)
         if kwargs:
             # create row objects
             row = tuple.__new__(cls, list(kwargs.values()))
@@ -1149,16 +1130,15 @@ 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,
@@ -1166,28 +1146,29 @@ 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__"):
-            raise TypeError("Cannot convert a Row class into dict")
+            msg = "Cannot convert a Row class into dict"
+            raise TypeError(msg)
 
         if recursive:
 
-            def conv(obj: Any) -> Any:
+            def conv(obj: Union[Row, list, dict, object]) -> Union[list, dict, object]:
                 if isinstance(obj, Row):
                     return obj.asDict(True)
                 elif isinstance(obj, list):
                     return [conv(o) for o in obj]
                 elif isinstance(obj, dict):
-                    return dict((k, conv(v)) for k, v in obj.items())
+                    return {k: conv(v) for k, v in obj.items()}
                 else:
                     return obj
 
@@ -1195,35 +1176,34 @@ class Row(tuple):
         else:
             return dict(zip(self.__fields__, self))
 
-    def __contains__(self, item: Any) -> bool:
+    def __contains__(self, item: Any) -> bool:  # noqa: D105, ANN401
         if hasattr(self, "__fields__"):
             return item in self.__fields__
         else:
-            return super(Row, self).__contains__(item)
+            return super().__contains__(item)
 
     # let object acts like class
-    def __call__(self, *args: Any) -> "Row":
-        """create new Row object"""
+    def __call__(self, *args: Any) -> "Row":  # noqa: ANN401
+        """Create new Row object."""
         if len(args) > len(self):
-            raise ValueError(
-                "Can not create Row with fields %s, expected %d values " "but got %s" % (self, len(self), args)
-            )
+            msg = f"Can not create Row with fields {self}, expected {len(self):d} values but got {args}"
+            raise ValueError(msg)
         return _create_row(self, args)
 
-    def __getitem__(self, item: Any) -> Any:
+    def __getitem__(self, item: Any) -> Any:  # noqa: D105, ANN401
         if isinstance(item, (int, slice)):
-            return super(Row, self).__getitem__(item)
+            return super().__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(Row, self).__getitem__(idx)
+            return super().__getitem__(idx)
         except IndexError:
-            raise KeyError(item)
+            raise KeyError(item)  # noqa: B904
         except ValueError:
-            raise ValueError(item)
+            raise ValueError(item)  # noqa: B904
 
-    def __getattr__(self, item: str) -> Any:
+    def __getattr__(self, item: str) -> Any:  # noqa: D105, ANN401
         if item.startswith("__"):
             raise AttributeError(item)
         try:
@@ -1232,18 +1212,19 @@ class Row(tuple):
             idx = self.__fields__.index(item)
             return self[idx]
         except IndexError:
-            raise AttributeError(item)
+            raise AttributeError(item)  # noqa: B904
         except ValueError:
-            raise AttributeError(item)
+            raise AttributeError(item)  # noqa: B904
 
-    def __setattr__(self, key: Any, value: Any) -> None:
+    def __setattr__(self, key: Any, value: Any) -> None:  # noqa: D105, ANN401
         if key != "__fields__":
-            raise RuntimeError("Row is read-only")
+            msg = "Row is read-only"
+            raise RuntimeError(msg)
         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)))
@@ -1253,6 +1234,6 @@ class Row(tuple):
     def __repr__(self) -> str:
         """Printable representation of Row used in Python REPL."""
         if hasattr(self, "__fields__"):
-            return "Row(%s)" % ", ".join("%s=%r" % (k, v) for k, v in zip(self.__fields__, tuple(self)))
+            return "Row({})".format(", ".join(f"{k}={v!r}" for k, v in zip(self.__fields__, tuple(self))))
         else:
-            return "<Row(%s)>" % ", ".join("%r" % field for field in self)
+            return "<Row({})>".format(", ".join(f"{field!r}" for field in self))