feat(python): Allow creation of dictionary and list types (#445)

This PR adds support for creating dictionary and list types:

```python
import nanoarrow as na
na.list_of(na.int32())
#> Schema(LIST, value_type=Schema(INT32, name='item'))
na.dictionary(na.int32(), na.string())
#> Schema(DICTIONARY, index_type=Schema(INT32), value_type=Schema(STRING), dictionary_ordered=False)
```

Before, creating these types (or associated arrays from buffer) was not
possible. This required some changes to `modify()` to ensure we could
also set `children` and `dictionary` there.

Author: paleolimbot

python/src/nanoarrow/__init__.py

@@ -43,7 +43,7 @@
     Type,
     TimeUnit,
     null,
-    bool,
+    bool_,
     int8,
     uint8,
     int16,
@@ -57,6 +57,10 @@
     float64,
     string,
     large_string,
+    list_,
+    large_list,
+    fixed_size_list,
+    dictionary,
     binary,
     large_binary,
     fixed_size_binary,
@@ -88,7 +92,7 @@
     "allocate_c_array_stream",
     "allocate_c_schema",
     "binary",
-    "bool",
+    "bool_",
     "c_array",
     "c_array_from_buffers",
     "c_array_stream",
@@ -102,9 +106,11 @@
     "date64",
     "decimal128",
     "decimal256",
+    "dictionary",
     "duration",
     "extension_type",
     "fixed_size_binary",
+    "fixed_size_list",
     "float16",
     "float32",
     "float64",
@@ -117,6 +123,8 @@
     "interval_months",
     "large_binary",
     "large_string",
+    "large_list",
+    "list_",
     "null",
     "string",
     "struct",

python/src/nanoarrow/_lib.pyx

@@ -769,23 +769,55 @@ cdef class CSchema:
         else:
             return None
 
-    def modify(self, *, name=None, flags=None, nullable=None, metadata=None,
-               validate=True):
-        builder = CSchemaBuilder.copy(self)
+    def modify(self, *, format=None, name=None, flags=None, nullable=None,
+               metadata=None, children=None, dictionary=None, validate=True):
+        cdef CSchemaBuilder builder = CSchemaBuilder.allocate()
 
-        if name is not None:
+        if format is None:
+            builder.set_format(self.format)
+        else:
+            builder.set_format(format)
+
+        if name is None:
+            builder.set_name(self.name)
+        elif name is not False:
             builder.set_name(name)
 
-        if flags is not None:
+        if flags is None:
+            builder.set_flags(self.flags)
+        else:
             builder.set_flags(flags)
 
         if nullable is not None:
             builder.set_nullable(nullable)
 
-        if metadata is not None:
-            builder.clear_metadata()
+        if metadata is None:
+            if self.metadata is not None:
+                builder.append_metadata(self.metadata)
+        else:
             builder.append_metadata(metadata)
 
+        if children is None:
+            if self.n_children > 0:
+                builder.allocate_children(self.n_children)
+                for i, child in enumerate(self.children):
+                    builder.set_child(i, None, child)
+        elif hasattr(children, "items"):
+            builder.allocate_children(len(children))
+            for i, item in enumerate(children.items()):
+                name, child = item
+                builder.set_child(i, name, child)
+        else:
+            builder.allocate_children(len(children))
+            for i, child in enumerate(children):
+                builder.set_child(i, None, child)
+
+        if dictionary is None:
+            if self.dictionary:
+                builder.set_dictionary(self.dictionary)
+        elif dictionary is not False:
+            builder.set_dictionary(dictionary)
+
         if validate:
             builder.validate()
 
@@ -1036,19 +1068,10 @@ cdef class CSchemaBuilder:
         if self._ptr.release == NULL:
             ArrowSchemaInit(self._ptr)
 
-    @staticmethod
-    def copy(CSchema schema):
-        return CSchemaBuilder(schema.__deepcopy__())
-
     @staticmethod
     def allocate():
         return CSchemaBuilder(CSchema.allocate())
 
-    def clear_metadata(self):
-        cdef int code = ArrowSchemaSetMetadata(self.c_schema._ptr, NULL)
-        Error.raise_error_not_ok("ArrowSchemaSetMetadata()", code)
-        return self
-
     def append_metadata(self, metadata):
         cdef CBuffer buffer = CBuffer.empty()
 
@@ -1164,6 +1187,23 @@ cdef class CSchemaBuilder:
         if name is not None:
             name = str(name)
             code = ArrowSchemaSetName(self._ptr.children[i], name.encode("UTF-8"))
+            Error.raise_error_not_ok("ArrowSchemaSetName()", code)
+
+        return self
+
+    def set_dictionary(self, CSchema dictionary):
+        self.c_schema._assert_valid()
+
+        cdef int code
+        if self._ptr.dictionary == NULL:
+            code = ArrowSchemaAllocateDictionary(self._ptr)
+            Error.raise_error_not_ok("ArrowSchemaAllocateDictionary()", code)
+
+        if self._ptr.dictionary.release != NULL:
+            ArrowSchemaRelease(self._ptr.dictionary)
+
+        code = ArrowSchemaDeepCopy(dictionary._ptr, self._ptr.dictionary)
+        Error.raise_error_not_ok("ArrowSchemaDeepCopy()", code)
 
         return self
 
@@ -1179,6 +1219,14 @@ cdef class CSchemaBuilder:
 
         return self
 
+    def set_dictionary_ordered(self, dictionary_ordered):
+        if dictionary_ordered:
+            self._ptr.flags = self._ptr.flags | ARROW_FLAG_DICTIONARY_ORDERED
+        else:
+            self._ptr.flags = self._ptr.flags & ~ARROW_FLAG_DICTIONARY_ORDERED
+
+        return self
+
     def validate(self):
         return CSchemaView(self.c_schema)