Type alias PyVortexResult

Signed-off-by: Adam Gutglick <adam@spiraldb.com>

Author: AdamGS

vortex-python/src/arrays/builtins/struct_.rs

@@ -12,7 +12,7 @@ use crate::arrays::PyArrayRef;
 use crate::arrays::native::AsArrayRef;
 use crate::arrays::native::EncodingSubclass;
 use crate::arrays::native::PyNativeArray;
-use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 
 /// Concrete class for arrays with `vortex.struct` encoding.
 #[pyclass(name = "StructArray", module = "vortex", extends=PyNativeArray, frozen)]
@@ -25,7 +25,7 @@ impl EncodingSubclass for PyStructArray {
 #[pymethods]
 impl PyStructArray {
     /// Returns the given field of the struct array.
-    pub fn field(self_: PyRef<'_, Self>, name: &str) -> Result<PyArrayRef, PyVortexError> {
+    pub fn field(self_: PyRef<'_, Self>, name: &str) -> PyVortexResult<PyArrayRef> {
         let field = self_.as_array_ref().field_by_name(name)?.clone();
         Ok(PyArrayRef::from(field))
     }

vortex-python/src/arrays/compressed.rs

@@ -19,7 +19,7 @@ use crate::PyVortex;
 use crate::arrays::PyArrayRef;
 use crate::arrays::native::EncodingSubclass;
 use crate::arrays::native::PyNativeArray;
-use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 
 /// Concrete class for arrays with `vortex.alp` encoding.
 #[pyclass(name = "AlpArray", module = "vortex", extends=PyNativeArray, frozen)]
@@ -88,7 +88,7 @@ impl EncodingSubclass for PyZigZagArray {
 #[pymethods]
 impl PyZigZagArray {
     #[staticmethod]
-    pub fn encode(array: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+    pub fn encode(array: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         Ok(PyVortex(
             zigzag_encode(array.inner().clone().to_primitive())?.into_array(),
         ))

vortex-python/src/arrays/from_arrow.rs

@@ -19,10 +19,10 @@ use vortex::error::VortexError;
 
 use crate::arrays::PyArrayRef;
 use crate::arrow::FromPyArrow;
-use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 
 /// Convert an Arrow object to a Vortex array.
-pub(super) fn from_arrow(obj: &Borrowed<'_, '_, PyAny>) -> Result<PyArrayRef, PyVortexError> {
+pub(super) fn from_arrow(obj: &Borrowed<'_, '_, PyAny>) -> PyVortexResult<PyArrayRef> {
     let pa = obj.py().import("pyarrow")?;
     let pa_array = pa.getattr("Array")?;
     let chunked_array = pa.getattr("ChunkedArray")?;
@@ -55,7 +55,7 @@ pub(super) fn from_arrow(obj: &Borrowed<'_, '_, PyAny>) -> Result<PyArrayRef, Py
         let dtype = DType::from_arrow(array_stream.schema());
         let chunks = array_stream
             .into_iter()
-            .map(|b| -> Result<_, PyVortexError> {
+            .map(|b| -> PyVortexResult<_> {
                 Ok(ArrayRef::from_arrow(b.map_err(VortexError::from)?, false))
             })
             .collect::<Result<Vec<_>, _>>()?;

vortex-python/src/arrays/mod.rs

@@ -43,6 +43,7 @@ use crate::arrays::py::PythonArray;
 use crate::arrow::ToPyArrow;
 use crate::dtype::PyDType;
 use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 use crate::install_module;
 use crate::python_repr::PythonRepr;
 use crate::scalar::PyScalar;
@@ -214,7 +215,7 @@ impl PyArray {
     /// -------
     /// :class:`~vortex.Array`
     #[staticmethod]
-    fn from_arrow(obj: Bound<'_, PyAny>) -> Result<PyArrayRef, PyVortexError> {
+    fn from_arrow(obj: Bound<'_, PyAny>) -> PyVortexResult<PyArrayRef> {
         from_arrow::from_arrow(&obj.as_borrowed())
     }
 
@@ -260,7 +261,7 @@ impl PyArray {
     fn from_range(
         range: Bound<PyAny>,
         dtype: Option<Bound<PyDType>>,
-    ) -> Result<PyArrayRef, PyVortexError> {
+    ) -> PyVortexResult<PyArrayRef> {
         let range = range.cast::<PyRange>()?;
         let start = range.start()?;
         let stop = range.stop()?;
@@ -317,9 +318,7 @@ impl PyArray {
     /// ]
     /// ```
     ///
-    fn to_arrow_array<'py>(
-        self_: &'py Bound<'py, Self>,
-    ) -> Result<Bound<'py, PyAny>, PyVortexError> {
+    fn to_arrow_array<'py>(self_: &'py Bound<'py, Self>) -> PyVortexResult<Bound<'py, PyAny>> {
         // NOTE(ngates): for struct arrays, we could also return a RecordBatchStreamReader.
         let array = PyArrayRef::extract(self_.as_any().as_borrowed())?.into_inner();
         let py = self_.py();
@@ -332,9 +331,7 @@ impl PyArray {
             let chunks = chunked_array
                 .chunks()
                 .iter()
-                .map(|chunk| -> Result<_, PyVortexError> {
-                    Ok(chunk.clone().into_arrow(&arrow_dtype)?)
-                })
+                .map(|chunk| -> PyVortexResult<_> { Ok(chunk.clone().into_arrow(&arrow_dtype)?) })
                 .collect::<Result<Vec<ArrowArrayRef>, _>>()?;
 
             let pa_data_type = arrow_dtype.clone().to_pyarrow(py)?;
@@ -425,42 +422,42 @@ impl PyArray {
     }
 
     ///Rust docs are *not* copied into Python for __lt__: https://github.com/PyO3/pyo3/issues/4326
-    fn __lt__(slf: Bound<Self>, other: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+    fn __lt__(slf: Bound<Self>, other: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&slf, &*other, Operator::Lt)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __le__: https://github.com/PyO3/pyo3/issues/4326
-    fn __le__(slf: Bound<Self>, other: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+    fn __le__(slf: Bound<Self>, other: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::Lte)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __eq__: https://github.com/PyO3/pyo3/issues/4326
-    fn __eq__(slf: Bound<Self>, other: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+    fn __eq__(slf: Bound<Self>, other: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::Eq)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __ne__: https://github.com/PyO3/pyo3/issues/4326
-    fn __ne__(slf: Bound<Self>, other: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+    fn __ne__(slf: Bound<Self>, other: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::NotEq)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __ge__: https://github.com/PyO3/pyo3/issues/4326
-    fn __ge__(slf: Bound<Self>, other: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+    fn __ge__(slf: Bound<Self>, other: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::Gte)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __gt__: https://github.com/PyO3/pyo3/issues/4326
-    fn __gt__(slf: Bound<Self>, other: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+    fn __gt__(slf: Bound<Self>, other: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::Gt)?;
         Ok(PyArrayRef::from(inner))
@@ -494,7 +491,7 @@ impl PyArray {
     ///   5
     /// ]
     /// ```
-    fn filter(slf: Bound<Self>, mask: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+    fn filter(slf: Bound<Self>, mask: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let mask = (&*mask as &dyn Array).to_bool().to_mask_fill_null_false();
         let inner = vortex::compute::filter(&*slf, &mask)?;
@@ -620,7 +617,7 @@ impl PyArray {
     ///   "a"
     /// ]
     /// ```
-    fn take(slf: Bound<Self>, indices: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+    fn take(slf: Bound<Self>, indices: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
 
         if !indices.dtype().is_int() {
@@ -678,7 +675,7 @@ impl PyArray {
             .to_string())
     }
 
-    fn serialize(slf: &Bound<Self>, ctx: &PyArrayContext) -> Result<Vec<Vec<u8>>, PyVortexError> {
+    fn serialize(slf: &Bound<Self>, ctx: &PyArrayContext) -> PyVortexResult<Vec<Vec<u8>>> {
         // FIXME(ngates): do not copy to vec, use buffer protocol
         let array = PyArrayRef::extract(slf.as_any().as_borrowed())?;
         Ok(array

vortex-python/src/arrays/py/mod.rs

@@ -14,10 +14,10 @@ pub(crate) use python::*;
 use vortex::array::vtable::ArrayId;
 pub(crate) use vtable::*;
 
-use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 
 /// Extract the array id from a Python class `id` attribute.
-pub fn id_from_obj(cls: &Bound<PyAny>) -> Result<ArrayId, PyVortexError> {
+pub fn id_from_obj(cls: &Bound<PyAny>) -> PyVortexResult<ArrayId> {
     Ok(ArrayId::new_arc(
         cls.getattr("id")
             .map_err(|_| {

vortex-python/src/arrays/py/python.rs

@@ -10,7 +10,7 @@ use vortex::dtype::DType;
 use crate::arrays::PyArray;
 use crate::arrays::py::id_from_obj;
 use crate::dtype::PyDType;
-use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 
 /// Base class for implementing a Vortex encoding in Python.
 ///
@@ -32,7 +32,7 @@ impl PyPythonArray {
         cls: &Bound<'_, PyType>,
         len: usize,
         dtype: PyDType,
-    ) -> Result<PyClassInitializer<Self>, PyVortexError> {
+    ) -> PyVortexResult<PyClassInitializer<Self>> {
         let id = id_from_obj(cls)?;
         Ok(PyClassInitializer::from(PyArray).add_subclass(Self {
             id,

vortex-python/src/compress.rs

@@ -5,7 +5,7 @@ use pyo3::prelude::*;
 use vortex::compressor::BtrBlocksCompressor;
 
 use crate::arrays::PyArrayRef;
-use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 use crate::install_module;
 
 pub(crate) fn init(py: Python, parent: &Bound<PyModule>) -> PyResult<()> {
@@ -50,7 +50,7 @@ pub(crate) fn init(py: Python, parent: &Bound<PyModule>) -> PyResult<()> {
 ///    >>> str(vx.compress(a))
 ///    'vortex.alp(f64?, len=1000)'
 #[pyfunction]
-pub fn compress(array: PyArrayRef) -> Result<PyArrayRef, PyVortexError> {
+pub fn compress(array: PyArrayRef) -> PyVortexResult<PyArrayRef> {
     let compressed = BtrBlocksCompressor::default().compress(array.inner())?;
     Ok(PyArrayRef::from(compressed))
 }

vortex-python/src/dataset.rs

@@ -29,7 +29,7 @@ use crate::TOKIO_RUNTIME;
 use crate::arrays::PyArrayRef;
 use crate::arrow::IntoPyArrow;
 use crate::arrow::ToPyArrow;
-use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 use crate::expr::PyExpr;
 use crate::install_module;
 use crate::object_store_urls::object_store_from_url;
@@ -134,7 +134,7 @@ impl PyVortexDataset {
         row_filter: Option<&Bound<'py, PyExpr>>,
         indices: Option<PyArrayRef>,
         row_range: Option<(u64, u64)>,
-    ) -> Result<PyArrayRef, PyVortexError> {
+    ) -> PyVortexResult<PyArrayRef> {
         let array = read_array_from_reader(
             &self.vxf,
             projection_from_python(columns)?,
@@ -152,7 +152,7 @@ impl PyVortexDataset {
         row_filter: Option<&Bound<'_, PyExpr>>,
         split_by: Option<usize>,
         row_range: Option<(u64, u64)>,
-    ) -> Result<Py<PyAny>, PyVortexError> {
+    ) -> PyVortexResult<Py<PyAny>> {
         let mut scan = self_
             .vxf
             .scan()?
@@ -178,7 +178,7 @@ impl PyVortexDataset {
         row_filter: Option<&Bound<'_, PyExpr>>,
         split_by: Option<usize>,
         row_range: Option<(u64, u64)>,
-    ) -> Result<usize, PyVortexError> {
+    ) -> PyVortexResult<usize> {
         if row_filter.is_none() {
             let row_count = match row_range {
                 Some(range) => range.1 - range.0,
@@ -210,7 +210,7 @@ impl PyVortexDataset {
 
     /// The natural splits of this Dataset.
     #[pyo3(signature = (*))]
-    pub fn splits(&self) -> Result<Vec<(u64, u64)>, PyVortexError> {
+    pub fn splits(&self) -> PyVortexResult<Vec<(u64, u64)>> {
         Ok(self
             .vxf
             .splits()?
@@ -221,6 +221,6 @@ impl PyVortexDataset {
 }
 
 #[pyfunction]
-pub fn dataset_from_url(py: Python, url: &str) -> Result<PyVortexDataset, PyVortexError> {
+pub fn dataset_from_url(py: Python, url: &str) -> PyVortexResult<PyVortexDataset> {
     Ok(py.detach(|| TOKIO_RUNTIME.block_on(PyVortexDataset::from_url(url)))?)
 }

vortex-python/src/dtype/factory.rs

@@ -21,7 +21,7 @@ use vortex::dtype::PType;
 use vortex::dtype::StructFields;
 
 use crate::dtype::PyDType;
-use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 
 /// Construct the data type for a column containing only the null value.
 ///
@@ -261,7 +261,7 @@ pub(super) fn dtype_decimal(
     precision: u8,
     scale: i8,
     nullable: bool,
-) -> Result<Bound<'_, PyDType>, PyVortexError> {
+) -> PyVortexResult<Bound<'_, PyDType>> {
     let decimal_type = DType::Decimal(DecimalDType::try_new(precision, scale)?, nullable.into());
     Ok(PyDType::init(py, decimal_type)?)
 }

vortex-python/src/dtype/mod.rs

@@ -47,7 +47,7 @@ use crate::dtype::null::PyNullDType;
 use crate::dtype::primitive::PyPrimitiveDType;
 use crate::dtype::struct_::PyStructDType;
 use crate::dtype::utf8::PyUtf8DType;
-use crate::error::PyVortexError;
+use crate::error::PyVortexResult;
 use crate::install_module;
 use crate::python_repr::PythonRepr;
 
@@ -154,11 +154,11 @@ impl PyDType {
 
 #[pymethods]
 impl PyDType {
-    fn to_arrow_type(&self, py: Python) -> Result<Py<PyAny>, PyVortexError> {
+    fn to_arrow_type(&self, py: Python) -> PyVortexResult<Py<PyAny>> {
         Ok(self.0.to_arrow_dtype()?.to_pyarrow(py)?)
     }
 
-    fn to_arrow_schema(&self, py: Python) -> Result<Py<PyAny>, PyVortexError> {
+    fn to_arrow_schema(&self, py: Python) -> PyVortexResult<Py<PyAny>> {
         Ok(self.0.to_arrow_schema()?.to_pyarrow(py)?)
     }