Data type converter: Remove more methods for mutability

src/crate/client/converter.py

@@ -89,8 +89,11 @@ class DataType(Enum):
     ARRAY = 100
 
 
+ConverterMapping = Dict[DataType, ConverterFunction]
+
+
 # Map data type identifier to converter function.
-_DEFAULT_CONVERTERS: Dict[DataType, ConverterFunction] = {
+_DEFAULT_CONVERTERS: ConverterMapping = {
     DataType.IP: _to_ipaddress,
     DataType.TIMESTAMP_WITH_TZ: _to_datetime,
     DataType.TIMESTAMP_WITHOUT_TZ: _to_datetime,
@@ -100,21 +103,14 @@ class DataType(Enum):
 class Converter:
     def __init__(
         self,
-        mappings: Optional[Dict[DataType, ConverterFunction]] = None,
+        mappings: Optional[ConverterMapping] = None,
         default: ConverterFunction = _to_default,
     ) -> None:
         self._mappings = mappings or {}
         self._default = default
 
-    @property
-    def mappings(self) -> Dict[DataType, ConverterFunction]:
-        return self._mappings
-
     def get(self, type_: DataType) -> ConverterFunction:
-        return self.mappings.get(type_, self._default)
-
-    def set(self, type_: DataType, converter: ConverterFunction) -> None:
-        self.mappings[type_] = converter
+        return self._mappings.get(type_, self._default)
 
     def convert(self, converter_definition: ConverterDefinition, value: Optional[Any]) -> Optional[Any]:
         """
@@ -153,7 +149,11 @@ def col_type_to_converter(self, type_: ColTypesDefinition) -> ConverterDefinitio
 
 
 class DefaultTypeConverter(Converter):
-    def __init__(self) -> None:
-        super(DefaultTypeConverter, self).__init__(
-            mappings=deepcopy(_DEFAULT_CONVERTERS), default=_to_default
+    def __init__(self, more_mappings: Optional[ConverterMapping] = None) -> None:
+        mappings: ConverterMapping = {}
+        mappings.update(deepcopy(_DEFAULT_CONVERTERS))
+        if more_mappings:
+            mappings.update(deepcopy(more_mappings))
+        super().__init__(
+            mappings=mappings, default=_to_default
         )

src/crate/client/cursor.py

@@ -19,9 +19,11 @@
 # with Crate these terms will supersede the license and you may use the
 # software solely pursuant to the terms of the relevant commercial agreement.
 
-from .converter import Converter, DefaultTypeConverter
-from .exceptions import ProgrammingError
 import warnings
+from typing import Optional
+
+from .converter import Converter, DefaultTypeConverter, ConverterMapping
+from .exceptions import ProgrammingError
 
 
 class Cursor(object):
@@ -242,8 +244,8 @@ def _convert_rows(self):
             ]
 
     @staticmethod
-    def get_default_converter() -> Converter:
+    def get_default_converter(mappings: Optional[ConverterMapping] = None) -> Converter:
         """
         Return the standard converter instance.
         """
-        return DefaultTypeConverter()
+        return DefaultTypeConverter(more_mappings=mappings)

src/crate/client/doctests/cursor.txt

@@ -343,8 +343,7 @@ To create a simple converter for converging CrateDB's ``BIT`` type to Python's
 
     >>> from crate.client.converter import Converter, DataType
 
-    >>> converter = Converter()
-    >>> converter.set(DataType.BIT, lambda value: int(value[2:-1], 2))
+    >>> converter = Converter({DataType.BIT: lambda value: int(value[2:-1], 2)})
     >>> cursor = connection.cursor(converter=converter)
 
 Proof that the converter works correctly, ``B\'0110\'`` should be converted to

src/crate/client/test_cursor.py

@@ -57,8 +57,8 @@ def test_execute_with_converter(self):
 
         # Use the set of data type converters from `DefaultTypeConverter`
         # and add another custom converter.
-        converter = Cursor.get_default_converter()
-        converter.set(DataType.BIT, lambda value: value is not None and int(value[2:-1], 2) or None)
+        converter = Cursor.get_default_converter(
+            {DataType.BIT: lambda value: value is not None and int(value[2:-1], 2) or None})
 
         # Create a `Cursor` object with converter.
         c = conn.cursor(converter=converter)