many improvements, refactoring:

* added reading from filelike objects (breaking change!)
* supporting pathlike
* remove get_sheet_data/get_sheet_names functions (breaking change!)
* updated readme/tests
* CalamineReader -> CalamineWorkbook (breaking change!)

Author: dimastbk

Cargo.toml

@@ -15,11 +15,12 @@ crate-type = ["cdylib"]
 
 [dependencies]
 calamine = {version = "0.19.1", features = ["dates", "chrono"]}
-pyo3 = {version = "0.18.0", features = ["extension-module", "chrono"]}
+pyo3 = {version = "0.18.1", features = ["extension-module", "chrono"]}
 chrono = {version = "0.4.23", features = ["serde"]}
+pyo3-file = {git = "https://github.com/omerbenamram/pyo3-file.git", rev = "2bc4c1a00551ce1942ebf20cb4ebee4884b3aad1"}
 
 [build-dependencies]
-pyo3-build-config = "0.18.0"
+pyo3-build-config = "0.18.1"
 
 [package.metadata.maturin]
 name = "python_calamine._python_calamine"

README.md

@@ -14,30 +14,30 @@ pip install python-calamine
 
 ### Example
 ```python
-from python_calamine import get_sheet_data, get_sheet_names
+from python_calamine import CalamineWorkbook
 
+workbook = CalamineWorkbook.from_pyobject("file.xlsx")
+workbook.sheet_names
+# ["Sheet1", "Sheet2"]
 
-get_sheet_names("file.xlsx")
-# ['Sheet1', 'Sheet2']
-
-get_sheet_data("file.xlsx", "Sheet1")
+workbook.get_sheet_by_name("Sheet1").to_python()
 # [
-# ['1',  '2',  '3',  '4',  '5',  '6',  '7'],
-# ['1',  '2',  '3',  '4',  '5',  '6',  '7'],
-# ['1',  '2',  '3',  '4',  '5',  '6',  '7'],
+# ["1",  "2",  "3",  "4",  "5",  "6",  "7"],
+# ["1",  "2",  "3",  "4",  "5",  "6",  "7"],
+# ["1",  "2",  "3",  "4",  "5",  "6",  "7"],
 # ]
 ```
 
 By default, calamine skips empty rows/cols before data. For suppress this behaviour, set `skip_empty_area` to `False`.
 ```python
-from python_calamine import get_sheet_data
+from python_calamine import CalamineWorkbook
 
-get_sheet_data("file.xlsx", "Sheet1", skip_empty_area=False)
+workbook = CalamineWorkbook.from_pyobject("file.xlsx").get_sheet_by_name("Sheet1").to_python(skip_empty_area=False)
 # [
-# ['',  '',  '',  '',  '',  '',  ''],
-# ['1',  '2',  '3',  '4',  '5',  '6',  '7'],
-# ['1',  '2',  '3',  '4',  '5',  '6',  '7'],
-# ['1',  '2',  '3',  '4',  '5',  '6',  '7'],
+# [",  ",  ",  ",  ",  ",  "],
+# ["1",  "2",  "3",  "4",  "5",  "6",  "7"],
+# ["1",  "2",  "3",  "4",  "5",  "6",  "7"],
+# ["1",  "2",  "3",  "4",  "5",  "6",  "7"],
 # ]
 ```
 

python/python_calamine/__init__.py

@@ -1,7 +1,5 @@
 from ._python_calamine import (  # noqa: F401
     CalamineError,
-    CalamineReader,
     CalamineSheet,
-    get_sheet_data,
-    get_sheet_names,
+    CalamineWorkbook,
 )

python/python_calamine/_python_calamine.pyi

@@ -1,9 +1,15 @@
 from __future__ import annotations
 
 from datetime import date, datetime, time
+from os import PathLike
+from typing import Protocol
 
 ValueT = int | float | str | bool | time | date | datetime
 
+class ReadBuffer(Protocol):
+    def seek(self) -> int: ...
+    def read(self) -> bytes: ...
+
 class CalamineSheet:
     name: str
     @property
@@ -20,16 +26,13 @@ class CalamineSheet:
     def end(self) -> tuple[int, int] | None: ...
     def to_python(self, skip_empty_area: bool = True) -> list[list[ValueT]]: ...
 
-class CalamineReader:
+class CalamineWorkbook:
     sheet_names: list[str]
     @classmethod
-    def from_path(cls, path: str) -> "CalamineReader": ...
+    def from_pyobject(
+        cls, path_or_file_like: str | PathLike | ReadBuffer
+    ) -> "CalamineWorkbook": ...
     def get_sheet_by_name(self, name: str) -> CalamineSheet: ...
     def get_sheet_by_index(self, index: int) -> CalamineSheet: ...
 
-def get_sheet_data(
-    path: str, sheet: int, skip_empty_area: bool = True
-) -> list[list[ValueT]]: ...
-def get_sheet_names(path: str) -> list[str]: ...
-
 class CalamineError(Exception): ...

src/lib.rs

@@ -1,46 +1,12 @@
-use calamine::{open_workbook_auto, Error, Reader, Sheets};
 use pyo3::prelude::*;
-use pyo3::wrap_pyfunction;
 
 mod types;
 mod utils;
-use crate::types::{CalamineError, CalamineReader, CalamineSheet, CellValue};
-use crate::utils::convert_err_to_py;
-
-#[pyfunction]
-#[pyo3(signature = (path, sheet, skip_empty_area=true))]
-fn get_sheet_data(
-    path: &str,
-    sheet: usize,
-    skip_empty_area: bool,
-) -> PyResult<Vec<Vec<CellValue>>> {
-    let mut excel: Sheets<_> = open_workbook_auto(path).map_err(convert_err_to_py)?;
-    let readed_range = excel.worksheet_range_at(sheet);
-    let mut range = readed_range
-        .unwrap_or_else(|| Err(Error::Msg("Workbook is empty")))
-        .map_err(convert_err_to_py)?;
-    if !skip_empty_area {
-        if let Some(end) = range.end() {
-            range = range.range((0, 0), end)
-        }
-    }
-    Ok(range
-        .rows()
-        .map(|row| row.iter().map(|x| x.into()).collect())
-        .collect())
-}
-
-#[pyfunction]
-fn get_sheet_names(path: &str) -> PyResult<Vec<String>> {
-    let excel: Sheets<_> = open_workbook_auto(path).map_err(convert_err_to_py)?;
-    Ok(excel.sheet_names().to_vec())
-}
+use crate::types::{CalamineError, CalamineSheet, CalamineWorkbook, CellValue};
 
 #[pymodule]
 fn _python_calamine(py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(get_sheet_data, m)?)?;
-    m.add_function(wrap_pyfunction!(get_sheet_names, m)?)?;
-    m.add_class::<CalamineReader>()?;
+    m.add_class::<CalamineWorkbook>()?;
     m.add_class::<CalamineSheet>()?;
     m.add("CalamineError", py.get_type::<CalamineError>())?;
     Ok(())

src/types/mod.rs

@@ -2,10 +2,10 @@ use pyo3::create_exception;
 use pyo3::exceptions::PyException;
 
 mod cell;
-mod reader;
 mod sheet;
+mod workbook;
 pub use cell::CellValue;
-pub use reader::CalamineReader;
 pub use sheet::CalamineSheet;
+pub use workbook::CalamineWorkbook;
 
 create_exception!(python_calamine, CalamineError, PyException);

src/types/reader.rs

@@ -22,22 +22,27 @@ impl CalamineSheet {
     fn height(&self) -> usize {
         self.range.height()
     }
+
     #[getter]
     fn width(&self) -> usize {
         self.range.height()
     }
+
     #[getter]
     fn total_height(&self) -> u32 {
         self.range.end().unwrap_or_default().0
     }
+
     #[getter]
     fn total_width(&self) -> u32 {
         self.range.end().unwrap_or_default().1
     }
+
     #[getter]
     fn start(&self) -> Option<(u32, u32)> {
         self.range.start()
     }
+
     #[getter]
     fn end(&self) -> Option<(u32, u32)> {
         self.range.end()

src/types/sheet.rs

@@ -0,0 +1,100 @@
+use std::fs::File;
+use std::io::{BufReader, Cursor, Read};
+
+use calamine::{open_workbook_auto, open_workbook_auto_from_rs, Error, Reader, Sheets};
+use pyo3::prelude::*;
+use pyo3::types::PyType;
+
+use crate::utils::{err_to_py, FileOrFileLike};
+use crate::{CalamineError, CalamineSheet};
+
+enum SheetsEnum {
+    File(Sheets<BufReader<File>>),
+    FileLike(Sheets<Cursor<Vec<u8>>>),
+}
+
+impl SheetsEnum {
+    fn sheet_names(&self) -> &[String] {
+        match self {
+            SheetsEnum::File(f) => f.sheet_names(),
+            SheetsEnum::FileLike(f) => f.sheet_names(),
+        }
+    }
+
+    fn worksheet_range(
+        &mut self,
+        name: &str,
+    ) -> Option<Result<calamine::Range<calamine::DataType>, Error>> {
+        match self {
+            SheetsEnum::File(f) => f.worksheet_range(name),
+            SheetsEnum::FileLike(f) => f.worksheet_range(name),
+        }
+    }
+
+    fn worksheet_range_at(
+        &mut self,
+        index: usize,
+    ) -> Option<Result<calamine::Range<calamine::DataType>, Error>> {
+        match self {
+            SheetsEnum::File(f) => f.worksheet_range_at(index),
+            SheetsEnum::FileLike(f) => f.worksheet_range_at(index),
+        }
+    }
+}
+
+#[pyclass]
+pub struct CalamineWorkbook {
+    sheets: SheetsEnum,
+    #[pyo3(get)]
+    sheet_names: Vec<String>,
+}
+
+#[pymethods]
+impl CalamineWorkbook {
+    #[classmethod]
+    fn from_pyobject(_cls: &PyType, path_or_file_like: PyObject) -> PyResult<Self> {
+        Python::with_gil(|_py| {
+            let sheets: SheetsEnum = match FileOrFileLike::from_pyobject(path_or_file_like)? {
+                FileOrFileLike::FileLike(mut f) => {
+                    let mut buf = vec![];
+                    f.read_to_end(&mut buf)?;
+                    let reader = Cursor::new(buf);
+                    SheetsEnum::FileLike(open_workbook_auto_from_rs(reader).map_err(err_to_py)?)
+                }
+                FileOrFileLike::Path(s) => {
+                    SheetsEnum::File(open_workbook_auto(s).map_err(err_to_py)?)
+                }
+            };
+
+            let sheet_names = sheets.sheet_names().to_owned();
+
+            Ok(Self {
+                sheets,
+                sheet_names,
+            })
+        })
+    }
+
+    fn get_sheet_by_name(&mut self, name: &str) -> PyResult<CalamineSheet> {
+        let range = self
+            .sheets
+            .worksheet_range(name)
+            .unwrap_or_else(|| Err(Error::Msg("Workbook is empty")))
+            .map_err(err_to_py)?;
+        Ok(CalamineSheet::new(name.to_owned(), range))
+    }
+
+    fn get_sheet_by_index(&mut self, index: usize) -> PyResult<CalamineSheet> {
+        let name = self
+            .sheet_names
+            .get(index)
+            .ok_or_else(|| CalamineError::new_err("Workbook is empty"))?
+            .to_string();
+        let range = self
+            .sheets
+            .worksheet_range_at(index)
+            .unwrap_or_else(|| Err(Error::Msg("Workbook is empty")))
+            .map_err(err_to_py)?;
+        Ok(CalamineSheet::new(name, range))
+    }
+}

src/types/workbook.rs

@@ -1,12 +1,50 @@
+use std::path::PathBuf;
+
 use calamine::Error;
 use pyo3::exceptions::PyIOError;
+use pyo3::prelude::*;
+use pyo3::types::PyString;
 use pyo3::PyErr;
+use pyo3_file::PyFileLikeObject;
 
 use crate::types::CalamineError;
 
-pub fn convert_err_to_py(e: Error) -> PyErr {
+pub fn err_to_py(e: Error) -> PyErr {
     match e {
         Error::Io(err) => PyIOError::new_err(err.to_string()),
         _ => CalamineError::new_err(e.to_string()),
     }
 }
+
+// This enum uses code from example pyo3-file
+// MIT License, see authors under link
+// https://github.com/omerbenamram/pyo3-file/tree/2bc4c1a00551ce1942ebf20cb4ebee4884b3aad1#example
+#[derive(Debug)]
+pub enum FileOrFileLike {
+    Path(String),
+    FileLike(PyFileLikeObject),
+}
+
+impl FileOrFileLike {
+    pub fn from_pyobject(path_or_file_like: PyObject) -> PyResult<FileOrFileLike> {
+        Python::with_gil(|py| {
+            // is a string path
+            if let Ok(string_ref) = path_or_file_like.downcast::<PyString>(py) {
+                return Ok(FileOrFileLike::Path(
+                    string_ref.to_string_lossy().to_string(),
+                ));
+            }
+
+            // is a pathlike
+            if let Ok(string_ref) = path_or_file_like.extract::<PathBuf>(py) {
+                return Ok(FileOrFileLike::Path(
+                    string_ref.to_string_lossy().to_string(),
+                ));
+            }
+
+            // is a file-like
+            PyFileLikeObject::with_requirements(path_or_file_like, true, false, true)
+                .map(FileOrFileLike::FileLike)
+        })
+    }
+}