numbers-parser 4.8.0__py3-none-any.whl → 4.9.0__py3-none-any.whl

numbers_parser/document.py

@@ -4,24 +4,28 @@ from warnings import warn
 from pendulum import DateTime, Duration
 
 from numbers_parser.cell import (
+    BackgroundImage,
     Border,
     Cell,
+    ControlFormattingType,
     CustomFormatting,
     CustomFormattingType,
-    DateCell,
     Formatting,
     FormattingType,
     MergedCell,
-    NumberCell,
     Style,
     TextCell,
     UnsupportedWarning,
     xl_cell_to_rowcol,
+    xl_range,
 )
 from numbers_parser.cell_storage import CellStorage
 from numbers_parser.constants import (
+    CUSTOM_FORMATTING_ALLOWED_CELLS,
     DEFAULT_COLUMN_COUNT,
     DEFAULT_ROW_COUNT,
+    FORMATTING_ACTION_CELLS,
+    FORMATTING_ALLOWED_CELLS,
     MAX_COL_COUNT,
     MAX_HEADER_COUNT,
     MAX_ROW_COUNT,
@@ -29,7 +33,7 @@ from numbers_parser.constants import (
 from numbers_parser.containers import ItemsList
 from numbers_parser.file import write_numbers_file
 from numbers_parser.model import _NumbersModel
-from numbers_parser.numbers_cache import Cacheable, cache
+from numbers_parser.numbers_cache import Cacheable
 
 __all__ = ["Document", "Sheet", "Table"]
 
@@ -197,20 +201,6 @@ class Document:
         If no style name is provided, the next available numbered style
         will be generated in the series ``Custom Style 1``, ``Custom Style 2``, etc.
 
-        Parameters
-        ----------
-        kwargs: dict, optional
-            Key-value pairs to pass to the :class:`Style` constructor
-
-        Raises
-        ------
-        TypeError:
-            If ``font_size`` is not a ``float``, ``font_name`` is not a ``str``,
-            or if any of the ``bool`` parameters are invalid.
-
-        Example
-        -------
-
         .. code-block:: python
 
             red_text = doc.add_style(
@@ -224,9 +214,27 @@ class Document:
             )
             table.write("B2", "Red", style=red_text)
             table.set_cell_style("C2", red_text)
+
+        Parameters
+        ----------
+        kwargs: dict, optional
+            Key-value pairs to pass to the :py:class:`~numbers_parser.Style` constructor.
+
+        Raises
+        ------
+        TypeError:
+            If ``font_size`` is not a ``float``, ``font_name`` is not a ``str``,
+            ``bg_image`` is not a :py:class:`~numbers_parser.BackgroundImage`,
+            or if any of the ``bool`` parameters are invalid.
         """  # noqa: E501
         if "name" in kwargs and kwargs["name"] is not None and kwargs["name"] in self._model.styles:
             raise IndexError(f"style '{kwargs['name']}' already exists")
+
+        if "bg_image" in kwargs and kwargs["bg_image"] is not None:
+            if not isinstance(kwargs["bg_image"], BackgroundImage):
+                raise TypeError("bg_image must be a BackgroundImage object")
+            self._model.store_image((kwargs["bg_image"].data), kwargs["bg_image"].filename)
+
         style = Style(**kwargs)
         if style.name is None:
             style.name = self._model.custom_style_name()
@@ -238,20 +246,28 @@ class Document:
         r"""
         Add a new custom format to the current document.
 
+        .. code-block:: python
+
+            long_date = doc.add_custom_format(
+                name="Long Date",
+                type="date",
+                date_time_format="EEEE, d MMMM yyyy"
+            )
+            table.set_cell_formatting("C1", "custom", format=long_date)
+
         All custom formatting styles share a name and a type, described in the **Common**
         parameters in the following table. Additional key-value pairs configure the format
-        depending upon the value of ``kwargs["type"]``. Supported values for
-        ``kwargs["type"]`` are:
-
-            * ``"datetime"``: A date and time value with custom formatting.
-            * ``"number"``: A decimal number.
-            * ``"text"``: A simple text string.
+        depending upon the value of ``kwargs["type"]``.
 
-        :Common Keys:
+        :Common Args:
             * **name** (``str``) – The name of the custom format. If no name is provided,
               one is generated using the scheme ``Custom Format``, ``Custom Format 1``, ``Custom Format 2``, etc.
             * **type** (``str``, *optional*, default: ``number``) – The type of format to
-              create Supported formats are ``number``, ``datetime`` and ``text``.
+              create:
+
+              * ``"datetime"``: A date and time value with custom formatting.
+              * ``"number"``: A decimal number.
+              * ``"text"``: A simple text string.
 
         :``"number"``:
             * **integer_format** (``PaddingType``, *optional*, default: ``PaddingType.NONE``) – How
@@ -273,17 +289,6 @@ class Document:
             * **format** (``str``, *optional*, default: ``"%s"``) – Text format.
               The cell value is inserted in place of %s. Only one substitution is allowed by
               Numbers, and multiple %s formatting references raise a TypeError exception
-
-        Example
-        -------
-
-        .. code-block:: python
-
-            long_date = doc.add_custom_format(
-                name="Long Date",
-                type="date",
-                date_time_format="EEEE, d MMMM yyyy")
-            table.set_cell_formatting("C1", "custom", format=long_date)
         """  # noqa: E501
         if (
             "name" in kwargs
@@ -312,11 +317,6 @@ class Document:
 
 
 class Sheet:
-    """
-    .. NOTE::
-       Do not instantiate directly. Sheets are created by :py:class:`~numbers_parser.Document`.
-    """
-
     def __init__(self, model, sheet_id):
         self._sheet_id = sheet_id
         self._model = model
@@ -408,11 +408,6 @@ class Sheet:
 
 
 class Table(Cacheable):  # noqa: F811
-    """
-    .. NOTE::
-       Do not instantiate directly. Tables are created by :py:class:`~numbers_parser.Document`.
-    """
-
     def __init__(self, model, table_id):
         super().__init__()
         self._model = model
@@ -461,6 +456,14 @@ class Table(Cacheable):  # noqa: F811
         """
         int: The number of header rows.
 
+        Example
+        -------
+
+        .. code-block:: python
+
+            # Add an extra header row
+            table.num_header_rows += 1
+
         Raises
         ------
         ValueError:
@@ -484,6 +487,14 @@ class Table(Cacheable):  # noqa: F811
         """
         int: The number of header columns.
 
+        Example
+        -------
+
+        .. code-block:: python
+
+            # Add an extra header column
+            table.num_header_cols += 1
+
         Raises
         ------
         ValueError:
@@ -516,6 +527,11 @@ class Table(Cacheable):  # noqa: F811
         """
         The height of a table row in points.
 
+        .. code-block:: python
+
+            # Double the row's height
+            _ = table.row_height(4, table.row_height(4) * 2)
+
         Parameters
         ----------
         row: int
@@ -571,7 +587,6 @@ class Table(Cacheable):  # noqa: F811
             return self._data
 
     @property
-    @cache(num_args=0)
     def merge_ranges(self) -> List[str]:
         """List[str]: The merge ranges of cells in A1 notation.
 
@@ -587,8 +602,13 @@ class Table(Cacheable):  # noqa: F811
             >>> table.cell("A5")
             <numbers_parser.cell.MergedCell object at 0x1035f5310>
         """
-        merge_cells = self._model.merge_cells(self._table_id).merge_cell_names()
-        return sorted(set(list(merge_cells)))
+        merge_cells = set()
+        for row, cells in enumerate(self._data):
+            for col, cell in enumerate(cells):
+                if cell.is_merged:
+                    size = cell.size
+                    merge_cells.add(xl_range(row, col, row + size[0] - 1, col + size[1] - 1))
+        return sorted(list(merge_cells))
 
     def cell(self, *args) -> Union[Cell, MergedCell]:
         """
@@ -804,20 +824,28 @@ class Table(Cacheable):  # noqa: F811
         The ``write()`` method supports two forms of notation to designate the position
         of cells: **Row-column** notation and **A1** notation:
 
-        .. code-block:: python
+        .. code:: python
 
-            (0, 0)      # Row-column notation.
-            ("A1")      # The same cell in A1 notation.
+            doc = Document("write.numbers")
+            sheets = doc.sheets
+            tables = sheets[0].tables
+            table = tables[0]
+            table.write(1, 1, "This is new text")
+            table.write("B7", datetime(2020, 12, 25))
+            doc.save("new-sheet.numbers")
 
         Parameters
         ----------
 
-        param1: int
+        row: int
             The row number (zero indexed)
-        param2: int
+        col: int
             The column number (zero indexed)
-        param3: str | int | float | bool | DateTime | Duration
-            The value to write to the cell. The generated cell type
+        value: str | int | float | bool | DateTime | Duration
+            The value to write to the cell. The generated cell type is automatically
+            created based on the type of ``value``.
+        style: Style | str | None
+            The name of a document custom style or a :py:class:`~numbers_parser.cell.Style` object.
 
         Warns
         -----
@@ -833,19 +861,6 @@ class Table(Cacheable):  # noqa: F811
             If the style parameter is an invalid type.
         ValueError:
             If the cell type cannot be determined from the type of `param3`.
-
-        Example
-        -------
-
-        .. code:: python
-
-            doc = Document("write.numbers")
-            sheets = doc.sheets
-            tables = sheets[0].tables
-            table = tables[0]
-            table.write(1, 1, "This is new text")
-            table.write("B7", datetime(2020, 12, 25))
-            doc.save("new-sheet.numbers")
         """
         # TODO: write needs to retain/init the border
         (row, col, value) = self._validate_cell_coords(*args)
@@ -1050,8 +1065,27 @@ class Table(Cacheable):  # noqa: F811
         self.num_cols -= num_cols
         self._model.number_of_columns(self._table_id, self.num_cols)
 
-    def merge_cells(self, cell_range):
-        """Convert a cell range or list of cell ranges into merged cells."""
+    def merge_cells(self, cell_range: Union[str, List[str]]) -> None:
+        """
+        Convert a cell range or list of cell ranges into merged cells.
+
+        Parameters
+        ----------
+        cell_range: str | List[str]
+            Cell range(s) to merge in A1 notation
+
+        Example
+        --------
+        .. code:: python
+
+            >>> table.cell("B2")
+            <numbers_parser.cell.TextCell object at 0x102c0d390>
+            >>> table.cell("B2").is_merged
+            False
+            >>> table.merge_cells("B2:C2")
+            >>> table.cell("B2").is_merged
+            True
+        """
         if isinstance(cell_range, list):
             for x in cell_range:
                 self.merge_cells(x)
@@ -1074,6 +1108,48 @@ class Table(Cacheable):  # noqa: F811
                     cell._set_merge(merge_cells.get((row, col)))
 
     def set_cell_border(self, *args):
+        """
+        Set the borders for a cell.
+
+        Cell references can be row-column offsers or Excel/Numbers-style A1 notation. Borders
+        can be applied to multiple sides of a cell by passing a list of sides. The name(s)
+        of the side(s) must be one of ``"top"``, ``"right"``, ``"bottom"`` or ``"left"``.
+
+        Numbers supports different border styles for each cell within a merged cell range
+        for those cells that are on the outer part of the merge. ``numbers-parser`` will
+        ignore attempts to set these invisible cell edges and issue a ``RuntimeWarning``.
+
+        .. code-block:: python
+
+            # Dashed line for B7's right border
+            table.set_cell_border(6, 1, "right", Border(5.0, RGB(29, 177, 0), "dashes"))
+            # Solid line starting at B7's left border and running for 3 rows
+            table.set_cell_border("B7", "left", Border(8.0, RGB(29, 177, 0), "solid"), 3)
+
+        :Args (row-column):
+            * **param1** (*int*): The row number (zero indexed).
+            * **param2** (*int*): The column number (zero indexed).
+            * **param3** (*str | List[str]*): Which side(s) of the cell to apply the border to.
+            * **param4** (:py:class:`Border`): The border to add.
+            * **param5** (*int*, *optinal*, default: 1): The length of the stroke to add.
+
+        :Args (A1):
+            * **param1** (*str*): A cell reference using Excel/Numbers-style A1 notation.
+            * **param2** (*str | List[str]*): Which side(s) of the cell to apply the border to.
+            * **param3** (:py:class:`Border`): The border to add.
+            * **param4** (*int*, *optional*, default: 1): The length of the stroke to add.
+
+        Raises
+        ------
+        TypeError:
+            If an invalid number of arguments is passed or if the types of the arguments
+            are invalid.
+
+        Warns
+        -----
+        RuntimeWarning:
+            If any of the sides to which the border is applied have been merged.
+        """  # noqa: E501
         (row, col, *args) = self._validate_cell_coords(*args)
         if len(args) == 2:
             (side, border_value) = args
@@ -1094,9 +1170,24 @@ class Table(Cacheable):  # noqa: F811
                 self.set_cell_border(row, col, s, border_value, length)
             return
 
-        if self._data[row][col].is_merged and side in ["bottom", "right"]:
+        cell = self._data[row][col]
+        if cell.is_merged and (
+            (side == "right" and cell.size[1] > 1) or (side == "bottom" and cell.size[0] > 1)
+        ):
             warn(
-                f"cell [{row},{col}] is merged; {side} border not set",
+                f"{side} edge of [{row},{col}] is merged; border not set",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+            return
+        elif isinstance(cell, MergedCell) and (
+            (side == "top" and cell.row_start < row)
+            or (side == "right" and cell.col_end > col)
+            or (side == "bottom" and cell.row_end > row)
+            or (side == "left" and cell.col_start < col)
+        ):
+            warn(
+                f"{side} edge of [{row},{col}] is merged; border not set",
                 RuntimeWarning,
                 stacklevel=2,
             )
@@ -1121,92 +1212,144 @@ class Table(Cacheable):  # noqa: F811
 
         Cell references can be **row-column** offsers or Excel/Numbers-style **A1** notation.
 
+        .. code:: python
+
+            table.set_cell_formatting(
+                "C1",
+                "date",
+                date_time_format="EEEE, d MMMM yyyy"
+            )
+            table.set_cell_formatting(
+                0,
+                4,
+                "number",
+                decimal_places=3,
+                negative_style=NegativeNumberStyle.RED
+            )
+
         :Parameters:
             * **args** (*list*, *optional*) – Positional arguments for cell reference and data format type (see below)
             * **kwargs** (*dict*, *optional*) - Key-value pairs defining a formatting options for each data format (see below).
 
         :Args (row-column):
-            * **param1** (``int``): The row number (zero indexed).
-            * **param2** (``int``): The column number (zero indexed).
-            * **param3** (``str``): Data format type for the cell (see "data formats" below).
+            * **param1** (*int*): The row number (zero indexed).
+            * **param2** (*int*): The column number (zero indexed).
+            * **param3** (*str*): Data format type for the cell (see "data formats" below).
 
         :Args (A1):
-            * **param1** (``str``): A cell reference using Excel/Numbers-style A1 notation.
-            * **param2** (``str``): Data format type for the cell (see "data formats" below).
+            * **param1** (*str*): A cell reference using Excel/Numbers-style A1 notation.
+            * **param2** (*str*): Data format type for the cell (see "data formats" below).
+
+        :Raises:
+            * **TypeError** -
+                If a tickbox is chosen for anything other than ``bool`` values.
 
         :Warns:
             * **RuntimeWarning** -
                 If ``use_accounting_style`` is used with
-                any ``negative_style`` other than ``NegativeNumberStyle.MINUS``.
+                any ``negative_style`` other than ``NegativeNumberStyle.MINUS``, or
+                if a rating is out of range 0 to 5 (rating is clamped to these values).
 
         All formatting styles share a name and a type, described in the **Common**
         parameters in the following table. Additional key-value pairs configure the format
-        depending upon the value of ``kwargs["type"]``. Supported values for
-        ``kwargs["type"]`` are:
-
-            * ``"base"``: A number base in the range 2-36.
-            * ``"currency"``: A decimal formatted with a currency symbol.
-            * ``"datetime"``: A date and time value with custom formatting.
-            * ``"fraction"``: A number formatted as the nearest fraction.
-            * ``"percentage"``: A number formatted as a percentage
-            * ``"number"``: A decimal number.
-            * ``"scientific"``: A decimal number with scientific notation.
-
-        :Common keys:
-            * **name** (``str``) – The name of the custom format. If no name is provided,
+        depending upon the value of ``kwargs["type"]``.
+
+        :Common Args:
+            * **name** (*str*) – The name of the custom format. If no name is provided,
               one is generated using the scheme ``Custom Format``, ``Custom Format 1``, ``Custom Format 2``, etc.
-            * **type** (``str``, *optional*, default: ``number``) – The type of format to
-              create Supported formats are ``number``, ``datetime`` and ``text``.
+            * **type** (*str, optional, default: number*) – The type of format to
+              create:
+
+              * ``"base"``: A number base in the range 2-36.
+              * ``"currency"``: A decimal formatted with a currency symbol.
+              * ``"datetime"``: A date and time value with custom formatting.
+              * ``"fraction"``: A number formatted as the nearest fraction.
+              * ``"percentage"``: A number formatted as a percentage
+              * ``"number"``: A decimal number.
+              * ``"scientific"``: A decimal number with scientific notation.
+              * ``"tickbox"``: A checkbox (bool values only).
+              * ``"rating"``: A star rating from 0 to 5.
+              * ``"slider"``: A range slider.
+              * ``"stepper"``: An up/down value stepper.
+              * ``"popup"``: A menu of options.
 
         :``"base"``:
-            * **base_use_minus_sign** (``int``, *optional*, default: ``10``) – The integer
+            * **base_use_minus_sign** (*int, optional, default: 10*) – The integer
               base to represent the number from 2-36.
-            * **base_use_minus_sign** (``bool``, *optional*, default: ``True``) – If ``True``
+            * **base_use_minus_sign** (*bool, optional, default: True*) – If ``True``
               use a standard minus sign, otherwise format as two's compliment (only
               possible for binary, octal and hexadecimal.
-            * **base_places** (``int``, *optional*, default: ``0``) – The number of
+            * **base_places** (*int, optional, default: 0*) – The number of
               decimal places, or ``None`` for automatic.
 
         :``"currency"``:
-            * **currency** (``str``, *optional*, default: ``"GBP"``) – An ISO currency
+            * **currency** (*str, optional, default: "GBP"*) – An ISO currency
               code, e.g. ``"GBP"`` or ``"USD"``.
-            * **decimal_places** (``int``, *optional*, default: ``2``) – The number of
+            * **decimal_places** (*int, optional, default: 2*) – The number of
               decimal places, or ``None`` for automatic.
-            * **negative_style** (``NegativeNumberStyle``, *optional*, default: ``NegativeNumberStyle.MINUS``) – How negative numbers are represented.
+            * **negative_style** (*:py:class:`~numbers_parser.NegativeNumberStyle`, optional, default: NegativeNumberStyle.MINUS*) – How negative numbers are represented.
               See `Negative number formats <#negative-formats>`_.
-            * **show_thousands_separator** (``bool``, *optional*, default: ``False``) – ``True``
+            * **show_thousands_separator** (*bool, optional, default: False*) – ``True``
               if the number should include a thousands seperator, e.g. ``,``
-            * **use_accounting_style** (``bool``, *optional*, default: ``False``) –  ``True``
+            * **use_accounting_style** (*bool, optional, default: False*) –  ``True``
               if the currency symbol should be formatted to the left of the cell and
               separated from the number value by a tab.
 
         :``"datetime"``:
-            * **date_time_format** (``str``, *optional*, default: ``"dd MMM YYY HH:MM"``) – A POSIX
+            * **date_time_format** (*str, optional, default: "dd MMM YYY HH:MM"*) – A POSIX
                strftime-like formatting string of `Numbers date/time
                directives <#datetime-formats>`_.
 
         :``"fraction"``:
-            * **fraction_accuracy** (``FractionAccuracy``, *optional*, default: ``FractionAccuracy.THREE`` – The
+            * **fraction_accuracy** (*:py:class:`~numbers_parser.FractionAccuracy`, optional, default: FractionAccuracy.THREE* – The
                 precision of the faction.
 
         :``"percentage"``:
-            * **decimal_places** (``float``, *optional*, default: ``None``) –  number of
+            * **decimal_places** (*float, optional, default: None*) –  number of
               decimal places, or ``None`` for automatic.
-            * **negative_style** (``NegativeNumberStyle``, *optional*, default: ``NegativeNumberStyle.MINUS``) – How negative numbers are represented.
+            * **negative_style** (*:py:class:`~numbers_parser.NegativeNumberStyle`, optional, default: NegativeNumberStyle.MINUS*) – How negative numbers are represented.
               See `Negative number formats <#negative-formats>`_.
-            * **show_thousands_separator** (``bool``, *optional*, default: ``False``) – ``True``
+            * **show_thousands_separator** (*bool, optional, default: False*) – ``True``
               if the number should include a thousands seperator, e.g. ``,``
 
         :``"scientific"``:
-            * **decimal_places** (``float``, *optional*, default: ``None``) – number of
+            * **decimal_places** (*float, optional, default: None*) – number of
               decimal places, or ``None`` for automatic.
 
-        Example
+        :``"tickbox"``:
+            * No additional parameters defined.
+
+        :``"rating"``:
+            * No additional parameters defined.
+
+        :``"slider"``:
+            * **control_format** (*ControlFormattingType, optional, default: ControlFormattingType.NUMBER*) - the format
+                of the data in the slider. Valid options are ``"base"``, ``"currency"``,
+                ``"datetime"``, ``"fraction"``, ``"percentage"``, ``"number"``,
+                or ``"scientific". Each format allows additional parameters identical to those
+                available for the formats themselves. For example, a slider using fractions
+                is configured with ``fraction_accuracy``.
+            * **increment** (*float, optional, default: 1*) - the slider's minimum value
+            * **maximum** (*float, optional, default: 100*) - the slider's maximum value
+            * **minimum** (*float, optional, default: 1*) - increment value for the slider
+
+        :`"stepper"``:
+            * **control_format** (*ControlFormattingType, optional, default: ControlFormattingType.NUMBER*) - the format
+                of the data in the stepper. Valid options are ``"base"``, ``"currency"``,
+                ``"datetime"``, ``"fraction"``, ``"percentage"``, ``"number"``,
+                or ``"scientific"``. Each format allows additional parameters identical to those
+                available for the formats themselves. For example, a stepper using fractions
+                is configured with ``fraction_accuracy``.
+            * **increment** (*float, optional, default: 1*) - the stepper's minimum value
+            * **maximum** (*float, optional, default: 100*) - the stepper's maximum value
+            * **minimum** (*float, optional, default: 1*) - increment value for the stepper
+
+        :`"popup"``:
+            * **popup_values** (*List[str|int|float], optional, default: None*) – values
+                for the popup menu
+            * **allow_none** (*bool, optional, default: True*) - If ``True``
+                include a blank value in the list
 
-        .. code:: python
-
-            >>> table.set_cell_formatting("C1", "date", date_time_format="EEEE, d MMMM yyyy")
-            >>> table.set_cell_formatting(0, 4, "number", decimal_places=3, negative_style=NegativeNumberStyle.RED)
 
         """  # noqa: E501
         (row, col, *args) = self._validate_cell_coords(*args)
@@ -1218,11 +1361,11 @@ class Table(Cacheable):  # noqa: F811
             raise TypeError("no type defined for cell format")
 
         if format_type == "custom":
-            self.set_cell_custom_format(row, col, **kwargs)
+            self._set_cell_custom_format(row, col, **kwargs)
         else:
-            self.set_cell_data_format(row, col, format_type, **kwargs)
+            self._set_cell_data_format(row, col, format_type, **kwargs)
 
-    def set_cell_custom_format(self, row: int, col: int, **kwargs) -> None:
+    def _set_cell_custom_format(self, row: int, col: int, **kwargs) -> None:
         if "format" not in kwargs:
             raise TypeError("no format provided for custom format")
 
@@ -1237,33 +1380,57 @@ class Table(Cacheable):  # noqa: F811
             raise TypeError("format must be a CustomFormatting object or format name")
 
         cell = self._data[row][col]
-        if custom_format.type == CustomFormattingType.DATETIME and not isinstance(cell, DateCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot use date/time formatting for cells of type {type_name}")
-        elif custom_format.type == CustomFormattingType.NUMBER and not isinstance(cell, NumberCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot use number formatting for cells of type {type_name}")
-        elif custom_format.type == CustomFormattingType.TEXT and not isinstance(cell, TextCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot use text formatting for cells of type {type_name}")
+        type_name = type(cell).__name__
+        format_type_name = custom_format.type.name.lower()
+        if type_name not in CUSTOM_FORMATTING_ALLOWED_CELLS[format_type_name]:
+            raise TypeError(
+                f"cannot use {format_type_name} formatting for cells of type {type_name}"
+            )
 
         format_id = self._model.custom_format_id(self._table_id, custom_format)
         cell._set_formatting(format_id, custom_format.type)
 
-    def set_cell_data_format(self, row: int, col: int, format_type: str, **kwargs) -> None:
+    def _set_cell_data_format(self, row: int, col: int, format_type_name: str, **kwargs) -> None:
         try:
-            format_type = FormattingType[format_type.upper()]
+            format_type = FormattingType[format_type_name.upper()]
         except (KeyError, AttributeError):
-            raise TypeError(f"unsuported cell format type '{format_type}'") from None
+            raise TypeError(f"unsuported cell format type '{format_type_name}'") from None
 
         cell = self._data[row][col]
-        if format_type == FormattingType.DATETIME and not isinstance(cell, DateCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot use date/time formatting for cells of type {type_name}")
-        elif not isinstance(cell, NumberCell) and not isinstance(cell, DateCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot set formatting for cells of type {type_name}")
+        type_name = type(cell).__name__
+        if type_name not in FORMATTING_ALLOWED_CELLS[format_type_name]:
+            raise TypeError(
+                f"cannot use {format_type_name} formatting for cells of type {type_name}"
+            )
 
         format = Formatting(type=format_type, **kwargs)
-        format_id = self._model.format_archive(self._table_id, format_type, format)
-        cell._set_formatting(format_id, format_type)
+        if format_type_name in FORMATTING_ACTION_CELLS:
+            control_id = self._model.control_cell_archive(self._table_id, format_type, format)
+        else:
+            control_id = None
+
+        is_currency = True if format_type == FormattingType.CURRENCY else False
+        if format_type_name in ["slider", "stepper"]:
+            if "control_format" in kwargs:
+                try:
+                    control_format = kwargs["control_format"].name
+                    number_format_type = FormattingType[control_format]
+                    is_currency = (
+                        True
+                        if kwargs["control_format"] == ControlFormattingType.CURRENCY
+                        else False
+                    )
+                except (KeyError, AttributeError):
+                    raise TypeError(
+                        "unsupported number format '{control_format}' for format_type_name"
+                    ) from None
+            else:
+                number_format_type = FormattingType.NUMBER
+            format_id = self._model.format_archive(self._table_id, number_format_type, format)
+        elif format_type_name == "popup":
+            popup_format_type = FormattingType.TEXT if isinstance(cell, TextCell) else True
+            format_id = self._model.format_archive(self._table_id, popup_format_type, format)
+        else:
+            format_id = self._model.format_archive(self._table_id, format_type, format)
+
+        cell._set_formatting(format_id, format_type, control_id, is_currency=is_currency)