Kyle/create

src/array/mod.rs

@@ -1,4 +1,5 @@
 mod r#async;
+mod create;
 mod selection;
 mod shared;
 mod sync;

src/array/sync.rs

@@ -5,14 +5,17 @@ use std::sync::Arc;
 use crate::array::selection::PySelection;
 use crate::array::shared::array_metadata_accessors;
 use crate::array::util::PyChunkIndices;
-use crate::codec::PyCodecOptions;
+use crate::chunks::PyChunkGrid;
+use crate::codec::{PyArrayToArrayCodec, PyBytesToBytesCodec, PyCodecChain, PyCodecOptions};
 use crate::decoded_array::DecodedArray;
+use crate::dtype::PyDataType;
 use crate::error::ZarristaResult;
+use crate::fill_value::PyFillValue;
 use crate::node::PyNodePath;
 use crate::storage::PySyncStorage;
 use pyo3::prelude::*;
 use pyo3_bytes::PyBytes;
-use zarrs::array::Array;
+use zarrs::array::{Array, ArrayBuilder};
 use zarrs::storage::ReadableWritableListableStorageTraits;
 
 /// A Zarr array.
@@ -45,6 +48,55 @@ impl PyArray {
         )
     }
 
+    /// Create a new array
+    #[staticmethod]
+    #[pyo3(
+        signature = (store, dtype, chunk_grid, fill_value, *, path="/", subchunk_shape=None, array_to_array_codecs=None, bytes_to_bytes_codecs=None),
+        text_signature = "(store, dtype, chunk_grid, fill_value, *, path='/', subchunk_shape=None, array_to_array_codecs=None, bytes_to_bytes_codecs=None)"
+    )]
+    #[expect(clippy::too_many_arguments)]
+    fn create(
+        store: PySyncStorage,
+        dtype: PyDataType,
+        chunk_grid: PyChunkGrid,
+        fill_value: PyFillValue,
+        path: &str,
+        subchunk_shape: Option<Vec<u64>>,
+        array_to_array_codecs: Option<Vec<PyArrayToArrayCodec>>,
+        bytes_to_bytes_codecs: Option<Vec<PyBytesToBytesCodec>>,
+    ) -> ZarristaResult<Self> {
+        let store = store.into_inner();
+        let mut builder = ArrayBuilder::new_with_chunk_grid(
+            chunk_grid,
+            dtype.into_inner(),
+            fill_value.into_inner(),
+        );
+
+        if let Some(subchunk_shape) = subchunk_shape {
+            builder.subchunk_shape(subchunk_shape);
+        }
+        if let Some(array_to_array_codecs) = array_to_array_codecs {
+            builder.array_to_array_codecs(
+                array_to_array_codecs
+                    .into_iter()
+                    .map(|c| c.into_inner())
+                    .collect(),
+            );
+        }
+        if let Some(bytes_to_bytes_codecs) = bytes_to_bytes_codecs {
+            builder.bytes_to_bytes_codecs(
+                bytes_to_bytes_codecs
+                    .into_iter()
+                    .map(|c| c.into_inner())
+                    .collect(),
+            );
+        }
+
+        Ok(Self {
+            inner: builder.build(store, path)?,
+        })
+    }
+
     /// Open the array stored at `path` in `store`.
     #[staticmethod]
     #[pyo3(

src/chunks.rs

@@ -1,11 +1,25 @@
 use pyo3::prelude::*;
 use zarrs::array::ChunkGrid;
 
-#[pyclass(module = "zarrista", frozen, name = "ChunkGrid")]
+use crate::error::ZarristaResult;
+use crate::metadata::PyMetadataV3;
+
+#[derive(Debug, Clone)]
+#[pyclass(module = "zarrista", frozen, name = "ChunkGrid", from_py_object)]
 pub struct PyChunkGrid(ChunkGrid);
 
 #[pymethods]
 impl PyChunkGrid {
+    #[staticmethod]
+    fn from_metadata(metadata: PyMetadataV3, shape: Vec<u64>) -> ZarristaResult<Self> {
+        Ok(Self(ChunkGrid::from_metadata(metadata.as_ref(), &shape)?))
+    }
+
+    #[getter]
+    fn metadata(&self) -> PyMetadataV3 {
+        self.0.metadata().into()
+    }
+
     #[getter]
     fn ndim(&self) -> usize {
         self.0.dimensionality()

src/codec/array_to_array.rs

@@ -26,10 +26,20 @@ pub fn bitround(keepbits: u32) -> PyArrayToArrayCodec {
     PyArrayToArrayCodec(Arc::new(codec))
 }
 
-#[pyclass(module = "zarrista.codec", frozen, name = "ArrayToArrayCodec")]
+#[derive(Debug, Clone)]
+#[pyclass(
+    module = "zarrista.codec",
+    frozen,
+    name = "ArrayToArrayCodec",
+    from_py_object
+)]
 pub struct PyArrayToArrayCodec(Arc<dyn ArrayToArrayCodecTraits>);
 
 impl PyArrayToArrayCodec {
+    pub fn into_inner(self) -> Arc<dyn ArrayToArrayCodecTraits> {
+        self.0
+    }
+
     pub fn new(codec: Arc<dyn ArrayToArrayCodecTraits>) -> Self {
         Self(codec)
     }

src/codec/bytes_to_bytes/mod.rs

@@ -17,13 +17,23 @@ use zarrs::array::{BytesToBytesCodecTraits, Codec, CodecOptions};
 use crate::error::ZarristaResult;
 use crate::metadata::{PyConfiguration, PyMetadataV3};
 
-#[pyclass(module = "zarrista.codec", frozen, name = "BytesToBytesCodec")]
+#[derive(Debug, Clone)]
+#[pyclass(
+    module = "zarrista.codec",
+    frozen,
+    name = "BytesToBytesCodec",
+    from_py_object
+)]
 pub struct PyBytesToBytesCodec(Arc<dyn BytesToBytesCodecTraits>);
 
 impl PyBytesToBytesCodec {
     pub fn new(codec: Arc<dyn BytesToBytesCodecTraits>) -> Self {
         Self(codec)
     }
+
+    pub fn into_inner(self) -> Arc<dyn BytesToBytesCodecTraits> {
+        self.0
+    }
 }
 
 #[pymethods]

src/dtype.rs

@@ -10,7 +10,7 @@ use zarrs::array::{DataType, DataTypeSize};
 use zarrs::metadata::v3::MetadataV3;
 
 #[derive(Debug, Clone)]
-#[pyclass(module = "zarrista", frozen, name = "DataType", skip_from_py_object)]
+#[pyclass(module = "zarrista", frozen, name = "DataType", from_py_object)]
 pub struct PyDataType {
     inner: DataType,
 }
@@ -19,6 +19,10 @@ impl PyDataType {
     pub(crate) fn inner(&self) -> &DataType {
         &self.inner
     }
+
+    pub fn into_inner(self) -> DataType {
+        self.inner
+    }
 }
 
 #[pymethods]

src/fill_value.rs

@@ -2,13 +2,18 @@ use pyo3::prelude::*;
 use pyo3_bytes::PyBytes;
 use zarrs::array::FillValue;
 
-#[pyclass(module = "zarrista", frozen, name = "FillValue")]
+#[derive(Debug, Clone)]
+#[pyclass(module = "zarrista", frozen, name = "FillValue", from_py_object)]
 pub struct PyFillValue(FillValue);
 
 impl PyFillValue {
     pub(crate) fn inner(&self) -> &FillValue {
         &self.0
     }
+
+    pub fn into_inner(self) -> FillValue {
+        self.0
+    }
 }
 
 #[pymethods]