pyfastexcel 0.1.8__py3-none-win_amd64.whl

pyfastexcel/__init__.py

@@ -0,0 +1,21 @@
+from openpyxl_style_writer import CustomStyle, DefaultStyle
+
+from pyfastexcel.workbook import Workbook
+from pyfastexcel.writer import StreamWriter
+from pyfastexcel.utils import set_debug_level
+from pyfastexcel.enums import ChartType, ChartDataLabelPosition, ChartLineType, MarkerSymbol
+
+__all__ = [
+    'Workbook',
+    'StreamWriter',
+    # Temporary link the CustomStyle from openpyxl_style_writer for
+    # convinent usage.
+    'CustomStyle',
+    'DefaultStyle',
+    'set_debug_level',
+    # Constants for chart creation.
+    'ChartType',
+    'ChartDataLabelPosition',
+    'ChartLineType',
+    'MarkerSymbol',
+]

pyfastexcel/_typing.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Literal, Protocol, Optional, List, Union, TypeVar
+from typing_extensions import TypedDict
+
+
+class CommentTextDict(TypedDict, total=False):
+    text: str
+    size: Optional[int]
+    name: Optional[str]
+    bold: Optional[bool]
+    italic: Optional[bool]
+    underline: Optional[Literal['single', 'double']]
+    strike: Optional[bool]
+    vert_align: Optional[str]
+    color: Optional[str]
+
+
+class SelectionDict(TypedDict, total=False):
+    sq_ref: str
+    active_cell: str
+    pane: str
+
+
+class Writable(Protocol):
+    def write(self, content: str) -> None: ...
+
+
+Self = TypeVar('Self')
+CommentTextStructure = Union[str, List[str], CommentTextDict, List[CommentTextDict]]
+SetPanesSelection = List[SelectionDict]

pyfastexcel/chart.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field, field_serializer
+from typing import List, Literal, Optional
+
+from .enums import ChartDataLabelPosition, ChartLineType, ChartType, MarkerSymbol
+
+
+class Font(BaseModel):
+    """
+    Defines font settings for text elements in a chart.
+
+    Attributes:
+        bold (Optional[bool]): Specifies if the text is bold.
+        color (Optional[str]): The color of the text.
+        family (Optional[str]): The font family for the text.
+        italic (Optional[bool]): Specifies if the text is italic.
+        size (Optional[float]): The font size for the text.
+        strike (Optional[bool]): Specifies if the text has a strikethrough.
+        underline (Optional[str]): The style of underline for the text.
+        vert_align (Optional[str]): Vertical alignment for the text, such as
+            "baseline", "superscript" or "subscript".
+    """
+
+    bold: Optional[bool] = Field(None, serialization_alias='Bold')
+    color: Optional[str] = Field(None, serialization_alias='Color')
+    family: Optional[str] = Field(None, serialization_alias='Family')
+    italic: Optional[bool] = Field(None, serialization_alias='Italic')
+    size: Optional[float] = Field(None, serialization_alias='Size')
+    strike: Optional[bool] = Field(None, serialization_alias='Strike')
+    underline: Optional[str] = Field(None, serialization_alias='Underline')
+    vert_align: Optional[str] = Field(None, serialization_alias='VertAlign')
+
+
+class Fill(BaseModel):
+    """
+    Describes the fill settings.
+
+    Attributes:
+        ftype (Optional[Literal['pattern', 'gradient']]): The type of fill, either
+            'pattern' or 'gradient'.
+        pattern (Optional[int]): The pattern index for fill (between 0 and 18).
+        color (Optional[str]): The fill color (Only support hex color value).
+        shading (Optional[int]): The shading index for the fill (between 0 and 5).
+    """
+
+    ftype: Optional[Literal['pattern', 'gradient']] = Field('pattern', serialization_alias='Type')
+    pattern: Optional[int] = Field(None, serialization_alias='Pattern', gt=-1, lt=19)
+    color: Optional[str] = Field(None, serialization_alias='Color')
+    shading: Optional[int] = Field(None, serialization_alias='Shading', gt=-1, lt=6)
+
+
+class Marker(BaseModel):
+    """
+    Defines the appearance and style of markers used in charts.
+
+    Attributes:
+        fill (Optional[Fill]): Fill settings for the marker.
+        symbol (Optional[str | MarkerSymbol]): The symbol used for the marker.
+        size (Optional[int]): The size of the marker.
+    """
+
+    fill: Optional[Fill] = Field(None, serialization_alias='Fill')
+    symbol: Optional[str | MarkerSymbol] = Field(None, serialization_alias='Symbol')
+    size: Optional[int] = Field(None, serialization_alias='Size')
+
+    @field_serializer('symbol')
+    @classmethod
+    def marker_symbol_serializer(cls, symbol: str | MarkerSymbol | None) -> str | None:
+        if symbol is None:
+            return None
+        if isinstance(symbol, MarkerSymbol):
+            return symbol.value
+        return MarkerSymbol.get_enum(symbol).value
+
+
+class Line(BaseModel):
+    """
+    Represents line settings for chart elements.
+
+    Attributes:
+        ltype (Optional[str | ChartLineType]): The type of line.
+        smooth (Optional[bool]): Specifies if the line should be smoothed.
+        width (Optional[float]): The width of the line.
+        show_marker_line (Optional[bool]): Indicates if the line should be shown on markers.
+    """
+
+    ltype: Optional[str | ChartLineType] = Field(None, serialization_alias='Type')
+    smooth: Optional[bool] = Field(None, serialization_alias='Smooth')
+    width: Optional[float] = Field(None, serialization_alias='Width')
+    show_marker_line: Optional[bool] = Field(None, serialization_alias='ShowMarkerLine')
+
+    @field_serializer('ltype')
+    @classmethod
+    def line_type_validator(cls, ltype: str | ChartLineType | None) -> int:
+        if ltype is None:
+            return None
+        if isinstance(ltype, ChartLineType):
+            return ltype.value
+        return ChartLineType.get_enum(ltype).value
+
+
+class ChartLegend(BaseModel):
+    """
+    Defines settings for the chart legend.
+
+    Attributes:
+        position (Optional[Literal['none', 'top', 'bottom', 'left', 'right', 'top_right']]):
+            The position of the legend.
+        show_legend_key (Optional[bool]): Specifies if the legend key should be shown.
+    """
+
+    position: Optional[Literal['none', 'top', 'bottom', 'left', 'right', 'top_right']] = Field(
+        None, serialization_alias='Position'
+    )
+    show_legend_key: Optional[bool] = Field(None, serialization_alias='ShowLegendKey')
+
+
+class RichTextRun(BaseModel):
+    """
+    Represents a text run with rich text formatting.
+
+    Attributes:
+        text (str): The text content.
+        font (Optional[Font]): Font settings for the text.
+    """
+
+    text: str = Field(..., serialization_alias='Text')
+    font: Optional[Font] = Field(None, serialization_alias='Font')
+
+
+class ChartCustomNumFmt(BaseModel):
+    """
+    Custom number formatting for chart elements.
+
+    Attributes:
+        num_fmt (Optional[str]): The custom number format.
+        source_linked (Optional[bool]): Specifies if the format is linked to the source.
+    """
+
+    num_fmt: Optional[str] = Field(None, serialization_alias='CustomNumFmt')
+    source_linked: Optional[bool] = Field(None, serialization_alias='SourceLinked')
+
+
+class ChartAxis(BaseModel):
+    """
+    Defines the settings for chart axes.
+
+    Attributes:
+        none (Optional[bool]): Specifies if the axis should be hidden.
+        font (Optional[Font]): Font settings for the axis labels.
+        major_grid_lines (Optional[bool]): Specifies if major grid lines should be displayed.
+        minor_grid_lines (Optional[bool]): Specifies if minor grid lines should be displayed.
+        major_unit (Optional[float]): The interval between major grid lines.
+        tick_label_skip (Optional[int]): Specifies the number of tick labels to skip between
+            each drawn label.
+        reverse_order (Optional[bool]): Indicates if the axis order should be reversed.
+        secondary (Optional[bool]): Specifies if this is a secondary axis.
+        maximum (Optional[float]): The maximum value for the axis.
+        minimum (Optional[float]): The minimum value for the axis.
+        log_base (Optional[float]): The logarithmic base for the axis scale.
+        num_fmt (Optional[ChartCustomNumFmt]): Custom number format for the axis.
+        title (Optional[List[RichTextRun]]): The title of the axis.
+    """
+
+    none: Optional[bool] = Field(None, serialization_alias='None')
+    font: Optional[Font] = Field(Font(), serialization_alias='Font')
+    major_grid_lines: Optional[bool] = Field(None, serialization_alias='MajorGridLines')
+    minor_grid_lines: Optional[bool] = Field(None, serialization_alias='MinorGridLines')
+    major_unit: Optional[float] = Field(None, serialization_alias='MajorUnit')
+    tick_label_skip: Optional[int] = Field(None, serialization_alias='TickLabelSkip')
+    reverse_order: Optional[bool] = Field(None, serialization_alias='ReverseOrder')
+    secondary: Optional[bool] = Field(None, serialization_alias='Secondary')
+    maximum: Optional[float] = Field(None, serialization_alias='Maximum')
+    minimum: Optional[float] = Field(None, serialization_alias='Minimum')
+    log_base: Optional[float] = Field(None, serialization_alias='LogBase')
+    num_fmt: Optional[ChartCustomNumFmt] = Field(ChartCustomNumFmt(), serialization_alias='NumFmt')
+    title: Optional[List[RichTextRun]] = Field(None, serialization_alias='Title')
+
+
+class ChartPlotArea(BaseModel):
+    """
+    Represents the plot area of a chart.
+
+    Attributes:
+        second_plot_values (Optional[int]): The number of values in a secondary plot
+            (Only for pieOfPie and barOfPie chart).
+        show_bubble_size (Optional[bool]): Indicates if bubble sizes should be displayed.
+        show_cat_name (Optional[bool]): Specifies if category names should be shown.
+        show_leader_lines (Optional[bool]): Indicates if leader lines should be shown in
+            the data label.
+        show_percent (Optional[bool]): Specifies if percentages should be shown in the data label.
+        show_ser_name (Optional[bool]): Indicates if series names should be displayed in the
+            data label.
+        show_val (Optional[bool]): Specifies if values should be shown in the data label.
+        fill (Optional[Fill]): Fill settings for the plot area.
+        num_fmt (Optional[ChartCustomNumFmt]): Custom number format for the plot area.
+    """
+
+    second_plot_values: Optional[int] = Field(None, serialization_alias='SecondPlotValues')
+    show_bubble_size: Optional[bool] = Field(None, serialization_alias='ShowBubbleSize')
+    show_cat_name: Optional[bool] = Field(None, serialization_alias='ShowCatName')
+    show_leader_lines: Optional[bool] = Field(None, serialization_alias='ShowLeaderLines')
+    show_percent: Optional[bool] = Field(None, serialization_alias='ShowPercent')
+    show_ser_name: Optional[bool] = Field(None, serialization_alias='ShowSerName')
+    show_val: Optional[bool] = Field(None, serialization_alias='ShowVal')
+    fill: Optional[Fill] = Field(None, serialization_alias='Fill')
+    num_fmt: Optional[ChartCustomNumFmt] = Field(ChartCustomNumFmt(), serialization_alias='NumFmt')
+
+
+class GraphicOptions(BaseModel):
+    """
+    Defines various graphical options for chart elements.
+
+    Attributes:
+        alt_text (Optional[str]): Alternative text for accessibility.
+        print_object (Optional[bool]): Indicates if the object should be printed.
+        locked (Optional[bool]): Specifies if the object is locked.
+        lock_aspect_ratio (Optional[bool]): Indicates if the aspect ratio should be locked.
+        auto_fit (Optional[bool]): Specifies if the object should automatically fit its content.
+        offset_x (Optional[int]): The horizontal offset of the object.
+        offset_y (Optional[int]): The vertical offset of the object.
+        scale_x (Optional[float]): The horizontal scale factor.
+        scale_y (Optional[float]): The vertical scale factor.
+        hyperlink (Optional[str]): A hyperlink associated with the object.
+        hyperlink_type (Optional[str]): The type of hyperlink.
+        positioning (Optional[str]): The positioning mode for the object.
+    """
+
+    alt_text: Optional[str] = Field(None, serialization_alias='AltText')
+    print_object: Optional[bool] = Field(None, serialization_alias='PrintObject')
+    locked: Optional[bool] = Field(None, serialization_alias='Locked')
+    lock_aspect_ratio: Optional[bool] = Field(None, serialization_alias='LockAspectRatio')
+    auto_fit: Optional[bool] = Field(None, serialization_alias='AutoFit')
+    offset_x: Optional[int] = Field(None, serialization_alias='OffsetX')
+    offset_y: Optional[int] = Field(None, serialization_alias='OffsetY')
+    scale_x: Optional[float] = Field(None, serialization_alias='ScaleX')
+    scale_y: Optional[float] = Field(None, serialization_alias='ScaleY')
+    hyperlink: Optional[str] = Field(None, serialization_alias='Hyperlink')
+    hyperlink_type: Optional[str] = Field(None, serialization_alias='HyperlinkType')
+    positioning: Optional[str] = Field(None, serialization_alias='Positioning')
+
+
+class ChartDimension(BaseModel):
+    """
+    Specifies the dimensions of a chart.
+
+    Attributes:
+        width (Optional[int]): The width of the chart.
+        height (Optional[int]): The height of the chart.
+    """
+
+    width: Optional[int] = Field(None, serialization_alias='Width')
+    height: Optional[int] = Field(None, serialization_alias='Height')
+
+
+class ChartSeries(BaseModel):
+    """
+    Represents a data series in a chart.
+
+    Attributes:
+        name (str): The name of the series (Legend).
+        categories (str): The categories for the series (X value).
+        values (str): The values for the series (Y value).
+        sizes (Optional[str]): The sizes for bubble charts.
+        fill (Optional[Fill]): Fill settings for the series.
+        line (Optional[Line]): Line settings for the series.
+        marker (Optional[Marker]): Marker settings for the series.
+        data_label_position (Optional[str | ChartDataLabelPosition]): The position
+            of data labels for the series.
+    """
+
+    name: str = Field(..., serialization_alias='Name')
+    categories: str = Field(..., serialization_alias='Categories')
+    values: str = Field(..., serialization_alias='Values')
+    sizes: Optional[str] = Field(None, serialization_alias='Sizes')
+    fill: Optional[Fill] = Field(Fill(), serialization_alias='Fill')
+    line: Optional[Line] = Field(Line(), serialization_alias='Line')
+    marker: Optional[Marker] = Field(Marker(), serialization_alias='Marker')
+    data_label_position: Optional[str | ChartDataLabelPosition] = Field(
+        None, serialization_alias='DataLabelPosition'
+    )
+
+    @field_serializer('data_label_position')
+    @classmethod
+    def data_label_position_validator(cls, label: str | ChartDataLabelPosition | None) -> int:
+        if label is None:
+            return ChartDataLabelPosition.Unset.value
+        if isinstance(label, ChartDataLabelPosition):
+            return label.value
+        return ChartDataLabelPosition.get_enum(label).value
+
+
+class Chart(BaseModel):
+    """
+    Defines the configuration for a chart.
+
+    Attributes:
+        chart_type (str | ChartType): The type of chart, such as 'bar', 'line', etc.
+        series (List[ChartSeries] | ChartSeries): The data series to be plotted
+            in the chart.
+        graph_format (Optional[GraphicOptions]): Graphical options for the chart.
+        title (Optional[List[RichTextRun]]): The title of the chart.
+        legend (Optional[ChartLegend]): The legend settings for the chart.
+        dimension (Optional[ChartDimension]): The dimensions of the chart.
+        vary_colors (Optional[bool]): Specifies if colors should vary by data point.
+        x_axis (Optional[ChartAxis]): The configuration of the X-axis.
+        y_axis (Optional[ChartAxis]): The configuration of the Y-axis.
+        plot_area (Optional[ChartPlotArea]): The configuration of the plot area.
+        fill (Optional[Fill]): The fill settings for the chart.
+        border (Optional[Line]): The border settings for the chart.
+        show_blanks_as (Optional[str]): Specifies how blanks should be shown in the chart.
+        bubble_size (Optional[int]): The size of bubbles in a bubble chart.
+        hole_size (Optional[int]): The size of the hole in a doughnut chart.
+        order (Optional[int]): The order of the series in the chart.
+    """
+
+    chart_type: str | ChartType = Field(..., serialization_alias='Type')
+    series: List[ChartSeries] | ChartSeries = Field(None, serialization_alias='Series')
+    graph_format: Optional[GraphicOptions] = Field(GraphicOptions(), serialization_alias='Format')
+    title: Optional[List[RichTextRun]] = Field(None, serialization_alias='Title')
+    legend: Optional[ChartLegend] = Field(ChartLegend(), serialization_alias='Legend')
+    dimension: Optional[ChartDimension] = Field(ChartDimension(), serialization_alias='Dimension')
+    vary_colors: Optional[bool] = Field(None, serialization_alias='VaryColors')
+    x_axis: Optional[ChartAxis] = Field(ChartAxis(), serialization_alias='XAxis')
+    y_axis: Optional[ChartAxis] = Field(ChartAxis(), serialization_alias='YAxis')
+    plot_area: Optional[ChartPlotArea] = Field(ChartPlotArea(), serialization_alias='PlotArea')
+    fill: Optional[Fill] = Field(Fill(), serialization_alias='Fill')
+    border: Optional[Line] = Field(Line(), serialization_alias='Border')
+    show_blanks_as: Optional[str] = Field(None, serialization_alias='ShowBlanksAs')
+    bubble_size: Optional[int] = Field(None, serialization_alias='BubbleSize')
+    hole_size: Optional[int] = Field(None, serialization_alias='HoleSize')
+    order: Optional[int] = Field(None, serialization_alias='order')
+
+    @field_serializer('series')
+    @classmethod
+    def series_serializer(cls, series: List[ChartSeries] | ChartSeries) -> List[ChartSeries]:
+        series = [series] if isinstance(series, ChartSeries) else series
+        return series
+
+    @field_serializer('chart_type')
+    @classmethod
+    def chart_type_validator(cls, chart_type: str | ChartType) -> int:
+        if isinstance(chart_type, ChartType):
+            return chart_type.value
+        return ChartType.get_enum(chart_type).value

pyfastexcel/driver.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+import base64
+import ctypes
+import logging
+import sys
+from datetime import datetime, timezone
+from io import BytesIO
+from pathlib import Path
+from typing import overload
+
+import msgspec
+from openpyxl import load_workbook
+from openpyxl_style_writer import CustomStyle
+
+from .logformatter import formatter
+from .style import StyleManager
+from .worksheet import WorkSheet
+from .validators import TableFinalValidation
+from ._typing import Writable
+
+BASE_DIR = Path(__file__).resolve().parent
+
+logger = logging.getLogger(__name__)
+style_formatter = logging.StreamHandler()
+style_formatter.setFormatter(formatter)
+
+logger.addHandler(style_formatter)
+logger.propagate = False
+
+
+class ExcelDriver:
+    """
+    A driver class to write data to Excel files using custom styles.
+
+    ### Attributes:
+        _FILE_PROPS (dict[str, str]): Default file properties for the Excel
+        file.
+        _PROTECT_ALGORITHM (tuple[str]): Algorithm for the workbook protection
+
+    ### Methods:
+        __init__(): Initializes the ExcelDriver.
+        _read_lib(lib_path: str): Reads a library for Excel manipulation.
+        read_lib_and_create_excel(lib_path: str = None): Reads the library and
+                creates the Excel file.
+    """
+
+    _FILE_PROPS = {
+        'Category': '',
+        'ContentStatus': '',
+        'Created': '',
+        'Creator': 'pyfastexcel',
+        'Description': '',
+        'Identifier': 'xlsx',
+        'Keywords': 'spreadsheet',
+        'LastModifiedBy': 'pyfastexcel',
+        'Modified': '',
+        'Revision': '0',
+        'Subject': '',
+        'Title': '',
+        'Language': 'en-Us',
+        'Version': '',
+    }
+    _PROTECT_ALGORITHM = (
+        'XOR',
+        'MD4',
+        'MD5',
+        'SHA-1',
+        'SHA-256',
+        'SHA-384',
+        'SHA-512',
+    )
+    DEBUG = False
+
+    def __init__(self, pre_allocate: dict[str, int] = None, plain_data: list[list[str]] = None):
+        """
+        Initializes the Workbook with default settings and initializes Sheet1.
+
+        It initializes the workbook structure with Sheet1 as the default sheet,
+        sets default file properties, initializes current sheet and sheet list,
+        and initializes dictionaries for workbook and protection settings.
+
+        Args:
+            pre_allocate (dict[str, int], optional): A dictionary containing 'n_rows' and 'n_cols'
+                keys specifying the dimensions for pre-allocating data in Sheet1.
+            plain_data (list[list[str]], optional): A 2D list of strings representing initial data
+                to populate Sheet1.
+        """
+        self.workbook = {
+            'Sheet1': WorkSheet(pre_allocate=pre_allocate, plain_data=plain_data),
+        }
+        self.file_props = self._get_default_file_props()
+        self.sheet = 'Sheet1'
+        self._sheet_list = tuple(['Sheet1'])
+        self._dict_wb = {}
+        self.protection = {}
+        self.style = StyleManager()
+
+    @property
+    def sheet_list(self):
+        return list(self._sheet_list)
+
+    @overload
+    def save(self, file: Writable) -> None:
+        """
+        Saves the workbook to a writable object.
+
+        Args:
+            file (Writable): Writable object that has .write() function.
+        """
+        ...
+
+    @overload
+    def save(self, path: str) -> None:
+        """
+        Saves the workbook to a file.
+
+        Args:
+            path (str): A path to save the file.
+        """
+        ...
+
+    def save(self, file_or_path: Writable | str) -> None:
+        if not hasattr(self, 'decoded_bytes'):
+            self.read_lib_and_create_excel()
+
+        if isinstance(file_or_path, str):
+            with open(file_or_path, 'wb') as file:
+                file.write(self.decoded_bytes)
+        else:
+            file_or_path.write(self.decoded_bytes)
+
+    def __getitem__(self, key: str) -> WorkSheet:
+        return self.workbook[key]
+
+    def _check_if_sheet_exists(self, sheet_name: str) -> None:
+        if sheet_name not in self.sheet_list:
+            raise KeyError(f'{sheet_name} Sheet Does Not Exist.')
+
+    def read_lib_and_create_excel(
+        self, lib_path: str = None, ignore_go_panic: bool = True
+    ) -> bytes:
+        """
+        Reads the library and creates the Excel file.
+
+        Args:
+            lib_path (str, optional): The path to the library. Defaults to None.
+
+        Returns:
+            bytes: The byte data of the created Excel file.
+        """
+        ignore_go_panic = 0 if ignore_go_panic is False else 1
+        pyfastexcel = self._read_lib(lib_path)
+        self._create_style()
+
+        # Transfer all WorkSheet Object to the sheet dictionary in the workbook.
+        set_group_columns = False
+        set_row_columns = False
+        use_openpyxl = False
+        for sheet in self._sheet_list:
+            self._dict_wb[sheet] = self.workbook[sheet]._transfer_to_dict()
+            if self.workbook[sheet]._excel_engine == 'openpyxl':
+                use_openpyxl = True
+            if len(self.workbook[sheet]._grouped_columns_list) != 0:
+                set_group_columns = True
+            if len(self.workbook[sheet]._grouped_rows_list) != 0:
+                set_row_columns = True
+            if len(self.workbook[sheet]._table_list) != 0:
+                TableFinalValidation(
+                    data=self.workbook[sheet]._data,
+                    table_list=self.workbook[sheet]._table_list,
+                )
+
+        results = {
+            'content': self._dict_wb,
+            'file_props': self.file_props,
+            'style': self.style._style_map,
+            'protection': self.protection,
+            'sheet_order': self._sheet_list,
+        }
+        json_data = msgspec.json.encode(results)
+        create_excel = pyfastexcel.Export
+        free_pointer = pyfastexcel.FreeCPointer
+        free_pointer.argtypes = [ctypes.c_void_p, ctypes.c_int64]
+        create_excel.argtypes = [ctypes.c_char_p, ctypes.c_int64]
+        create_excel.restype = ctypes.c_void_p
+        byte_data = create_excel(json_data, ignore_go_panic)
+        self.decoded_bytes = base64.b64decode(ctypes.cast(byte_data, ctypes.c_char_p).value)
+        free_pointer(byte_data, 1 if self.DEBUG else 0)
+        StyleManager.reset_style_configs()
+
+        # Due to Streaming API of Excelize can't group column currently
+        # So implement this function by openpyxl
+        if (set_group_columns or set_row_columns) and use_openpyxl is True:
+            logger.info('Using openpyxl to group columns and rows...')
+            self.decoded_bytes = self._set_group_columns_and_group_rows()
+
+        return self.decoded_bytes
+
+    def _set_group_columns_and_group_rows(self):
+        wb = load_workbook(BytesIO(self.decoded_bytes))
+        for sheet in self._sheet_list:
+            grouped_columns = self.workbook[sheet]._grouped_columns_list
+            ws = wb[sheet]
+            for col in grouped_columns:
+                ws.column_dimensions.group(
+                    col['start_col'],
+                    col['end_col'],
+                    outline_level=col['outline_level'],
+                    hidden=col['hidden'],
+                )
+            grouped_rows = self.workbook[sheet]._grouped_rows_list
+            for row in grouped_rows:
+                ws.row_dimensions.group(
+                    row['start_row'],
+                    row['end_row'],
+                    outline_level=row['outline_level'],
+                    hidden=row['hidden'],
+                )
+
+        # Save the workbook to a BytesIO stream
+        excel_stream = BytesIO()
+        wb.save(excel_stream)
+        decoded_bytes = excel_stream.getvalue()
+        excel_stream.close()
+        return decoded_bytes
+
+    def _read_lib(self, lib_path: str) -> ctypes.CDLL:  # pragma: no cover
+        """
+        Reads a shared-library for writing Excel.
+
+        Args:
+            lib_path (str): The path to the library.
+
+        Returns:
+            ctypes.CDLL: The library object.
+        """
+        if lib_path is None:
+            if sys.platform.startswith('linux'):
+                lib_path = str(list(BASE_DIR.glob('**/*.so'))[0])
+            elif sys.platform.startswith('win32'):
+                lib_path = str(list(BASE_DIR.glob('**/*.dll'))[0])
+            elif sys.platform.startswith('darwin'):
+                lib_path = str(list(BASE_DIR.glob('**/*.dylib'))[0])
+
+        # On macOS, there is no winmode parameter, so we should not pass it
+        if sys.platform.startswith('win32') or sys.platform.startswith('linux'):
+            lib = ctypes.CDLL(lib_path, winmode=0)
+        else:
+            lib = ctypes.CDLL(lib_path)
+        return lib
+
+    def _get_default_file_props(self) -> dict[str, str]:
+        now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
+        file_props = self._FILE_PROPS.copy()
+        file_props['Created'] = now
+        file_props['Modified'] = now
+        return file_props
+
+    def _get_style_collections(self) -> dict[str, CustomStyle]:
+        """
+        Gets collections of custom styles.
+
+        Returns:
+            dict[str, CustomStyle]: A dictionary containing custom style
+                collections.
+        """
+        return {
+            attr: getattr(self, attr)
+            for attr in dir(self)
+            if not callable(getattr(self, attr)) and isinstance(getattr(self, attr), CustomStyle)
+        }
+
+    def _create_style(self) -> None:
+        """
+        Creates custom styles for the Excel file.
+
+        This method initializes custom styles for the Excel file based on
+        predefined attributes.
+        """
+        style_collections = self._get_style_collections()
+        self.style._STYLE_NAME_MAP.update({val: key for key, val in style_collections.items()})
+
+        # Set the CustomStyle from the pre-defined class attributes.
+        for key, val in style_collections.items():
+            self.style._update_style_map(key, val)
+
+        # Set the CustomStyle from the REGISTERED method.
+        for key, val in self.style.REGISTERED_STYLES.items():
+            self.style._update_style_map(key, val)