duckdb 1.5.0.dev37__cp314-cp314-win_amd64.whl → 1.5.0.dev94__cp314-cp314-win_amd64.whl

duckdb/experimental/spark/context.py

@@ -1,42 +1,42 @@
-from typing import Optional
+from typing import Optional  # noqa: D100
+
 import duckdb
 from duckdb import DuckDBPyConnection
-
-from duckdb.experimental.spark.exception import ContributionsAcceptedError
 from duckdb.experimental.spark.conf import SparkConf
+from duckdb.experimental.spark.exception import ContributionsAcceptedError
 
 
-class SparkContext:
-    def __init__(self, master: str):
-        self._connection = duckdb.connect(':memory:')
+class SparkContext:  # noqa: D101
+    def __init__(self, master: str) -> None:  # noqa: D107
+        self._connection = duckdb.connect(":memory:")
         # This aligns the null ordering with Spark.
         self._connection.execute("set default_null_order='nulls_first_on_asc_last_on_desc'")
 
     @property
-    def connection(self) -> DuckDBPyConnection:
+    def connection(self) -> DuckDBPyConnection:  # noqa: D102
         return self._connection
 
-    def stop(self) -> None:
+    def stop(self) -> None:  # noqa: D102
         self._connection.close()
 
     @classmethod
-    def getOrCreate(cls, conf: Optional[SparkConf] = None) -> "SparkContext":
+    def getOrCreate(cls, conf: Optional[SparkConf] = None) -> "SparkContext":  # noqa: D102
         raise ContributionsAcceptedError
 
     @classmethod
-    def setSystemProperty(cls, key: str, value: str) -> None:
+    def setSystemProperty(cls, key: str, value: str) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
     @property
-    def applicationId(self) -> str:
+    def applicationId(self) -> str:  # noqa: D102
         raise ContributionsAcceptedError
 
     @property
-    def defaultMinPartitions(self) -> int:
+    def defaultMinPartitions(self) -> int:  # noqa: D102
         raise ContributionsAcceptedError
 
     @property
-    def defaultParallelism(self) -> int:
+    def defaultParallelism(self) -> int:  # noqa: D102
         raise ContributionsAcceptedError
 
     # @property
@@ -44,33 +44,35 @@ class SparkContext:
     # 	raise ContributionsAcceptedError
 
     @property
-    def startTime(self) -> str:
+    def startTime(self) -> str:  # noqa: D102
         raise ContributionsAcceptedError
 
     @property
-    def uiWebUrl(self) -> str:
+    def uiWebUrl(self) -> str:  # noqa: D102
         raise ContributionsAcceptedError
 
     @property
-    def version(self) -> str:
+    def version(self) -> str:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def __repr__(self) -> str:
+    def __repr__(self) -> str:  # noqa: D105
         raise ContributionsAcceptedError
 
-    # def accumulator(self, value: ~T, accum_param: Optional[ForwardRef('AccumulatorParam[T]')] = None) -> 'Accumulator[T]':
+    # def accumulator(self, value: ~T, accum_param: Optional[ForwardRef('AccumulatorParam[T]')] = None
+    #     ) -> 'Accumulator[T]':
     # 	pass
 
-    def addArchive(self, path: str) -> None:
+    def addArchive(self, path: str) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def addFile(self, path: str, recursive: bool = False) -> None:
+    def addFile(self, path: str, recursive: bool = False) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def addPyFile(self, path: str) -> None:
+    def addPyFile(self, path: str) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    # def binaryFiles(self, path: str, minPartitions: Optional[int] = None) -> duckdb.experimental.spark.rdd.RDD[typing.Tuple[str, bytes]]:
+    # def binaryFiles(self, path: str, minPartitions: Optional[int] = None
+    #     ) -> duckdb.experimental.spark.rdd.RDD[typing.Tuple[str, bytes]]:
     # 	pass
 
     # def binaryRecords(self, path: str, recordLength: int) -> duckdb.experimental.spark.rdd.RDD[bytes]:
@@ -79,37 +81,45 @@ class SparkContext:
     # def broadcast(self, value: ~T) -> 'Broadcast[T]':
     # 	pass
 
-    def cancelAllJobs(self) -> None:
+    def cancelAllJobs(self) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def cancelJobGroup(self, groupId: str) -> None:
+    def cancelJobGroup(self, groupId: str) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def dump_profiles(self, path: str) -> None:
+    def dump_profiles(self, path: str) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
     # def emptyRDD(self) -> duckdb.experimental.spark.rdd.RDD[typing.Any]:
     # 	pass
 
-    def getCheckpointDir(self) -> Optional[str]:
+    def getCheckpointDir(self) -> Optional[str]:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def getConf(self) -> SparkConf:
+    def getConf(self) -> SparkConf:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def getLocalProperty(self, key: str) -> Optional[str]:
+    def getLocalProperty(self, key: str) -> Optional[str]:  # noqa: D102
         raise ContributionsAcceptedError
 
-    # def hadoopFile(self, path: str, inputFormatClass: str, keyClass: str, valueClass: str, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
+    # def hadoopFile(self, path: str, inputFormatClass: str, keyClass: str, valueClass: str,
+    #     keyConverter: Optional[str] = None, valueConverter: Optional[str] = None,
+    #     conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
     # 	pass
 
-    # def hadoopRDD(self, inputFormatClass: str, keyClass: str, valueClass: str, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
+    # def hadoopRDD(self, inputFormatClass: str, keyClass: str, valueClass: str, keyConverter: Optional[str] = None,
+    #     valueConverter: Optional[str] = None, conf: Optional[Dict[str, str]] = None, batchSize: int = 0
+    #     ) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
     # 	pass
 
-    # def newAPIHadoopFile(self, path: str, inputFormatClass: str, keyClass: str, valueClass: str, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
+    # def newAPIHadoopFile(self, path: str, inputFormatClass: str, keyClass: str, valueClass: str,
+    #     keyConverter: Optional[str] = None, valueConverter: Optional[str] = None,
+    #     conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
     # 	pass
 
-    # def newAPIHadoopRDD(self, inputFormatClass: str, keyClass: str, valueClass: str, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
+    # def newAPIHadoopRDD(self, inputFormatClass: str, keyClass: str, valueClass: str,
+    #     keyConverter: Optional[str] = None, valueConverter: Optional[str] = None,
+    #     conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
     # 	pass
 
     # def parallelize(self, c: Iterable[~T], numSlices: Optional[int] = None) -> pyspark.rdd.RDD[~T]:
@@ -118,46 +128,52 @@ class SparkContext:
     # def pickleFile(self, name: str, minPartitions: Optional[int] = None) -> pyspark.rdd.RDD[typing.Any]:
     # 	pass
 
-    # def range(self, start: int, end: Optional[int] = None, step: int = 1, numSlices: Optional[int] = None) -> pyspark.rdd.RDD[int]:
+    # def range(self, start: int, end: Optional[int] = None, step: int = 1, numSlices: Optional[int] = None
+    #     ) -> pyspark.rdd.RDD[int]:
     # 	pass
 
-    # def runJob(self, rdd: pyspark.rdd.RDD[~T], partitionFunc: Callable[[Iterable[~T]], Iterable[~U]], partitions: Optional[Sequence[int]] = None, allowLocal: bool = False) -> List[~U]:
+    # def runJob(self, rdd: pyspark.rdd.RDD[~T], partitionFunc: Callable[[Iterable[~T]], Iterable[~U]],
+    #     partitions: Optional[Sequence[int]] = None, allowLocal: bool = False) -> List[~U]:
     # 	pass
 
-    # def sequenceFile(self, path: str, keyClass: Optional[str] = None, valueClass: Optional[str] = None, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, minSplits: Optional[int] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
+    # def sequenceFile(self, path: str, keyClass: Optional[str] = None, valueClass: Optional[str] = None,
+    #     keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, minSplits: Optional[int] = None,
+    #     batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
     # 	pass
 
-    def setCheckpointDir(self, dirName: str) -> None:
+    def setCheckpointDir(self, dirName: str) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def setJobDescription(self, value: str) -> None:
+    def setJobDescription(self, value: str) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def setJobGroup(self, groupId: str, description: str, interruptOnCancel: bool = False) -> None:
+    def setJobGroup(self, groupId: str, description: str, interruptOnCancel: bool = False) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def setLocalProperty(self, key: str, value: str) -> None:
+    def setLocalProperty(self, key: str, value: str) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def setLogLevel(self, logLevel: str) -> None:
+    def setLogLevel(self, logLevel: str) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def show_profiles(self) -> None:
+    def show_profiles(self) -> None:  # noqa: D102
         raise ContributionsAcceptedError
 
-    def sparkUser(self) -> str:
+    def sparkUser(self) -> str:  # noqa: D102
         raise ContributionsAcceptedError
 
     # def statusTracker(self) -> duckdb.experimental.spark.status.StatusTracker:
     # 	raise ContributionsAcceptedError
 
-    # def textFile(self, name: str, minPartitions: Optional[int] = None, use_unicode: bool = True) -> pyspark.rdd.RDD[str]:
+    # def textFile(self, name: str, minPartitions: Optional[int] = None, use_unicode: bool = True
+    #     ) -> pyspark.rdd.RDD[str]:
     # 	pass
 
     # def union(self, rdds: List[pyspark.rdd.RDD[~T]]) -> pyspark.rdd.RDD[~T]:
     # 	pass
 
-    # def wholeTextFiles(self, path: str, minPartitions: Optional[int] = None, use_unicode: bool = True) -> pyspark.rdd.RDD[typing.Tuple[str, str]]:
+    # def wholeTextFiles(self, path: str, minPartitions: Optional[int] = None, use_unicode: bool = True
+    #     ) -> pyspark.rdd.RDD[typing.Tuple[str, str]]:
     # 	pass
 
 

duckdb/experimental/spark/errors/__init__.py

@@ -15,58 +15,56 @@
 # limitations under the License.
 #
 
-"""
-PySpark exceptions.
-"""
-from .exceptions.base import (  # noqa: F401
-    PySparkException,
+"""PySpark exceptions."""
+
+from .exceptions.base import (
     AnalysisException,
-    TempTableAlreadyExistsException,
-    ParseException,
-    IllegalArgumentException,
     ArithmeticException,
-    UnsupportedOperationException,
     ArrayIndexOutOfBoundsException,
     DateTimeException,
+    IllegalArgumentException,
     NumberFormatException,
-    StreamingQueryException,
-    QueryExecutionException,
+    ParseException,
+    PySparkAssertionError,
+    PySparkAttributeError,
+    PySparkException,
+    PySparkIndexError,
+    PySparkNotImplementedError,
+    PySparkRuntimeError,
+    PySparkTypeError,
+    PySparkValueError,
     PythonException,
-    UnknownException,
+    QueryExecutionException,
     SparkRuntimeException,
     SparkUpgradeException,
-    PySparkTypeError,
-    PySparkValueError,
-    PySparkIndexError,
-    PySparkAttributeError,
-    PySparkRuntimeError,
-    PySparkAssertionError,
-    PySparkNotImplementedError,
+    StreamingQueryException,
+    TempTableAlreadyExistsException,
+    UnknownException,
+    UnsupportedOperationException,
 )
 
-
 __all__ = [
-    "PySparkException",
     "AnalysisException",
-    "TempTableAlreadyExistsException",
-    "ParseException",
-    "IllegalArgumentException",
     "ArithmeticException",
-    "UnsupportedOperationException",
     "ArrayIndexOutOfBoundsException",
     "DateTimeException",
+    "IllegalArgumentException",
     "NumberFormatException",
-    "StreamingQueryException",
-    "QueryExecutionException",
+    "ParseException",
+    "PySparkAssertionError",
+    "PySparkAttributeError",
+    "PySparkException",
+    "PySparkIndexError",
+    "PySparkNotImplementedError",
+    "PySparkRuntimeError",
+    "PySparkTypeError",
+    "PySparkValueError",
     "PythonException",
-    "UnknownException",
+    "QueryExecutionException",
     "SparkRuntimeException",
     "SparkUpgradeException",
-    "PySparkTypeError",
-    "PySparkValueError",
-    "PySparkIndexError",
-    "PySparkAttributeError",
-    "PySparkRuntimeError",
-    "PySparkAssertionError",
-    "PySparkNotImplementedError",
+    "StreamingQueryException",
+    "TempTableAlreadyExistsException",
+    "UnknownException",
+    "UnsupportedOperationException",
 ]

duckdb/experimental/spark/errors/error_classes.py

@@ -1,4 +1,4 @@
-#
+# ruff: noqa: D100, E501
 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with
 # this work for additional information regarding copyright ownership.

duckdb/experimental/spark/errors/exceptions/__init__.py

@@ -1,4 +1,4 @@
-#
+#  # noqa: D104
 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with
 # this work for additional information regarding copyright ownership.

duckdb/experimental/spark/errors/exceptions/base.py

@@ -1,20 +1,19 @@
-from typing import Dict, Optional, cast
+from typing import Optional, cast  # noqa: D100
 
 from ..utils import ErrorClassesReader
 
+
 class PySparkException(Exception):
-    """
-    Base Exception for handling errors generated from PySpark.
-    """
+    """Base Exception for handling errors generated from PySpark."""
 
-    def __init__(
+    def __init__(  # noqa: D107
         self,
         message: Optional[str] = None,
         # The error class, decides the message format, must be one of the valid options listed in 'error_classes.py'
         error_class: Optional[str] = None,
         # The dictionary listing the arguments specified in the message (or the error_class)
-        message_parameters: Optional[Dict[str, str]] = None,
-    ):
+        message_parameters: Optional[dict[str, str]] = None,
+    ) -> None:
         # `message` vs `error_class` & `message_parameters` are mutually exclusive.
         assert (message is not None and (error_class is None and message_parameters is None)) or (
             message is None and (error_class is not None and message_parameters is not None)
@@ -24,7 +23,7 @@ class PySparkException(Exception):
 
         if message is None:
             self.message = self.error_reader.get_error_message(
-                cast(str, error_class), cast(Dict[str, str], message_parameters)
+                cast("str", error_class), cast("dict[str, str]", message_parameters)
             )
         else:
             self.message = message
@@ -33,25 +32,23 @@ class PySparkException(Exception):
         self.message_parameters = message_parameters
 
     def getErrorClass(self) -> Optional[str]:
-        """
-        Returns an error class as a string.
+        """Returns an error class as a string.
 
         .. versionadded:: 3.4.0
 
-        See Also
+        See Also:
         --------
         :meth:`PySparkException.getMessageParameters`
         :meth:`PySparkException.getSqlState`
         """
         return self.error_class
 
-    def getMessageParameters(self) -> Optional[Dict[str, str]]:
-        """
-        Returns a message parameters as a dictionary.
+    def getMessageParameters(self) -> Optional[dict[str, str]]:
+        """Returns a message parameters as a dictionary.
 
         .. versionadded:: 3.4.0
 
-        See Also
+        See Also:
         --------
         :meth:`PySparkException.getErrorClass`
         :meth:`PySparkException.getSqlState`
@@ -59,159 +56,113 @@ class PySparkException(Exception):
         return self.message_parameters
 
     def getSqlState(self) -> None:
-        """
-        Returns an SQLSTATE as a string.
+        """Returns an SQLSTATE as a string.
 
         Errors generated in Python have no SQLSTATE, so it always returns None.
 
         .. versionadded:: 3.4.0
 
-        See Also
+        See Also:
         --------
         :meth:`PySparkException.getErrorClass`
         :meth:`PySparkException.getMessageParameters`
         """
         return None
 
-    def __str__(self) -> str:
+    def __str__(self) -> str:  # noqa: D105
         if self.getErrorClass() is not None:
             return f"[{self.getErrorClass()}] {self.message}"
         else:
             return self.message
 
+
 class AnalysisException(PySparkException):
-    """
-    Failed to analyze a SQL query plan.
-    """
+    """Failed to analyze a SQL query plan."""
 
 
 class SessionNotSameException(PySparkException):
-    """
-    Performed the same operation on different SparkSession.
-    """
+    """Performed the same operation on different SparkSession."""
 
 
 class TempTableAlreadyExistsException(AnalysisException):
-    """
-    Failed to create temp view since it is already exists.
-    """
+    """Failed to create temp view since it is already exists."""
 
 
 class ParseException(AnalysisException):
-    """
-    Failed to parse a SQL command.
-    """
+    """Failed to parse a SQL command."""
 
 
 class IllegalArgumentException(PySparkException):
-    """
-    Passed an illegal or inappropriate argument.
-    """
+    """Passed an illegal or inappropriate argument."""
 
 
 class ArithmeticException(PySparkException):
-    """
-    Arithmetic exception thrown from Spark with an error class.
-    """
+    """Arithmetic exception thrown from Spark with an error class."""
 
 
 class UnsupportedOperationException(PySparkException):
-    """
-    Unsupported operation exception thrown from Spark with an error class.
-    """
+    """Unsupported operation exception thrown from Spark with an error class."""
 
 
 class ArrayIndexOutOfBoundsException(PySparkException):
-    """
-    Array index out of bounds exception thrown from Spark with an error class.
-    """
+    """Array index out of bounds exception thrown from Spark with an error class."""
 
 
 class DateTimeException(PySparkException):
-    """
-    Datetime exception thrown from Spark with an error class.
-    """
+    """Datetime exception thrown from Spark with an error class."""
 
 
 class NumberFormatException(IllegalArgumentException):
-    """
-    Number format exception thrown from Spark with an error class.
-    """
+    """Number format exception thrown from Spark with an error class."""
 
 
 class StreamingQueryException(PySparkException):
-    """
-    Exception that stopped a :class:`StreamingQuery`.
-    """
+    """Exception that stopped a :class:`StreamingQuery`."""
 
 
 class QueryExecutionException(PySparkException):
-    """
-    Failed to execute a query.
-    """
+    """Failed to execute a query."""
 
 
 class PythonException(PySparkException):
-    """
-    Exceptions thrown from Python workers.
-    """
+    """Exceptions thrown from Python workers."""
 
 
 class SparkRuntimeException(PySparkException):
-    """
-    Runtime exception thrown from Spark with an error class.
-    """
+    """Runtime exception thrown from Spark with an error class."""
 
 
 class SparkUpgradeException(PySparkException):
-    """
-    Exception thrown because of Spark upgrade.
-    """
+    """Exception thrown because of Spark upgrade."""
 
 
 class UnknownException(PySparkException):
-    """
-    None of the above exceptions.
-    """
+    """None of the above exceptions."""
 
 
 class PySparkValueError(PySparkException, ValueError):
-    """
-    Wrapper class for ValueError to support error classes.
-    """
+    """Wrapper class for ValueError to support error classes."""
 
 
 class PySparkIndexError(PySparkException, IndexError):
-    """
-    Wrapper class for IndexError to support error classes.
-    """
+    """Wrapper class for IndexError to support error classes."""
 
 
 class PySparkTypeError(PySparkException, TypeError):
-    """
-    Wrapper class for TypeError to support error classes.
-    """
+    """Wrapper class for TypeError to support error classes."""
 
 
 class PySparkAttributeError(PySparkException, AttributeError):
-    """
-    Wrapper class for AttributeError to support error classes.
-    """
+    """Wrapper class for AttributeError to support error classes."""
 
 
 class PySparkRuntimeError(PySparkException, RuntimeError):
-    """
-    Wrapper class for RuntimeError to support error classes.
-    """
+    """Wrapper class for RuntimeError to support error classes."""
 
 
 class PySparkAssertionError(PySparkException, AssertionError):
-    """
-    Wrapper class for AssertionError to support error classes.
-    """
+    """Wrapper class for AssertionError to support error classes."""
 
 
 class PySparkNotImplementedError(PySparkException, NotImplementedError):
-    """
-    Wrapper class for NotImplementedError to support error classes.
-    """
+    """Wrapper class for NotImplementedError to support error classes."""

duckdb/experimental/spark/errors/utils.py

@@ -1,4 +1,4 @@
-#
+#  # noqa: D100
 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with
 # this work for additional information regarding copyright ownership.
@@ -16,37 +16,30 @@
 #
 
 import re
-from typing import Dict
 
 from .error_classes import ERROR_CLASSES_MAP
 
 
 class ErrorClassesReader:
-    """
-    A reader to load error information from error_classes.py.
-    """
+    """A reader to load error information from error_classes.py."""
 
-    def __init__(self) -> None:
+    def __init__(self) -> None:  # noqa: D107
         self.error_info_map = ERROR_CLASSES_MAP
 
-    def get_error_message(self, error_class: str, message_parameters: Dict[str, str]) -> str:
-        """
-        Returns the completed error message by applying message parameters to the message template.
-        """
+    def get_error_message(self, error_class: str, message_parameters: dict[str, str]) -> str:
+        """Returns the completed error message by applying message parameters to the message template."""
         message_template = self.get_message_template(error_class)
         # Verify message parameters.
         message_parameters_from_template = re.findall("<([a-zA-Z0-9_-]+)>", message_template)
         assert set(message_parameters_from_template) == set(message_parameters), (
-            f"Undefined error message parameter for error class: {error_class}. "
-            f"Parameters: {message_parameters}"
+            f"Undefined error message parameter for error class: {error_class}. Parameters: {message_parameters}"
         )
         table = str.maketrans("<>", "{}")
 
         return message_template.translate(table).format(**message_parameters)
 
     def get_message_template(self, error_class: str) -> str:
-        """
-        Returns the message template for corresponding error class from error_classes.py.
+        """Returns the message template for corresponding error class from error_classes.py.
 
         For example,
         when given `error_class` is "EXAMPLE_ERROR_CLASS",
@@ -93,7 +86,8 @@ class ErrorClassesReader:
         if main_error_class in self.error_info_map:
             main_error_class_info_map = self.error_info_map[main_error_class]
         else:
-            raise ValueError(f"Cannot find main error class '{main_error_class}'")
+            msg = f"Cannot find main error class '{main_error_class}'"
+            raise ValueError(msg)
 
         main_message_template = "\n".join(main_error_class_info_map["message"])
 
@@ -108,7 +102,8 @@ class ErrorClassesReader:
             if sub_error_class in main_error_class_subclass_info_map:
                 sub_error_class_info_map = main_error_class_subclass_info_map[sub_error_class]
             else:
-                raise ValueError(f"Cannot find sub error class '{sub_error_class}'")
+                msg = f"Cannot find sub error class '{sub_error_class}'"
+                raise ValueError(msg)
 
             sub_message_template = "\n".join(sub_error_class_info_map["message"])
             message_template = main_message_template + " " + sub_message_template

duckdb/experimental/spark/exception.py

@@ -1,14 +1,17 @@
+# ruff: noqa: D100
+from typing import Optional
+
+
 class ContributionsAcceptedError(NotImplementedError):
-    """
-    This method is not planned to be implemented, if you would like to implement this method
+    """This method is not planned to be implemented, if you would like to implement this method
     or show your interest in this method to other members of the community,
-    feel free to open up a PR or a Discussion over on https://github.com/duckdb/duckdb
-    """
+    feel free to open up a PR or a Discussion over on https://github.com/duckdb/duckdb.
+    """  # noqa: D205
 
-    def __init__(self, message=None):
+    def __init__(self, message: Optional[str] = None) -> None:  # noqa: D107
         doc = self.__class__.__doc__
         if message:
-            doc = message + '\n' + doc
+            doc = message + "\n" + doc
         super().__init__(doc)