exstruct 0.2.80__py3-none-any.whl → 0.3.2__py3-none-any.whl

exstruct/engine.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 from collections.abc import Iterator
 from contextlib import contextmanager
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Literal, TextIO, TypedDict, cast
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field
 
 from .core import cells as _cells
 from .core.cells import set_table_detection_params
@@ -30,6 +30,32 @@ class TableParams(TypedDict, total=False):
     min_nonempty_cells: int
 
 
+class ColorsOptions(BaseModel):
+    """Color extraction options.
+
+    Examples:
+        >>> ColorsOptions(
+        ...     include_default_background=False,
+        ...     ignore_colors=["#FFFFFF", "AD3815", "theme:1:0.2", "indexed:64", "auto"],
+        ... )
+    """
+
+    include_default_background: bool = Field(
+        default=False, description="Include default (white) backgrounds."
+    )
+    ignore_colors: list[str] = Field(
+        default_factory=list, description="List of color keys to ignore."
+    )
+
+    def ignore_colors_set(self) -> set[str]:
+        """Return ignore_colors as a set of normalized strings.
+
+        Returns:
+            Set of color keys to ignore.
+        """
+        return set(self.ignore_colors)
+
+
 @dataclass(frozen=True)
 class StructOptions:
     """
@@ -43,6 +69,9 @@ class StructOptions:
         table_params: Optional dict passed to `set_table_detection_params(**table_params)`
                       before extraction. Use this to tweak table detection heuristics
                       per engine instance without touching global state.
+        include_colors_map: Whether to extract background color maps.
+        include_merged_cells: Whether to extract merged cell ranges.
+        colors: Color extraction options.
     """
 
     mode: ExtractionMode = "standard"
@@ -50,6 +79,9 @@ class StructOptions:
         None  # forwarded to set_table_detection_params if provided
     )
     include_cell_links: bool | None = None  # None -> auto: verbose=True, others=False
+    include_colors_map: bool | None = None  # None -> auto: verbose=True, others=False
+    include_merged_cells: bool | None = None  # None -> auto: light=False, others=True
+    colors: ColorsOptions = field(default_factory=ColorsOptions)
 
 
 class FormatOptions(BaseModel):
@@ -91,6 +123,9 @@ class FilterOptions(BaseModel):
     include_auto_print_areas: bool = Field(
         default=False, description="Include COM-computed auto page-break areas."
     )
+    include_merged_cells: bool = Field(
+        default=True, description="Include merged cell ranges."
+    )
 
 
 class DestinationOptions(BaseModel):
@@ -118,11 +153,10 @@ class OutputOptions(BaseModel):
     - format: serialization format/indent.
     - filters: include/exclude flags (rows/shapes/charts/tables/print_areas, size flags).
     - destinations: side outputs (per-sheet, per-print-area, stream override).
-
-    Legacy flat fields (fmt, pretty, indent, include_*, sheets_dir, print_areas_dir, stream)
-    are still accepted and normalized into the nested structures.
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     format: FormatOptions = Field(
         default_factory=FormatOptions, description="Formatting options."
     )
@@ -133,112 +167,6 @@ class OutputOptions(BaseModel):
         default_factory=DestinationOptions, description="Side output destinations."
     )
 
-    @model_validator(mode="before")
-    @classmethod
-    def _coerce_legacy(cls, values: dict[str, object]) -> dict[str, object]:
-        if not isinstance(values, dict):
-            return values
-        # Normalize legacy flat fields into nested configs
-        fmt_cfg = {
-            "fmt": values.pop("fmt", None),
-            "pretty": values.pop("pretty", None),
-            "indent": values.pop("indent", None),
-        }
-        filt_cfg = {
-            "include_rows": values.pop("include_rows", None),
-            "include_shapes": values.pop("include_shapes", None),
-            "include_shape_size": values.pop("include_shape_size", None),
-            "include_charts": values.pop("include_charts", None),
-            "include_chart_size": values.pop("include_chart_size", None),
-            "include_tables": values.pop("include_tables", None),
-            "include_print_areas": values.pop("include_print_areas", None),
-        }
-        dest_cfg = {
-            "sheets_dir": values.pop("sheets_dir", None),
-            "print_areas_dir": values.pop("print_areas_dir", None),
-            "auto_page_breaks_dir": values.pop("auto_page_breaks_dir", None),
-            "stream": values.pop("stream", None),
-        }
-        # Drop None to let defaults apply
-        fmt_cfg = {k: v for k, v in fmt_cfg.items() if v is not None}
-        filt_cfg = {k: v for k, v in filt_cfg.items() if v is not None}
-        dest_cfg = {k: v for k, v in dest_cfg.items() if v is not None}
-
-        merged = dict(values)
-        if "format" not in merged and fmt_cfg:
-            merged["format"] = fmt_cfg
-        if "filters" not in merged and filt_cfg:
-            merged["filters"] = filt_cfg
-        if "destinations" not in merged and dest_cfg:
-            merged["destinations"] = dest_cfg
-        return merged
-
-    # Legacy compatibility properties
-    @property
-    def fmt(self) -> Literal["json", "yaml", "yml", "toon"]:
-        return self.format.fmt
-
-    @property
-    def pretty(self) -> bool:
-        return self.format.pretty
-
-    @property
-    def indent(self) -> int | None:
-        return self.format.indent
-
-    @property
-    def include_rows(self) -> bool:
-        return self.filters.include_rows
-
-    @property
-    def include_shapes(self) -> bool:
-        return self.filters.include_shapes
-
-    @property
-    def include_shape_size(self) -> bool | None:
-        return self.filters.include_shape_size
-
-    @property
-    def include_charts(self) -> bool:
-        return self.filters.include_charts
-
-    @property
-    def include_chart_size(self) -> bool | None:
-        return self.filters.include_chart_size
-
-    @property
-    def include_tables(self) -> bool:
-        return self.filters.include_tables
-
-    @property
-    def include_print_areas(self) -> bool | None:
-        return self.filters.include_print_areas
-
-    @property
-    def sheets_dir(self) -> Path | None:
-        resolved = self.destinations.sheets_dir
-        if resolved is None:
-            return None
-        return resolved if isinstance(resolved, Path) else Path(resolved)
-
-    @property
-    def print_areas_dir(self) -> Path | None:
-        resolved = self.destinations.print_areas_dir
-        if resolved is None:
-            return None
-        return resolved if isinstance(resolved, Path) else Path(resolved)
-
-    @property
-    def stream(self) -> TextIO | None:
-        return self.destinations.stream
-
-    @property
-    def auto_page_breaks_dir(self) -> Path | None:
-        resolved = self.destinations.auto_page_breaks_dir
-        if resolved is None:
-            return None
-        return resolved if isinstance(resolved, Path) else Path(resolved)
-
 
 class ExStructEngine:
     """
@@ -353,8 +281,12 @@ class ExStructEngine:
             table_candidates=sheet.table_candidates
             if self.output.filters.include_tables
             else [],
+            colors_map=sheet.colors_map,
             print_areas=sheet.print_areas if include_print_areas else [],
             auto_print_areas=sheet.auto_print_areas if include_auto_print_areas else [],
+            merged_cells=sheet.merged_cells
+            if self.output.filters.include_merged_cells
+            else [],
         )
 
     def _filter_workbook(
@@ -409,14 +341,6 @@ class ExStructEngine:
                 - verbose: All shapes (with size) and charts (with size).
         """
         chosen_mode = mode or self.options.mode
-        if chosen_mode not in ("light", "standard", "verbose"):
-            raise ValueError(f"Unsupported mode: {chosen_mode}")
-        include_links = (
-            self.options.include_cell_links
-            if self.options.include_cell_links is not None
-            else chosen_mode == "verbose"
-        )
-        include_print_areas = True  # Extract print areas even in light mode
         include_auto_page_breaks = (
             self.output.filters.include_auto_print_areas
             or self.output.destinations.auto_page_breaks_dir is not None
@@ -426,9 +350,13 @@ class ExStructEngine:
             return extract_workbook(
                 normalized_file_path,
                 mode=chosen_mode,
-                include_cell_links=include_links,
-                include_print_areas=include_print_areas,
+                include_cell_links=self.options.include_cell_links,
+                include_print_areas=None,
                 include_auto_page_breaks=include_auto_page_breaks,
+                include_colors_map=self.options.include_colors_map,
+                include_default_background=self.options.colors.include_default_background,
+                ignore_colors=self.options.colors.ignore_colors_set(),
+                include_merged_cells=self.options.include_merged_cells,
             )
 
     def serialize(
@@ -444,7 +372,7 @@ class ExStructEngine:
 
         Args:
             data: Workbook to serialize after filtering.
-            fmt: Serialization format; defaults to OutputOptions.fmt.
+            fmt: Serialization format; defaults to OutputOptions.format.fmt.
             pretty: Whether to pretty-print JSON output.
             indent: Indentation to use when pretty-printing JSON.
         """
@@ -478,7 +406,7 @@ class ExStructEngine:
         Args:
             data: Workbook to serialize and write.
             output_path: Target file path (str or Path); writes to stdout when None.
-            fmt: Serialization format; defaults to OutputOptions.fmt.
+            fmt: Serialization format; defaults to OutputOptions.format.fmt.
             pretty: Whether to pretty-print JSON output.
             indent: Indentation to use when pretty-printing JSON.
             sheets_dir: Directory for per-sheet outputs when provided (str or Path).

exstruct/errors.py

@@ -1,6 +1,8 @@
+"""Project-specific exception hierarchy for ExStruct."""
+
 from __future__ import annotations
 
-"""Project-specific exception hierarchy for ExStruct."""
+from enum import Enum
 
 
 class ExstructError(Exception):
@@ -33,3 +35,12 @@ class OutputError(ExstructError):
 
 class PrintAreaError(ExstructError, ValueError):
     """Raised when print-area specific processing fails (also a ValueError for compatibility)."""
+
+
+class FallbackReason(str, Enum):
+    """Reason codes for extraction fallbacks."""
+
+    LIGHT_MODE = "light_mode"
+    SKIP_COM_TESTS = "skip_com_tests"
+    COM_UNAVAILABLE = "com_unavailable"
+    COM_PIPELINE_FAILED = "com_pipeline_failed"

exstruct/io/__init__.py

@@ -1,24 +1,46 @@
 from __future__ import annotations
 
-import importlib
-import json
 import logging
 from pathlib import Path
 import re
-from types import ModuleType
 from typing import Literal, cast
 
-from openpyxl.utils import range_boundaries
-
-from ..errors import MissingDependencyError, OutputError, SerializationError
-from ..models import CellRow, Chart, PrintArea, PrintAreaView, Shape, WorkbookData
+from ..core.ranges import RangeBounds, parse_range_zero_based
+from ..errors import OutputError, SerializationError
+from ..models import (
+    Arrow,
+    CellRow,
+    Chart,
+    PrintArea,
+    PrintAreaView,
+    Shape,
+    SmartArt,
+    WorkbookData,
+)
 from ..models.types import JsonStructure
+from .serialize import (
+    _FORMAT_HINTS,
+    _ensure_format_hint,
+    _require_toon,
+    _require_yaml,
+    _serialize_payload_from_hint,
+)
 
 logger = logging.getLogger(__name__)
 
 
 def dict_without_empty_values(obj: object) -> JsonStructure:
-    """Recursively drop empty values from nested structures."""
+    """
+    Remove None, empty string, empty list, and empty dict values from a nested structure or supported model object.
+
+    Recursively processes dicts, lists, and supported model types (WorkbookData, CellRow, Chart, PrintArea, PrintAreaView, Shape, Arrow, SmartArt). Model instances are converted to dictionaries with None fields excluded before recursive cleaning. Values considered empty and removed are: `None`, `""` (empty string), `[]` (empty list), and `{}` (empty dict).
+
+    Parameters:
+        obj (object): A value to clean; may be a dict, list, scalar, or one of the supported model instances.
+
+    Returns:
+        JsonStructure: The input structure with empty values removed, preserving other values and nesting.
+    """
     if isinstance(obj, dict):
         return {
             k: dict_without_empty_values(v)
@@ -31,7 +53,14 @@ def dict_without_empty_values(obj: object) -> JsonStructure:
         ]
     if isinstance(
         obj,
-        WorkbookData | CellRow | Chart | PrintArea | PrintAreaView | Shape,
+        WorkbookData
+        | CellRow
+        | Chart
+        | PrintArea
+        | PrintAreaView
+        | Shape
+        | Arrow
+        | SmartArt,
     ):
         return dict_without_empty_values(obj.model_dump(exclude_none=True))
     return cast(JsonStructure, obj)
@@ -68,21 +97,16 @@ def _sanitize_sheet_filename(name: str) -> str:
     return safe or "sheet"
 
 
-def _parse_range_zero_based(range_str: str) -> tuple[int, int, int, int] | None:
-    """
-    Parse an Excel range string into zero-based (r1, c1, r2, c2) bounds.
-    Returns None on failure.
+def _parse_range_zero_based(range_str: str) -> RangeBounds | None:
+    """Parse an Excel range string into zero-based bounds.
+
+    Args:
+        range_str: Excel range string (e.g., "Sheet1!A1:B2").
+
+    Returns:
+        RangeBounds in zero-based coordinates, or None on failure.
     """
-    cleaned = range_str.strip()
-    if not cleaned:
-        return None
-    if "!" in cleaned:
-        cleaned = cleaned.split("!", 1)[1]
-    try:
-        min_col, min_row, max_col, max_row = range_boundaries(cleaned)
-    except Exception:
-        return None
-    return (min_row - 1, min_col - 1, max_row - 1, max_col - 1)
+    return parse_range_zero_based(range_str)
 
 
 def _row_in_area(row: CellRow, area: PrintArea) -> bool:
@@ -132,8 +156,14 @@ def _filter_table_candidates_to_area(
         bounds = _parse_range_zero_based(candidate)
         if not bounds:
             continue
-        r1, c1, r2, c2 = bounds
-        if r1 >= area.r1 and r2 <= area.r2 and c1 >= area.c1 and c2 <= area.c2:
+        r1 = bounds.r1 + 1
+        r2 = bounds.r2 + 1
+        if (
+            r1 >= area.r1
+            and r2 <= area.r2
+            and bounds.c1 >= area.c1
+            and bounds.c2 <= area.c2
+        ):
             filtered.append(candidate)
     return filtered
 
@@ -146,20 +176,46 @@ def _area_to_px_rect(
     Uses default Excel-like cell sizes; accuracy is highest when shapes/charts are COM-extracted.
     """
     left = area.c1 * col_px
-    top = area.r1 * row_px
+    top = (area.r1 - 1) * row_px
     right = (area.c2 + 1) * col_px
-    bottom = (area.r2 + 1) * row_px
+    bottom = area.r2 * row_px
     return left, top, right, bottom
 
 
 def _rects_overlap(a: tuple[int, int, int, int], b: tuple[int, int, int, int]) -> bool:
-    """Return True if rectangles (l, t, r, b) overlap."""
+    """
+    Determine whether two axis-aligned rectangles intersect (overlap in area).
+
+    Parameters:
+        a (tuple[int, int, int, int]): Rectangle A as (left, top, right, bottom).
+        b (tuple[int, int, int, int]): Rectangle B as (left, top, right, bottom).
+
+    Notes:
+        Rectangles are treated as half-open in this context: if they only touch at edges or corners, they do not count as overlapping.
+
+    Returns:
+        bool: `True` if the rectangles have a non-zero-area intersection, `False` otherwise.
+    """
     return not (a[2] <= b[0] or a[0] >= b[2] or a[3] <= b[1] or a[1] >= b[3])
 
 
-def _filter_shapes_to_area(shapes: list[Shape], area: PrintArea) -> list[Shape]:
+def _filter_shapes_to_area(
+    shapes: list[Shape | Arrow | SmartArt], area: PrintArea
+) -> list[Shape | Arrow | SmartArt]:
+    """
+    Filter drawable shapes to those that intersect the given print area.
+
+    Shapes and the print area are compared in approximate pixel coordinates. Shapes that have both width and height are included when their bounding rectangle overlaps the area. Shapes with unknown size (width or height is None) are treated as a point at their left/top coordinates and included only if that point lies inside the area.
+
+    Parameters:
+        shapes (list[Shape | Arrow | SmartArt]): Drawable objects with `l`, `t`, `w`, `h` coordinates.
+        area (PrintArea): Cell-based print area that will be converted to an approximate pixel rectangle.
+
+    Returns:
+        list[Shape | Arrow | SmartArt]: Subset of `shapes` whose geometry intersects the print area.
+    """
     area_rect = _area_to_px_rect(area)
-    filtered: list[Shape] = []
+    filtered: list[Shape | Arrow | SmartArt] = []
     for shp in shapes:
         if shp.w is None or shp.h is None:
             # Fallback: treat shape as a point if size is unknown (standard mode).
@@ -281,13 +337,12 @@ def save_print_area_views(
     Save each print area as an individual file in the specified format.
     Returns a map of area key (e.g., 'Sheet1#1') to written path.
     """
-    format_hint = fmt.lower()
-    if format_hint == "yml":
-        format_hint = "yaml"
-    if format_hint not in ("json", "yaml", "toon"):
-        raise SerializationError(
-            f"Unsupported print-area export format '{fmt}'. Allowed: json, yaml, yml, toon."
-        )
+    format_hint = _ensure_format_hint(
+        fmt,
+        allowed=_FORMAT_HINTS,
+        error_type=SerializationError,
+        error_message="Unsupported print-area export format '{fmt}'. Allowed: json, yaml, yml, toon.",
+    )
 
     views = build_print_area_views(
         workbook,
@@ -314,18 +369,10 @@ def save_print_area_views(
                 f"_area{idx + 1}_r{area.r1}-{area.r2}_c{area.c1}-{area.c2}{suffix}"
             )
             path = output_dir / file_name
-            match format_hint:
-                case "json":
-                    indent_val = 2 if pretty and indent is None else indent
-                    text = view.to_json(pretty=pretty, indent=indent_val)
-                case "yaml":
-                    text = view.to_yaml()
-                case "toon":
-                    text = view.to_toon()
-                case _:
-                    raise SerializationError(
-                        f"Unsupported print-area export format '{fmt}'. Allowed: json, yaml, yml, toon."
-                    )
+            payload = dict_without_empty_values(view.model_dump(exclude_none=True))
+            text = _serialize_payload_from_hint(
+                payload, format_hint, pretty=pretty, indent=indent
+            )
             _write_text(path, text)
             written[key] = path
     return written
@@ -348,13 +395,12 @@ def save_auto_page_break_views(
     Save auto page-break areas (computed via Excel COM) per sheet in the specified format.
     Returns a map of area key (e.g., 'Sheet1#auto#1') to written path.
     """
-    format_hint = fmt.lower()
-    if format_hint == "yml":
-        format_hint = "yaml"
-    if format_hint not in ("json", "yaml", "toon"):
-        raise SerializationError(
-            f"Unsupported auto page-break export format '{fmt}'. Allowed: json, yaml, yml, toon."
-        )
+    format_hint = _ensure_format_hint(
+        fmt,
+        allowed=_FORMAT_HINTS,
+        error_type=SerializationError,
+        error_message="Unsupported auto page-break export format '{fmt}'. Allowed: json, yaml, yml, toon.",
+    )
 
     views = _iter_area_views(
         workbook,
@@ -382,18 +428,10 @@ def save_auto_page_break_views(
                 f"_auto_page{idx + 1}_r{area.r1}-{area.r2}_c{area.c1}-{area.c2}{suffix}"
             )
             path = output_dir / file_name
-            match format_hint:
-                case "json":
-                    indent_val = 2 if pretty and indent is None else indent
-                    text = view.to_json(pretty=pretty, indent=indent_val)
-                case "yaml":
-                    text = view.to_yaml()
-                case "toon":
-                    text = view.to_toon()
-                case _:
-                    raise SerializationError(
-                        f"Unsupported auto page-break export format '{fmt}'. Allowed: json, yaml, yml, toon."
-                    )
+            payload = dict_without_empty_values(view.model_dump(exclude_none=True))
+            text = _serialize_payload_from_hint(
+                payload, format_hint, pretty=pretty, indent=indent
+            )
             _write_text(path, text)
             written[key] = path
     return written
@@ -409,32 +447,16 @@ def serialize_workbook(
     """
     Convert WorkbookData to string in the requested format without writing to disk.
     """
-    format_hint = fmt.lower()
-    if format_hint == "yml":
-        format_hint = "yaml"
+    format_hint = _ensure_format_hint(
+        fmt,
+        allowed=_FORMAT_HINTS,
+        error_type=SerializationError,
+        error_message="Unsupported export format '{fmt}'. Allowed: json, yaml, yml, toon.",
+    )
     filtered_dict = dict_without_empty_values(model.model_dump(exclude_none=True))
-
-    match format_hint:
-        case "json":
-            indent_val = 2 if pretty and indent is None else indent
-            return json.dumps(filtered_dict, ensure_ascii=False, indent=indent_val)
-        case "yaml":
-            yaml = _require_yaml()
-            return str(
-                yaml.safe_dump(
-                    filtered_dict,
-                    allow_unicode=True,
-                    sort_keys=False,
-                    indent=2,
-                )
-            )
-        case "toon":
-            toon = _require_toon()
-            return str(toon.encode(filtered_dict))
-        case _:
-            raise SerializationError(
-                f"Unsupported export format '{fmt}'. Allowed: json, yaml, yml, toon."
-            )
+    return _serialize_payload_from_hint(
+        filtered_dict, format_hint, pretty=pretty, indent=indent
+    )
 
 
 def save_sheets_as_json(
@@ -461,8 +483,10 @@ def save_sheets_as_json(
         )
         file_name = f"{_sanitize_sheet_filename(sheet_name)}.json"
         path = output_dir / file_name
-        indent_val = 2 if pretty and indent is None else indent
-        _write_text(path, json.dumps(payload, ensure_ascii=False, indent=indent_val))
+        text = _serialize_payload_from_hint(
+            payload, "json", pretty=pretty, indent=indent
+        )
+        _write_text(path, text)
         written[sheet_name] = path
     return written
 
@@ -479,11 +503,12 @@ def save_sheets(
     Save each sheet as an individual file in the specified format (json/yaml/toon).
     Payload includes book_name and the sheet's SheetData.
     """
-    format_hint = fmt.lower()
-    if format_hint == "yml":
-        format_hint = "yaml"
-    if format_hint not in ("json", "yaml", "toon"):
-        raise ValueError(f"Unsupported sheet export format: {fmt}")
+    format_hint = _ensure_format_hint(
+        fmt,
+        allowed=_FORMAT_HINTS,
+        error_type=SerializationError,
+        error_message="Unsupported sheet export format: {fmt}",
+    )
 
     output_dir.mkdir(parents=True, exist_ok=True)
     written: dict[str, Path] = {}
@@ -498,49 +523,14 @@ def save_sheets(
         suffix = {"json": ".json", "yaml": ".yaml", "toon": ".toon"}[format_hint]
         file_name = f"{_sanitize_sheet_filename(sheet_name)}{suffix}"
         path = output_dir / file_name
-        match format_hint:
-            case "json":
-                indent_val = 2 if pretty and indent is None else indent
-                text = json.dumps(payload, ensure_ascii=False, indent=indent_val)
-            case "yaml":
-                yaml = _require_yaml()
-                text = str(
-                    yaml.safe_dump(
-                        payload, allow_unicode=True, sort_keys=False, indent=2
-                    )
-                )
-            case "toon":
-                toon = _require_toon()
-                text = str(toon.encode(payload))
-            case _:
-                raise SerializationError(
-                    f"Unsupported sheet export format '{format_hint}'. Allowed: json, yaml, yml, toon."
-                )
+        text = _serialize_payload_from_hint(
+            payload, format_hint, pretty=pretty, indent=indent
+        )
         _write_text(path, text)
         written[sheet_name] = path
     return written
 
 
-def _require_yaml() -> ModuleType:
-    try:
-        module = importlib.import_module("yaml")
-    except ImportError as e:
-        raise MissingDependencyError(
-            "YAML export requires pyyaml. Install it via `pip install pyyaml` or add the 'yaml' extra."
-        ) from e
-    return module
-
-
-def _require_toon() -> ModuleType:
-    try:
-        module = importlib.import_module("toon")
-    except ImportError as e:
-        raise MissingDependencyError(
-            "TOON export requires python-toon. Install it via `pip install python-toon` or add the 'toon' extra."
-        ) from e
-    return module
-
-
 __all__ = [
     "dict_without_empty_values",
     "save_as_json",
@@ -552,4 +542,6 @@ __all__ = [
     "save_print_area_views",
     "save_auto_page_break_views",
     "serialize_workbook",
+    "_require_yaml",
+    "_require_toon",
 ]