python-calamine-reducto 0.7.19__tar.gz → 0.7.21__tar.gz

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/.github/workflows/release.yml

@@ -70,7 +70,7 @@ jobs:
 
   build-macos:
     name: wheels macos-${{ matrix.target }}
-    runs-on: macos-14
+    runs-on: macos-15
     strategy:
       fail-fast: false
       matrix:

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/Cargo.lock

@@ -80,7 +80,7 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 [[package]]
 name = "calamine"
 version = "0.32.0"
-source = "git+https://github.com/reductoai/calamine.git?branch=main#297ee32c41c7449e22f9fb94e93c0291b0b4d15d"
+source = "git+https://github.com/reductoai/calamine.git?branch=main#b87b3385408cad5fd436b96d08f1d4b0ebf7664c"
 dependencies = [
  "atoi_simd",
  "byteorder",
@@ -612,7 +612,7 @@ dependencies = [
 
 [[package]]
 name = "python-calamine-reducto"
-version = "0.7.19"
+version = "0.7.21"
 dependencies = [
  "calamine",
  "chrono",

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "python-calamine-reducto"
-version = "0.7.19"
+version = "0.7.21"
 edition = "2021"
 readme = "README.md"
 

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-calamine-reducto
-Version: 0.7.19
+Version: 0.7.21
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.11

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/README.md

@@ -25,7 +25,8 @@ Our additions live on `main`.
 - **`get_sheet_grid(name, rows, cols, include_styles=True)`** → `CellGrid` from the dense range.
 - **`get_sheet_layout(name)`** → dict with row heights, column widths, defaults
 - **`get_sheet_formulas`**, **`get_sheet_merged_ranges`**, **`get_sheet_images`**,
-  **`get_sheet_data_validations`**, **`get_sheet_freeze_panes`**,
+  **`get_sheet_data_validations`**, **`get_sheet_hyperlinks`**, **`get_sheet_hyperlink_formulas`**,
+  **`get_sheet_freeze_panes`**,
   **`get_sheet_filled_count`**, **`get_sheet_uncached_formula_count`**,
   **`get_all_tables_metadata`**
 

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/python/python_calamine/__init__.py

@@ -5,6 +5,8 @@ from ._python_calamine import (
     CalamineWorkbook,
     CellGrid,
     CellProxy,
+    FormulasTooLarge,
+    GridTooLarge,
     PasswordError,
     SheetMetadata,
     SheetTypeEnum,
@@ -26,6 +28,8 @@ __all__ = (
     "CalamineWorkbook",
     "CellGrid",
     "CellProxy",
+    "FormulasTooLarge",
+    "GridTooLarge",
     "PasswordError",
     "SheetMetadata",
     "SheetTypeEnum",

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/python/python_calamine/_python_calamine.pyi

@@ -204,6 +204,21 @@ class DataValidation(typing.TypedDict):
     formula2: str | None
     allow_blank: bool
 
+@typing.type_check_only
+class Hyperlink(typing.TypedDict):
+    ref: str
+    """Cell or range reference, e.g. `A1` or `A1:C3`."""
+    rel_id: str | None
+    """The `r:id` of the link, if any."""
+    target: str | None
+    """Relationship target, e.g. a URL. `None` for a link with only a `location`, and for an
+    `r:id` that has no hyperlink relationship."""
+    location: str | None
+    """Place inside the target or the workbook, e.g. `Sheet2!A1` or a URL fragment."""
+    display: str | None
+    external: bool
+    """`True` when the relationship has `TargetMode="External"`."""
+
 @typing.final
 class CellProxy:
     """One cell of a `CellGrid`. Read a field with `cell["value"]`."""
@@ -226,6 +241,10 @@ class CellGrid:
     def col_coords(self) -> npt.NDArray[np.int32]:
         """Grid column -> 0-based sheet column."""
 
+    @property
+    def gap_unpinned(self) -> bool:
+        """Whether gap compression removed rows or columns across frozen panes or inside merges."""
+
     @property
     def uncached_formula_count(self) -> int | None:
         """Formula cells with no cached value (streaming xlsx grids), else `None`."""
@@ -259,10 +278,19 @@ class CellGrid:
         value: bool,
     ) -> None: ...
     def apply_formatting_rust(self) -> None:
-        """Format each value with its number format (SSF, in Rust)."""
+        """Format each value with its number format (SSF, in Rust). An error value stays as is."""
+
+    def apply_dateutil_reformat(
+        self, date_parse: Callable[[str], float | None]
+    ) -> None:
+        """Reformat text cells that have a date format. `date_parse` gives a date serial.
 
-    def apply_dateutil_reformat(self, date_parse: Callable[[str], float | None]) -> None:
-        """Reformat text cells that have a date format. `date_parse` gives a date serial."""
+        Deprecated: text cells keep their text, as in Excel; the API no longer calls it.
+        It does not change an error value.
+
+        `date_parse` runs once for each distinct text. Text above 64 characters is not a
+        date, so `date_parse` does not get it.
+        """
 
     def apply_raw_as_formatted(self) -> None: ...
     def apply_color_names(self, converter: Callable[[str], str | None]) -> None:
@@ -394,6 +422,7 @@ class CalamineWorkbook:
         coverage: float = 0.999,
         trim_header_only: bool = False,
         max_empty_run: int | None = None,
+        max_grid_cells: int | None = None,
     ) -> tuple[CellGrid, int, int, int]:
         """Stream a grid. Returns `(grid, declared_rows, declared_cols, dropped_cells)`.
 
@@ -401,10 +430,17 @@ class CalamineWorkbook:
         `max_empty_run` keeps at most that many rows (and columns) of each empty run inside the
         trimmed bounds. It engages only above `trigger_cells`, and only when it halves the grid.
         `coord` and `merge_parent` stay in sheet positions; `row_coords`/`col_coords` map them.
+        Frozen columns stop the row compression, frozen rows stop the column compression, and
+        a merge keeps all its rows and columns.
+
+        `max_grid_cells` bounds the grid that the reader allocates. When frozen panes or merges
+        hold the compressed grid above it, compression keeps only the frozen rows and columns
+        and the anchor of each merge (`CellGrid.gap_unpinned`). A grid still above it raises
+        `GridTooLarge` before any allocation.
         """
 
     def get_sheet_filled_count(self, name: str) -> tuple[int, int, int]:
-        """`(filled, max_filled_row, max_filled_col)` in one streaming pass. xlsx only."""
+        """`(filled, max_filled_row, max_filled_col)` in one streaming pass."""
 
     def get_sheet_uncached_formula_count(self, name: str) -> int | None: ...
     def for_each_band(
@@ -421,23 +457,60 @@ class CalamineWorkbook:
     ) -> tuple[int, int, int]:
         """Stream the sheet as row bands. Returns `(declared_rows, declared_cols, dropped_cells)`."""
 
-    def get_sheet_formulas(self, name: str) -> list[tuple[int, int, str]]:
-        """`(row, col, formula)` for each formula cell. Each formula starts with `=`."""
+    def get_sheet_formulas(
+        self, name: str, max_formula_bytes: int = 268_435_456
+    ) -> list[tuple[int, int, str]]:
+        """`(row, col, formula)` for each formula cell. Each formula starts with `=`.
+
+        A formula above 8,192 characters (the Excel limit) is skipped. The reader copies a
+        shared formula into each of its cells. Every copy counts toward `max_formula_bytes`
+        (UTF-8 bytes), also a skipped copy. Above it, the read raises `FormulasTooLarge`.
+        """
 
     def get_sheet_images(self, name: str) -> list[tuple[bytes, str, int, int]]:
         """`(data, extension, anchor_row, anchor_col)` for each image."""
 
     def get_sheet_data_validations(self, name: str) -> list[DataValidation]: ...
+    def get_sheet_hyperlinks(
+        self, name: str, limit: int | None = None
+    ) -> list[Hyperlink]:
+        """The links of the sheet's `<hyperlinks>` element, at most `limit`. Empty for xlsb, xls, and ods."""
+
+    def get_sheet_hyperlink_formulas(
+        self, name: str, limit: int | None = None, max_formula_bytes: int = 268_435_456
+    ) -> list[tuple[int, int, str]]:
+        """`(row, col, formula)` for each formula that contains `HYPERLINK`, at most `limit`. Empty for xlsb, xls, and ods.
+
+        Every formula of the sheet counts toward `max_formula_bytes`, as in `get_sheet_formulas`.
+        """
+
     def get_sheet_freeze_panes(self, name: str) -> tuple[int, int]:
         """`(frozen_rows, frozen_cols)`."""
 
     def get_sheet_merged_ranges(self, name: str) -> list[tuple[int, int, int, int]]:
-        """`(start_row, start_col, end_row, end_col)`, 0-based and inclusive."""
+        """`(start_row, start_col, end_row, end_col)`, 0-based and inclusive, in file order.
+
+        These are the merges that every grid build uses. The reader drops some merges, never raises:
+
+        1. A merge that repeats an earlier merge.
+        2. Above 1,048,576 merges (one for each Excel row), the merges that start farthest
+           from the top of the sheet (by start row, then start column).
+        3. A merge that overlaps an earlier kept merge. Excel does not let merges overlap.
+
+        A valid sheet keeps all of its merges. `get_sheet_dropped_merges` gives the counts.
+        """
+
+    def get_sheet_dropped_merges(self, name: str) -> tuple[int, int, int]:
+        """`(duplicate, over_cap, overlapping)`: the merges that `get_sheet_merged_ranges` dropped.
+
+        All zero for a valid sheet. The merges stay cached for the last sheet, so a call after a
+        grid build of the same sheet does not read the sheet again.
+        """
 
     def get_sheet_bounds(self, name: str) -> tuple[int, int]:
         """`(max_filled_row, max_filled_col)`, 1-based and exclusive.
 
-        xlsx does not count `""` cells, as `get_sheet_grid_streaming`. Other formats count them.
+        The read streams the cells and does not count `""` cells, as `get_sheet_grid_streaming`.
         """
 
 class CalamineError(Exception): ...
@@ -449,6 +522,8 @@ class WorkbookClosed(CalamineError): ...
 class TablesNotLoaded(CalamineError): ...
 class TablesNotSupported(CalamineError): ...
 class TableNotFound(CalamineError): ...
+class GridTooLarge(CalamineError): ...
+class FormulasTooLarge(CalamineError): ...
 
 def load_workbook(
     path_or_filelike: str | os.PathLike | ReadBuffer, load_tables: bool = False
@@ -467,6 +542,8 @@ __all__ = [
     "CalamineWorkbook",
     "CellGrid",
     "CellProxy",
+    "FormulasTooLarge",
+    "GridTooLarge",
     "PasswordError",
     "SheetMetadata",
     "SheetTypeEnum",

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/src/lib.rs

@@ -3,8 +3,9 @@ use pyo3::prelude::*;
 mod types;
 use crate::types::{
     CalamineError, CalamineSheet, CalamineTable, CalamineWorkbook, CellGrid, CellProxy, CellValue,
-    Error, PasswordError, SheetMetadata, SheetTypeEnum, SheetVisibleEnum, TableNotFound,
-    TablesNotLoaded, TablesNotSupported, WorkbookClosed, WorksheetNotFound, XmlError, ZipError,
+    Error, FormulasTooLarge, GridTooLarge, PasswordError, SheetMetadata, SheetTypeEnum,
+    SheetVisibleEnum, TableNotFound, TablesNotLoaded, TablesNotSupported, WorkbookClosed,
+    WorksheetNotFound, XmlError, ZipError,
 };
 
 #[pyfunction]
@@ -37,5 +38,7 @@ fn _python_calamine(py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add("TablesNotLoaded", py.get_type::<TablesNotLoaded>())?;
     m.add("TableNotFound", py.get_type::<TableNotFound>())?;
     m.add("WorkbookClosed", py.get_type::<WorkbookClosed>())?;
+    m.add("GridTooLarge", py.get_type::<GridTooLarge>())?;
+    m.add("FormulasTooLarge", py.get_type::<FormulasTooLarge>())?;
     Ok(())
 }

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/src/types/errors.rs

@@ -8,6 +8,8 @@ pub enum Error {
     TablesNotSupported,
     TablesNotLoaded,
     WorkbookClosed,
+    /// The formula text of one sheet read is above `max_formula_bytes`.
+    FormulasTooLarge(u64),
 }
 
 create_exception!(python_calamine, CalamineError, PyException);
@@ -19,6 +21,8 @@ create_exception!(python_calamine, WorkbookClosed, CalamineError);
 create_exception!(python_calamine, TablesNotSupported, CalamineError);
 create_exception!(python_calamine, TablesNotLoaded, CalamineError);
 create_exception!(python_calamine, TableNotFound, CalamineError);
+create_exception!(python_calamine, GridTooLarge, CalamineError);
+create_exception!(python_calamine, FormulasTooLarge, CalamineError);
 
 impl From<CalamineCrateError> for Error {
     fn from(err: CalamineCrateError) -> Self {
@@ -38,6 +42,18 @@ impl From<XlsbError> for Error {
     }
 }
 
+impl From<XlsError> for Error {
+    fn from(err: XlsError) -> Self {
+        Error::Calamine(err.into())
+    }
+}
+
+impl From<OdsError> for Error {
+    fn from(err: OdsError) -> Self {
+        Error::Calamine(err.into())
+    }
+}
+
 impl From<Error> for PyErr {
     fn from(val: Error) -> Self {
         match val {
@@ -94,6 +110,9 @@ impl From<Error> for PyErr {
             Error::WorkbookClosed => WorkbookClosed::new_err("".to_string()),
             Error::TablesNotLoaded => TablesNotLoaded::new_err("".to_string()),
             Error::TablesNotSupported => TablesNotSupported::new_err("".to_string()),
+            Error::FormulasTooLarge(max) => FormulasTooLarge::new_err(format!(
+                "the formula text of the sheet is above max_formula_bytes={max}"
+            )),
         }
     }
 }

{python_calamine_reducto-0.7.19 → python_calamine_reducto-0.7.21}/src/types/grid.rs

@@ -14,6 +14,8 @@ use pyo3::exceptions::{PyIndexError, PyKeyError, PyTypeError, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyString};
 
+use super::workbook::longer_than;
+
 type PyObject = Py<PyAny>;
 
 /// Compact representation of a raw cell value (stays in Rust, not Python).
@@ -22,6 +24,8 @@ pub enum RawValue {
     Int(i64),
     Float(f64),
     String(Arc<str>),
+    /// An error value, e.g. `#DIV/0!`. Excel shows it as is, whatever the number format.
+    Error(Arc<str>),
     Bool(bool),
     DateTime(chrono::NaiveDateTime),
     Date(chrono::NaiveDate),
@@ -41,7 +45,7 @@ impl RawValue {
             RawValue::Empty => None,
             RawValue::Int(v) => Some(v.to_string()),
             RawValue::Float(v) => Some(v.to_string()),
-            RawValue::String(v) => Some(v.to_string()),
+            RawValue::String(v) | RawValue::Error(v) => Some(v.to_string()),
             RawValue::Bool(v) => Some(if *v {
                 "TRUE".to_string()
             } else {
@@ -219,6 +223,8 @@ pub struct CellGrid {
     // `coord` and `merge_parent` use them and the offsets are 0.
     pub(crate) row_coords: Option<Vec<i32>>,
     pub(crate) col_coords: Option<Vec<i32>>,
+    // Gap compression removed rows or columns across frozen panes or inside merges.
+    pub(crate) gap_unpinned: bool,
 
     // Formula cells with no cached value in the source sheet. None when unknown
     // (non-xlsx, dense path, or a derived grid).
@@ -244,7 +250,7 @@ impl CellGrid {
             .iter()
             .enumerate()
             .map(|(idx, value)| match value {
-                RawValue::String(s) => {
+                RawValue::String(s) | RawValue::Error(s) => {
                     let style = styles.as_ref().map(|sv| sv.get(idx));
                     style.is_some_and(|st| st.font_bold || st.font_underline) || s.ends_with(':')
                 }
@@ -271,6 +277,7 @@ impl CellGrid {
             anchor_offset: (0, 0),
             row_coords: None,
             col_coords: None,
+            gap_unpinned: false,
             uncached_formula_count: None,
         }
     }
@@ -495,7 +502,7 @@ impl CellGrid {
         let column = match field.parse::<Field>()? {
             Field::Value => self.object_column(
                 py,
-                py_strs(py, self.formatted_values.iter().map(|v| v.as_deref())),
+                py_strs(py, self.formatted_values.iter().map(Option::as_ref)),
             ),
             Field::Header => self.bool_column(py, self.header.clone()),
             Field::TableMember => self.bool_column(py, self.table_member.clone()),
@@ -780,10 +787,32 @@ impl FromStr for Field {
     }
 }
 
-/// Python objects for optional strings: `str`, or `None`.
-fn py_strs<'a>(py: Python<'_>, values: impl Iterator<Item = Option<&'a str>>) -> Vec<PyObject> {
+/// No date text is longer, so `apply_dateutil_reformat` does not parse a longer string.
+const MAX_DATE_TEXT_CHARS: usize = 64;
+
+/// The date serial of `text` from the Python `date_parse` callback, or `None`.
+fn date_serial(date_parse: &Bound<'_, PyAny>, text: &str) -> PyResult<Option<f64>> {
+    let result = date_parse.call1((text,))?;
+    if result.is_none() {
+        return Ok(None);
+    }
+    Ok(Some(result.extract()?))
+}
+
+/// Python objects for optional strings: `str`, or `None`. The cells that share one
+/// `Arc` share one Python string, so a long text in many cells is not copied per cell.
+fn py_strs<'a>(
+    py: Python<'_>,
+    values: impl Iterator<Item = Option<&'a Arc<str>>>,
+) -> Vec<PyObject> {
+    // Keyed by address: the caller holds every `Arc` until the end of the call.
+    let mut shared: HashMap<*const u8, PyObject> = HashMap::new();
     values
         .map(|v| match v {
+            Some(s) if Arc::strong_count(s) > 1 => shared
+                .entry(Arc::as_ptr(s).cast::<u8>())
+                .or_insert_with(|| PyString::new(py, s).into_any().unbind())
+                .clone_ref(py),
             Some(s) => PyString::new(py, s).into_any().unbind(),
             None => py.None(),
         })
@@ -829,6 +858,14 @@ impl CellGrid {
         )
     }
 
+    /// Whether gap compression removed rows or columns across frozen panes or inside
+    /// merges, to keep the grid under `max_grid_cells`. The API output can then differ
+    /// from the uncompressed grid, which was too large to build.
+    #[getter]
+    fn gap_unpinned(&self) -> bool {
+        self.gap_unpinned
+    }
+
     /// Formula cells with no cached value, counted by `get_sheet_grid_streaming`.
     /// `None` when unknown (non-xlsx workbook or a grid from another builder).
     #[getter]
@@ -974,6 +1011,9 @@ impl CellGrid {
 
         // Cache parsed NumberFormat objects to avoid re-parsing the same format string
         let mut format_cache: HashMap<Arc<str>, Option<NumberFormat>> = HashMap::new();
+        // The formatted text of a shared string, keyed by the addresses of the string and
+        // its format code. Both stay in `raw_values` and `styles` for the whole call.
+        let mut text_cache: HashMap<(*const u8, *const u8), Arc<str>> = HashMap::new();
 
         for idx in 0..self.raw_values.len() {
             if self.raw_values[idx].is_empty() {
@@ -981,6 +1021,12 @@ impl CellGrid {
                 continue;
             }
 
+            // A number format does not apply to an error value.
+            if let RawValue::Error(e) = &self.raw_values[idx] {
+                self.formatted_values[idx] = Some(e.clone());
+                continue;
+            }
+
             let nf: &str = self
                 .styles
                 .as_ref()
@@ -1035,12 +1081,31 @@ impl CellGrid {
                     let parsed = format_cache
                         .entry(nf_arc.clone())
                         .or_insert_with(|| NumberFormat::parse(nf_arc.as_ref()).ok());
-                    if let Some(fmt) = parsed {
-                        self.formatted_values[idx] =
-                            Some(Arc::from(fmt.format_text(s.as_ref(), &opts).as_str()));
-                    } else {
+                    let Some(fmt) = parsed else {
                         self.formatted_values[idx] = Some(s.clone());
-                    }
+                        continue;
+                    };
+                    let key = (
+                        Arc::as_ptr(s).cast::<u8>(),
+                        Arc::as_ptr(&nf_arc).cast::<u8>(),
+                    );
+                    let formatted = match text_cache.get(&key) {
+                        Some(text) => text.clone(),
+                        None => {
+                            let text = fmt.format_text(s.as_ref(), &opts);
+                            // Most formats return a text cell unchanged: keep the one copy.
+                            let text: Arc<str> = if text == **s {
+                                s.clone()
+                            } else {
+                                Arc::from(text)
+                            };
+                            if Arc::strong_count(s) > 1 {
+                                text_cache.insert(key, text.clone());
+                            }
+                            text
+                        }
+                    };
+                    self.formatted_values[idx] = Some(formatted);
                     continue;
                 }
                 RawValue::DateTime(dt) => {
@@ -1068,7 +1133,7 @@ impl CellGrid {
                     let nanos = td.subsec_nanos() as f64 / 1_000_000_000.0;
                     (secs + nanos) / 86400.0
                 }
-                RawValue::Bool(_) | RawValue::Empty => unreachable!(),
+                RawValue::Error(_) | RawValue::Bool(_) | RawValue::Empty => unreachable!(),
             };
 
             // Look up or parse the format code
@@ -1099,12 +1164,18 @@ impl CellGrid {
 
     /// Reformat string cells with date format codes using a Python dateutil callback.
     ///
+    /// Deprecated: text cells keep their text, as in Excel; the API no longer calls it.
+    /// It still works for callers that pin an older API.
+    ///
     /// Matches Python SSF behavior: when a string value has a date format,
     /// parse the string as a date via dateutil, convert to serial number,
-    /// and reformat with ssfmt.
+    /// and reformat with ssfmt. An error value is not a string, so it keeps its text.
     ///
     /// Callback signature: date_parse(string) -> Optional[float]
     ///   Returns a date serial number or None if parsing fails.
+    ///
+    /// The callback runs once for each distinct string. A string above
+    /// `MAX_DATE_TEXT_CHARS` is not a date, so the callback does not get it.
     fn apply_dateutil_reformat(
         &mut self,
         _py: Python<'_>,
@@ -1114,11 +1185,12 @@ impl CellGrid {
 
         let opts = FormatOptions::default();
         let mut format_cache: HashMap<Arc<str>, Option<NumberFormat>> = HashMap::new();
+        let mut serials: HashMap<Arc<str>, Option<f64>> = HashMap::new();
 
         for idx in 0..self.raw_values.len() {
             // Only process string values
             let s = match &self.raw_values[idx] {
-                RawValue::String(s) => s.clone(),
+                RawValue::String(s) if !longer_than(s, MAX_DATE_TEXT_CHARS) => s.clone(),
                 _ => continue,
             };
 
@@ -1144,12 +1216,17 @@ impl CellGrid {
                 continue;
             }
 
-            // Call Python dateutil callback: date_parse(string) -> Optional[float]
-            let result = date_parse.call1((s.as_ref(),))?;
-            if result.is_none() {
+            let serial = match serials.get(&s) {
+                Some(&serial) => serial,
+                None => {
+                    let serial = date_serial(date_parse, &s)?;
+                    serials.insert(s, serial);
+                    serial
+                }
+            };
+            let Some(serial) = serial else {
                 continue;
-            }
-            let serial: f64 = result.extract()?;
+            };
 
             // Reformat with ssfmt
             let formatted = fmt.format(serial, &opts);
@@ -1162,9 +1239,10 @@ impl CellGrid {
     /// For large sheets: store raw values directly as display strings (no SSF).
     fn apply_raw_as_formatted(&mut self) {
         for idx in 0..self.raw_values.len() {
-            self.formatted_values[idx] = self.raw_values[idx]
-                .to_display_string()
-                .map(|s| Arc::from(s.as_str()));
+            self.formatted_values[idx] = match &self.raw_values[idx] {
+                RawValue::String(s) | RawValue::Error(s) => Some(s.clone()),
+                raw => raw.to_display_string().map(Arc::from),
+            };
         }
     }
 
@@ -1295,7 +1373,7 @@ impl CellGrid {
         // the grid has drained and arr's other columns are already filled —
         // maximises headroom at the largest single allocation.
         let formatted = take(&mut self.formatted_values);
-        let objects = py_strs(py, formatted.iter().map(|v| v.as_deref()));
+        let objects = py_strs(py, formatted.iter().map(Option::as_ref));
         drop(formatted);
         set(Field::Value, self.object_column(py, objects)?)?;
 
@@ -1318,3 +1396,111 @@ impl CellProxy {
         grid.cell_field(py, self.row, self.col, key)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::sync::Arc;
+
+    use super::{CellGrid, CellStyle, CellStyles, RawValue};
+
+    const ERRORS: [&str; 8] = [
+        "#DIV/0!",
+        "#N/A",
+        "#NAME?",
+        "#NULL!",
+        "#NUM!",
+        "#REF!",
+        "#VALUE!",
+        "#GETTING_DATA",
+    ];
+    const FORMATS: [&str; 5] = [
+        ";;;",
+        "@\" sf\"",
+        "0\" sf\";-0\" sf\";0\" sf\";@\" sf\"",
+        "mm-dd-yy",
+        "General",
+    ];
+
+    /// One row for each value, one column for each format in `FORMATS`.
+    fn grid(values: &[RawValue]) -> CellGrid {
+        let cols = FORMATS.len();
+        let raw = values
+            .iter()
+            .flat_map(|v| std::iter::repeat_n(v.clone(), cols))
+            .collect();
+        let palette = FORMATS
+            .iter()
+            .map(|nf| CellStyle {
+                number_format: Arc::from(*nf),
+                ..CellStyle::default()
+            })
+            .collect();
+        let ids = (0..values.len() * cols)
+            .map(|i| (i % cols) as u32)
+            .collect();
+        let styles = CellStyles { ids, palette };
+        CellGrid::with_values(
+            values.len(),
+            cols,
+            raw,
+            Some(styles),
+            HashMap::new(),
+            (0, 0),
+        )
+    }
+
+    fn row(grid: &CellGrid, row: usize) -> Vec<Option<&str>> {
+        (0..grid.cols)
+            .map(|col| grid.formatted_values[row * grid.cols + col].as_deref())
+            .collect()
+    }
+
+    #[test]
+    fn error_values_ignore_the_number_format() {
+        let values: Vec<RawValue> = ERRORS
+            .iter()
+            .map(|e| RawValue::Error(Arc::from(*e)))
+            .collect();
+        let mut grid = grid(&values);
+        grid.apply_formatting_rust();
+        for (i, error) in ERRORS.iter().enumerate() {
+            assert_eq!(row(&grid, i), vec![Some(*error); FORMATS.len()]);
+        }
+    }
+
+    #[test]
+    fn text_and_numbers_keep_their_formatting() {
+        let mut grid = grid(&[RawValue::String(Arc::from("abc")), RawValue::Float(45000.5)]);
+        grid.apply_formatting_rust();
+        assert_eq!(
+            row(&grid, 0),
+            vec![
+                Some(""),
+                Some("abc sf"),
+                Some("abc sf"),
+                Some("abc"),
+                Some("abc")
+            ]
+        );
+        assert_eq!(
+            row(&grid, 1),
+            vec![
+                Some(""),
+                Some("45000.5"),
+                Some("45001 sf"),
+                Some("03-15-23"),
+                Some("45000.5")
+            ]
+        );
+    }
+
+    #[test]
+    fn raw_display_of_an_error_is_its_text() {
+        let error = RawValue::Error(Arc::from("#REF!"));
+        assert_eq!(error.to_display_string().as_deref(), Some("#REF!"));
+        let mut grid = grid(&[error]);
+        grid.apply_raw_as_formatted();
+        assert_eq!(row(&grid, 0), vec![Some("#REF!"); FORMATS.len()]);
+    }
+}