pyfastexcel 0.1.8__py3-none-win_amd64.whl

pyfastexcel/enums.py

@@ -0,0 +1,119 @@
+from enum import Enum
+
+
+class BaseEnum(Enum):
+    @classmethod
+    def get_enum(cls, name: str):
+        # Use casefold for case-insensitive comparison
+        name_casefolded = name.casefold()
+        for enum in cls:
+            if enum.name.casefold() == name_casefolded:
+                return enum
+        raise ValueError(f'{name} is not a valid {cls.__name__}')
+
+
+class ChartType(BaseEnum):
+    Area = 0
+    AreaStacked = 1
+    AreaPercentStacked = 2
+    Area3D = 3
+    Area3DStacked = 4
+    Area3DPercentStacked = 5
+    Bar = 6
+    BarStacked = 7
+    BarPercentStacked = 8
+    Bar3DClustered = 9
+    Bar3DStacked = 10
+    Bar3DPercentStacked = 11
+    Bar3DConeClustered = 12
+    Bar3DConeStacked = 13
+    Bar3DConePercentStacked = 14
+    Bar3DPyramidClustered = 15
+    Bar3DPyramidStacked = 16
+    Bar3DPyramidPercentStacked = 17
+    Bar3DCylinderClustered = 18
+    Bar3DCylinderStacked = 19
+    Bar3DCylinderPercentStacked = 20
+    Col = 21
+    ColStacked = 22
+    ColPercentStacked = 23
+    Col3D = 24
+    Col3DClustered = 25
+    Col3DStacked = 26
+    Col3DPercentStacked = 27
+    Col3DCone = 28
+    Col3DConeClustered = 29
+    Col3DConeStacked = 30
+    Col3DConePercentStacked = 31
+    Col3DPyramid = 32
+    Col3DPyramidClustered = 33
+    Col3DPyramidStacked = 34
+    Col3DPyramidPercentStacked = 35
+    Col3DCylinder = 36
+    Col3DCylinderClustered = 37
+    Col3DCylinderStacked = 38
+    Col3DCylinderPercentStacked = 39
+    Doughnut = 40
+    Line = 41
+    Line3D = 42
+    Pie = 43
+    Pie3D = 44
+    PieOfPie = 45
+    BarOfPie = 46
+    Radar = 47
+    Scatter = 48
+    Surface3D = 49
+    WireframeSurface3D = 50
+    Contour = 51
+    WireframeContour = 52
+    Bubble = 53
+    Bubble3D = 54
+
+
+class ChartDataLabelPosition(BaseEnum):
+    Unset = 0
+    BestFit = 1
+    Below = 2
+    Center = 3
+    InsideBase = 4
+    InsideEnd = 5
+    Left = 6
+    OutsideEnd = 7
+    Right = 8
+    Above = 9
+
+
+class ChartLineType(BaseEnum):
+    Unset = 0
+    Solid = 1
+    NONE = 2
+    Automatic = 3
+
+
+class MarkerSymbol(BaseEnum):
+    Circle = 'circle'
+    Dash = 'dash'
+    Diamond = 'diamond'
+    Dot = 'dot'
+    NONE = 'none'
+    Picture = 'picture'
+    Plus = 'plus'
+    Square = 'square'
+    Star = 'star'
+    Triangle = 'triangle'
+    X = 'x'
+    Auto = 'auto'
+
+
+class PivotSubTotal(BaseEnum):
+    Average = 'Average'
+    Count = 'Count'
+    CountNums = 'CountNums'
+    Max = 'Max'
+    Min = 'Min'
+    Product = 'Product'
+    StdDev = 'StdDev'
+    StdDevp = 'StdDevp'
+    Sum = 'Sum'
+    Var = 'Var'
+    Varp = 'Varp'

pyfastexcel/logformatter.py

@@ -0,0 +1,38 @@
+import logging
+import warnings
+
+NORMAL_FORMAT = '\033[%(log_color)s%(asctime)s - %(name)s - %(levelname)s - %(message)s\033[0m'
+LOG_COLORS = {
+    'DEBUG': '\033[90m',  # Grey
+    'INFO': '\033[92m',  # Green
+    'WARNING': '\033[93m',  # Yellow
+    'ERROR': '\033[91m',  # Red
+    'CRITICAL': '\033[91m',  # Red
+}
+LOG_CACHE = {}
+
+
+def custom_warning_format(message, *args):
+    start_color = '\033[93m'
+    reset_color = '\033[0m'
+    return f'{start_color}DeprecationWarning: {message}{reset_color}\n'
+
+
+def log_warning(logger: logging.Logger, message: str):
+    if not LOG_CACHE.get(message):
+        logger.warning(message)
+        LOG_CACHE[message] = True
+
+
+class ColoredFormatter(logging.Formatter):
+    def __init__(self, fmt):
+        super().__init__(fmt)
+
+    def format(self, record):
+        record.log_color = LOG_COLORS[record.levelname]
+        return super().format(record)
+
+
+warnings.formatwarning = custom_warning_format
+warnings.simplefilter('always', DeprecationWarning)
+formatter = ColoredFormatter(NORMAL_FORMAT)

pyfastexcel/pivot.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field, field_validator, field_serializer
+from typing import Optional
+
+from .enums import PivotSubTotal
+
+
+_pivot_table_style_config = ('PivotStyleLight', 'PivotStyleMedium', 'PivotStyleDark')
+
+_pivot_table_style: set[str] = set()
+_pivot_table_style.add('')
+_pivot_table_style.add(None)
+
+for name in _pivot_table_style_config:
+    for i in range(1, 29):
+        _pivot_table_style.add(f'{name}{i}')
+
+
+class PivotTableField(BaseModel):
+    """
+    Model representing a field in a PivotTable.
+
+    Attributes:
+        compact (Optional[bool]): Indicates whether the field is in compact form.
+        data (Optional[str]): Represents the data value for the field.
+        name (Optional[str]): The name of the field.
+        outline (Optional[bool]): Indicates whether the field is in outline form.
+        subtotal (Optional[str]): The type of subtotal for the field.
+        default_subtotal (Optional[bool]): Indicates whether this field has a default subtotal applied.
+    """
+
+    compact: Optional[bool] = Field(None, serialization_alias='Compact')
+    data: Optional[str] = Field(None, serialization_alias='Data')
+    name: Optional[str] = Field(None, serialization_alias='Name')
+    outline: Optional[bool] = Field(None, serialization_alias='Outline')
+    subtotal: Optional[str | PivotSubTotal] = Field(None, serialization_alias='Subtotal')
+    default_subtotal: Optional[bool] = Field(None, serialization_alias='DefaultSubtotal')
+
+    @field_serializer('subtotal')
+    @classmethod
+    def subtotal_serializer(cls, subtotal: str | PivotSubTotal | None) -> str:
+        if subtotal is None:
+            return None
+        if isinstance(subtotal, PivotSubTotal):
+            return subtotal.value
+        return PivotSubTotal.get_enum(subtotal).value
+
+
+class PivotTable(BaseModel):
+    """
+    Model representing a PivotTable, with its configuration and field settings.
+
+    Attributes:
+        data_range (str): The range of data to be used in the pivot table, e.g., "Sheet1!A1:B2".
+        pivot_table_range (str): The range where the pivot table will be positioned, e.g., "Sheet1!C3:D4".
+        rows (list[PivotTableField]): List of fields used as rows in the pivot table.
+        pivot_filter ([PivotTableField]): List of fields used as filters in the pivot table.
+        columns (list[PivotTableField]): List of fields used as columns in the pivot table.
+        data (list[PivotTableField]): List of fields used as data fields in the pivot table.
+        row_grand_totals (Optional[bool Indicates whether to show row grand totals.
+        column_grand_totals (Optional[bool]): Indicates whether to show column grand.
+        show_drill (Optional[bool]): Indicates whether to show drill indicators.
+        show_row_headers (Optional[bool]): Indicates whether to show row headers.
+        show_column_headers (Optional[bool]): Indicates whether to show column headers.
+        show_row_stripes (Optional[bool]): Indicates whether to show row stripes.
+        show_col_stripes (Optional[bool]): Indicates whether to show column stripes.
+        show_last_column (Optional[bool]): Indicates whether to show the last column.
+        use_auto_formatting (Optional[bool]): Indicates whether to use automatic formatting.
+        page_over_then_down (Optional[bool]): Indicates whether pages should be ordered from top to bottom
+            then left to right.
+        merge_item (Optional[bool]): Indicates whether to merge items.
+        compact_data (Optional[bool]): Indicates whether to show in a compact form.
+        show_error (Optional[bool]): Indicates whether to show errors.
+        classic_layout (Optional[bool]): Indicates whether to use classic layout.
+        pivot_table_style_name (Optional[str]): Specifies the style the pivot table.
+    """
+
+    data_range: str = Field(..., serialization_alias='DataRange')
+    pivot_table_range: str = Field(..., serialization_alias='PivotTableRange')
+    rows: list[PivotTableField] = Field([PivotTableField()], serialization_alias='Rows')
+    pivot_filter: list[PivotTableField] = Field([PivotTableField()], serialization_alias='Filter')
+    columns: list[PivotTableField] = Field([PivotTableField()], serialization_alias='Columns')
+    data: list[PivotTableField] = Field([PivotTableField()], serialization_alias='Data')
+    row_grand_totals: Optional[bool] = Field(None, serialization_alias='RowGrandTotals')
+    column_grand_totals: Optional[bool] = Field(None, serialization_alias='ColGrandTotals')
+    show_drill: Optional[bool] = Field(None, serialization_alias='ShowDrill')
+    show_row_headers: Optional[bool] = Field(None, serialization_alias='ShowRowHeaders')
+    show_column_headers: Optional[bool] = Field(None, serialization_alias='ShowColHeaders')
+    show_row_stripes: Optional[bool] = Field(None, serialization_alias='ShowRowStripes')
+    show_col_stripes: Optional[bool] = Field(None, serialization_alias='ShowColStripes')
+    show_last_column: Optional[bool] = Field(None, serialization_alias='ShowLastColumn')
+    use_auto_formatting: Optional[bool] = Field(None, serialization_alias='UseAutoFormatting')
+    page_over_then_down: Optional[bool] = Field(None, serialization_alias='PageOverThenDown')
+    merge_item: Optional[bool] = Field(None, serialization_alias='MergeItem')
+    compact_data: Optional[bool] = Field(None, serialization_alias='CompactData')
+    show_error: Optional[bool] = Field(None, serialization_alias='ShowError')
+    classic_layout: Optional[bool] = Field(None, serialization_alias='ClassicLayout')
+    pivot_table_style_name: Optional[str] = Field(None, serialization_alias='PivotTableStyleName')
+
+    @field_validator('data_range')
+    @classmethod
+    def data_range_validator(cls, data_range: str) -> str:
+        if '!' not in data_range or ':' not in data_range:
+            raise ValueError(
+                'Invalid data range. Expected format: Sheet1!A1:B2 or Sheet1!$A$1:$B$2'
+            )
+        return data_range
+
+    @field_validator('pivot_table_range')
+    @classmethod
+    def pivot_table_range_validator(cls, pivot_table_range: str) -> str:
+        if '!' not in pivot_table_range or ':' not in pivot_table_range:
+            raise ValueError(
+                'Invalid pivot_table_range. Expected format: Sheet1!A1:B2 or Sheet1!$A$1:$B$2'
+            )
+        return pivot_table_range
+
+    @field_validator('pivot_table_style_name')
+    @classmethod
+    def pivot_table_style_name_validator(cls, style: str) -> str:
+        if style not in _pivot_table_style:
+            raise ValueError(f'Invalid table style name. Expected one of {_pivot_table_style}')
+        return style

pyfastexcel/serializers.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, field_serializer, model_serializer
+from typing import Any, Optional
+
+from ._typing import CommentTextStructure, SetPanesSelection
+from .utils import CommentText, Selection, _validate_cell_reference
+
+
+class PanesSerializer(BaseModel):
+    selection: Optional[SetPanesSelection | list[Selection] | Selection] = None
+
+    @field_serializer('selection')
+    @classmethod
+    def serialize_selection(
+        cls,
+        selection: Optional[SetPanesSelection | list[Selection] | Selection],
+    ) -> list[dict[str, int]]:
+        if selection is None:
+            selection = []
+        elif not isinstance(selection, list):
+            selection = [selection]
+
+        selection = [item.to_dict() for item in selection if isinstance(item, Selection)]
+
+        return selection
+
+
+class CommentSerializer(BaseModel):
+    text: CommentTextStructure | CommentText | list[CommentText]
+
+    @field_serializer('text')
+    @classmethod
+    def serialize_text(
+        cls,
+        text: CommentTextStructure | CommentText | list[CommentText],
+    ) -> list[dict[str, str]]:
+        text = (
+            [text]
+            if isinstance(text, (str, CommentText))
+            else text
+            if isinstance(text, list)
+            else [text]
+        )
+        if all(isinstance(item, (dict, str)) for item in text):
+            for idx, item in enumerate(text):
+                if isinstance(item, str):
+                    text[idx] = {'text': item}
+                else:
+                    if 'text' not in item:
+                        raise ValueError('Comment text should contain the key "text".')
+                    text[idx] = {
+                        k[0].upper() + k[1:] if k != 'text' else k: v for k, v in item.items()
+                    }
+        elif all(isinstance(item, CommentText) for item in text):
+            text = [t.to_dict() for t in text]
+        return text
+
+
+class DataValidationSerializer(BaseModel):
+    set_range: Optional[list[int | float]]
+    input_msg: Optional[list[str]]
+    drop_list: Optional[list[str | int | float] | str]
+    error_msg: Optional[list[str]]
+
+    @model_serializer(mode='plain')
+    def model_serialize(self) -> dict[str, Any]:
+        drop_list_key = 'drop_list'
+        if isinstance(self.drop_list, str):
+            if ':' not in self.drop_list:
+                raise ValueError(
+                    'Invalid drop list. Sequential Reference'
+                    'Drop list should be in the format "A1:B2".',
+                )
+            drop_list_split = self.drop_list.split(':')
+            _validate_cell_reference(drop_list_split[0])
+            _validate_cell_reference(drop_list_split[1])
+            drop_list_key = 'sqref_drop_list'
+        elif self.drop_list is not None:
+            self.drop_list = [str(x) for x in self.drop_list]
+
+        dv = {}
+        if self.set_range is not None:
+            if not isinstance(self.set_range, list) or len(self.set_range) != 2:
+                raise ValueError('Set range should be a list of two elements. Like [1, 10].')
+            dv['set_range'] = self.set_range
+        if self.input_msg is not None:
+            if not isinstance(self.input_msg, list) or len(self.input_msg) != 2:
+                raise ValueError(
+                    'Input message should be a list of two elements. Like ["Title", "Body"].',
+                )
+            dv['input_title'] = self.input_msg[0]
+            dv['input_body'] = self.input_msg[1]
+        if self.drop_list is not None:
+            dv[drop_list_key] = self.drop_list
+        if self.error_msg is not None:
+            dv['error_title'] = self.error_msg[0]
+            dv['error_body'] = self.error_msg[1]
+
+        return dv

pyfastexcel/style.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from openpyxl_style_writer import CustomStyle
+from .logformatter import formatter, log_warning
+
+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
+
+# TODO: Implement a CustomStyle without the dependency of openpyxl_style_writer
+
+
+class StyleManager:
+    """
+    A class to set custom styles for Excel files.
+
+    ### Attributes:
+        BORDER_TO_INDEX (dict[str, int]): Mapping of border styles to excelize's
+        corresponding index.
+
+    ### Methods:
+        set_custom_style(cls, name: str, custom_style: CustomStyle): Set custom style
+        by register method.
+        _create_style(): Creates custom styles for the Excel file.
+        _get_style_collections(): Gets collections of custom styles.
+        _get_default_style(): Gets the default style.
+        _update_style_map(style_name: str, custom_style: CustomStyle): Updates
+            the style map.
+        _get_font_style(style: CustomStyle): Gets the font style.
+        _get_fill_style(style: CustomStyle): Gets the fill style.
+        _get_border_style(style: CustomStyle): Gets the border style.
+        _get_alignment_style(style: CustomStyle): Gets the alignment style.
+        _get_protection_style(style: CustomStyle): Gets the protection style.
+    """
+
+    BORDER_TO_INDEX = {
+        None: 0,
+        'thick': 5,
+        'slantDashDot': 13,
+        'dotted': 4,
+        'hair': 7,
+        'dashed': 3,
+        'double': 6,
+        'mediumDashDotDot': 12,
+        'medium': 2,
+        'dashDotDot': 11,
+        'thin': 1,
+        'dashDot': 9,
+        'mediumDashed': 8,
+        'mediumDashDot': 10,
+    }
+    # The style retrieved from set_custom_style will be stored in
+    # REGISTERED_STYLES temporarily. It will be created after any
+    # Writer is initialized and calls the self._create_style() method.
+    DEFAULT_STYLE = CustomStyle()
+    REGISTERED_STYLES = {'DEFAULT_STYLE': DEFAULT_STYLE}
+    _STYLE_NAME_MAP = {}
+    _STYLE_ID = 0
+    # The shared memory in the parent class that stores every CustomStyle
+    # from different Writer classes.
+    _style_map = {}
+
+    @classmethod
+    def set_custom_style(cls, name: str, custom_style: CustomStyle):
+        if cls.REGISTERED_STYLES.get(name):
+            log_warning(
+                logger,
+                f'{name} has already existed. Overiding the style settings.',
+            )
+        cls.REGISTERED_STYLES[name] = custom_style
+        cls._STYLE_NAME_MAP[custom_style] = name
+
+    @classmethod
+    def reset_style_configs(cls):
+        cls.REGISTERED_STYLES = {'DEFAULT_STYLE': cls.DEFAULT_STYLE}
+        cls._STYLE_NAME_MAP = {}
+        cls._STYLE_ID = 0
+        cls._style_map = {}
+
+    def _get_default_style(self) -> dict[str, dict[str, Any] | str]:
+        """
+        Gets the default style.
+
+        Returns:
+            dict[str, dict[str, Any] | str]: A dictionary containing the
+                default style settings.
+        """
+        return {
+            'Font': {},
+            'Fill': {},
+            'Border': {},
+            'Alignment': {},
+            'Protection': {},
+            'CustomNumFmt': 'general',
+        }
+
+    def _update_style_map(self, style_name: str, custom_style: CustomStyle) -> None:
+        if self._style_map.get(style_name):
+            log_warning(
+                logger,
+                f'{style_name} has already existed. Overiding the style settings.',
+            )
+        self._style_map[style_name] = self._get_default_style()
+        self._style_map[style_name]['Font'] = self._get_font_style(custom_style)
+        self._style_map[style_name]['Fill'] = self._get_fill_style(custom_style)
+        self._style_map[style_name]['Border'] = self._get_border_style(custom_style)
+        self._style_map[style_name]['Alignment'] = self._get_alignment_style(custom_style)
+        self._style_map[style_name]['Protection'] = self._get_protection_style(custom_style)
+        self._style_map[style_name]['CustomNumFmt'] = custom_style.number_format
+
+    def _get_font_style(self, style: CustomStyle) -> dict[str, str | int | bool | None]:
+        font_style_map = {}
+        if style.font.name:
+            font_style_map['Family'] = style.font.name
+        if style.font.sz:
+            font_style_map['Size'] = style.font.sz
+        if style.font.b:
+            font_style_map['Bold'] = style.font.b
+        if style.font.i:
+            font_style_map['Italic'] = style.font.i
+        if style.font.strike:
+            font_style_map['Strike'] = style.font.strike
+        if style.font.u:
+            font_style_map['UnderLine'] = style.font.u
+        if style.font.color.rgb:
+            font_style_map['Color'] = f'#{style.font.color.rgb[2:]}'
+        return font_style_map
+
+    def _get_fill_style(self, style: CustomStyle) -> dict[str, str]:
+        fill_style_map = {}
+        if style.fill.fgColor.rgb:
+            fill_style_map['Color'] = f'#{style.fill.fgColor.rgb[2:]}'
+        fill_style_map['Type'] = 'pattern'
+        fill_style_map['Pattern'] = 1
+        return fill_style_map
+
+    def _get_border_style(self, style: CustomStyle) -> dict[str, str]:
+        border_style_map = {}
+        direction = ['left', 'right', 'top', 'bottom']
+
+        for d in direction:
+            border_style_map[d] = {}
+
+        if style.border.left.style:
+            border_style_map['left']['Style'] = self.BORDER_TO_INDEX[style.border.left.style]
+        if style.border.right.style:
+            border_style_map['right']['Style'] = self.BORDER_TO_INDEX[style.border.right.style]
+        if style.border.top.style:
+            border_style_map['top']['Style'] = self.BORDER_TO_INDEX[style.border.top.style]
+        if style.border.bottom.style:
+            border_style_map['bottom']['Style'] = self.BORDER_TO_INDEX[style.border.bottom.style]
+
+        if style.border.left.color.rgb:
+            border_style_map['left']['Color'] = f'#{style.border.left.color.rgb[2:]}'
+        if style.border.right.color.rgb:
+            border_style_map['right']['Color'] = f'#{style.border.right.color.rgb[2:]}'
+        if style.border.top.color.rgb:
+            border_style_map['top']['Color'] = f'#{style.border.top.color.rgb[2:]}'
+        if style.border.bottom.color.rgb:
+            border_style_map['bottom']['Color'] = f'#{style.border.bottom.color.rgb[2:]}'
+        return border_style_map
+
+    def _get_alignment_style(self, style: CustomStyle) -> dict[str, str]:
+        ali_style_map = {}
+
+        if style.ali.horizontal:
+            ali_style_map['Horizontal'] = style.ali.horizontal
+        if style.ali.vertical:
+            ali_style_map['Vertical'] = style.ali.vertical
+        if style.ali.wrapText:
+            ali_style_map['WrapText'] = style.ali.wrapText
+        if style.ali.shrinkToFit:
+            ali_style_map['ShrinkToFit'] = style.ali.shrinkToFit
+        if style.ali.indent:
+            ali_style_map['Indent'] = style.ali.indent
+        if style.ali.readingOrder:
+            ali_style_map['ReadingOrder'] = style.ali.readingOrder
+        if style.ali.textRotation:
+            ali_style_map['TextRotation'] = style.ali.textRotation
+        if style.ali.justifyLastLine:
+            ali_style_map['JustifyLastLine'] = style.ali.justifyLastLine
+        if style.ali.relativeIndent:
+            ali_style_map['RelativeIndent'] = style.ali.relativeIndent
+
+        return ali_style_map
+
+    def _get_protection_style(self, style: CustomStyle) -> dict[str, str]:
+        protection_style_map = {}
+        if style.protection.locked:
+            protection_style_map['Locked'] = style.protection.locked
+        if style.protection.hidden:
+            protection_style_map['Hidden'] = style.protection.hidden
+        return protection_style_map