pyfastexcel 0.1.8__py3-none-win_amd64.whl

pyfastexcel/utils.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import logging
+import re
+import string
+import warnings
+
+# from dataclasses import dataclass
+from pydantic.dataclasses import dataclass
+from typing import Any, Literal
+
+from openpyxl_style_writer import CustomStyle
+
+warnings.simplefilter('always', DeprecationWarning)
+
+
+@dataclass
+class CommentText:
+    text: str
+    size: int | None = None
+    name: str | None = None
+    bold: bool | None = None
+    italic: bool | None = None
+    underline: Literal['single', 'double'] | None = None
+    strike: bool | None = None
+    vert_align: str | None = None
+    color: str | None = None
+
+    def to_dict(self):
+        result = {
+            k[0].upper() + k[1:]: v
+            for k, v in self.__dict__.items()
+            if v is not None and k != 'text'
+        }
+        if result.get('Vert_align') is not None:
+            result['VertAlign'] = result['Vert_align']
+        result['text'] = self.text
+        return result
+
+
+@dataclass
+class Selection:
+    sq_ref: str
+    active_cell: str
+    pane: str
+
+    def to_dict(self):
+        return {
+            'sq_ref': self.sq_ref,
+            'active_cell': self.active_cell,
+            'pane': self.pane,
+        }
+
+
+def set_debug_level(level: int):
+    logging.basicConfig(level=level)
+
+
+def deprecated_warning(msg: str):
+    warnings.warn(
+        msg,
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+
+def set_custom_style(style_name: str, style: CustomStyle) -> None:
+    from .style import StyleManager
+
+    StyleManager.set_custom_style(style_name, style)
+
+
+def validate_and_register_style(style: CustomStyle) -> None:
+    from .style import StyleManager
+
+    if not isinstance(style, CustomStyle):
+        raise TypeError(
+            f'Invalid type ({type(style)}). Style should be a CustomStyle object.',
+        )
+    set_custom_style(f'Custom Style {StyleManager._STYLE_ID}', style)
+    StyleManager._STYLE_ID += 1
+
+
+def validate_and_format_value(
+    value: Any,
+    set_default_style: bool = True,
+) -> tuple[Any, Literal['DEFAULT_STYLE']] | Any:
+    # Convert non-numeric value to string
+    value = f'{value}' if not isinstance(value, (int, float, str)) else value
+    # msgpec does not support np.float64, so we should convert
+    # it to python float.
+    value = float(value) if isinstance(value, float) else value
+
+    return (value, 'DEFAULT_STYLE') if set_default_style else value
+
+
+def transfer_string_slice_to_slice(string_slice: str) -> slice:
+    '''
+    Transfer a string slice to a slice object.
+    For example, 'A1:B2' will be transfered to slice(1, 2, 1).
+    '''
+    start, end = string_slice.split(':')
+    alpha_start, row_start = _separate_alpha_numeric(start)
+    alpha_end, row_end = _separate_alpha_numeric(end)
+    return slice(f'{alpha_start}{row_start}', f'{alpha_end}{row_end}')
+
+
+def _separate_alpha_numeric(input_string: str) -> tuple[str, int]:
+    '''
+    Separate the alpha and numeric part of a string.
+    Return alpha_part at first index and num_part at second index.
+    '''
+    alpha_part = re.findall(r'[a-zA-Z]+', input_string)
+    num_part = re.findall(r'[0-9]+', input_string)
+    if len(alpha_part) == 0 or len(num_part) == 0:
+        raise ValueError(f'Invalid input string {input_string}.')
+    return alpha_part[0], int(num_part[0])
+
+
+def _is_valid_column(column: str) -> bool:
+    """
+    Validate the alphabet part of the column.
+    """
+    column = column.upper()
+    index = 0
+    for c in column:
+        index = index * 26 + (ord(c) - ord('A')) + 1
+    return 1 <= index <= 16384
+
+
+def column_to_index(column: str) -> int:
+    """
+    Translate the column name to the column index.
+    """
+    if not isinstance(column, str):
+        raise TypeError(f'Invalid type ({type(column)}). Column should be a string.')
+    if len(column) > 3:
+        raise ValueError(f"Invalid column ({column}). Maximum Column is 'XFD'.")
+    if not all(c in string.ascii_uppercase for c in column):
+        raise ValueError(f'Invalid column ({column}). Column should be in uppercase.')
+    if not _is_valid_column(column):
+        raise ValueError(f"Invalid column ({column}). Maximum Column is 'XFD'.")
+    column = column.upper()
+    index = 0
+    for c in column:
+        index = index * 26 + (ord(c) - ord('A')) + 1
+    return index
+
+
+def index_to_column(index: int) -> str:
+    """
+    Translate the index to the column name.
+    """
+    if not isinstance(index, int):
+        raise TypeError(f'Invalid type ({type(index)}). Index should be a string.')
+    if index < 1 or index > 16384:
+        raise ValueError(f'Invalid index ({index}). Index should less and equal to 16384.')
+    name = ''
+    while index > 0:
+        index, r = divmod(index - 1, 26)
+        name = chr(r + ord('A')) + name
+    return name
+
+
+def cell_reference_to_index(index: str) -> tuple[int, int]:
+    """
+    Return the row and column index of the given Excel cell reference.
+    """
+    alpha, num = _separate_alpha_numeric(index)
+    column = column_to_index(alpha)
+    row = int(num)
+    return row - 1, column - 1
+
+
+def _validate_cell_reference(index: str) -> bool:
+    alpha, num = _separate_alpha_numeric(index)
+    num = int(num)
+    if not all(c in string.ascii_uppercase for c in alpha):
+        raise ValueError(f'Invalid column ({alpha}). Column should be in uppercase.')
+    if not _is_valid_column(alpha):
+        raise ValueError(f"Invalid column ({alpha}). Maximum Column is 'XFD'.")
+    if num < 1 or num > 16384:
+        raise ValueError(f'Invalid index ({num}). Index should less and equal to 16384.')
+    return True

pyfastexcel/validators.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import logging
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+from typing import Any, Optional, Literal
+
+from ._typing import CommentTextStructure, SetPanesSelection, Self
+from .logformatter import formatter
+from .utils import CommentText, Selection, cell_reference_to_index, _validate_cell_reference
+
+logger = logging.getLogger(__name__)
+style_formatter = logging.StreamHandler()
+style_formatter.setFormatter(formatter)
+
+logger.addHandler(style_formatter)
+logger.propagate = False
+
+_table_style_config: dict[str, int] = {
+    'TableStyleLight': 21,
+    'TableStyleMedium': 28,
+    'TableStyleDark': 11,
+}
+_table_style: set[str] = set()
+_table_style.add('')
+
+for s, num in _table_style_config.items():
+    for i in range(1, num + 1):
+        _table_style.add(f'{s}{i}')
+
+
+class TableValidator(BaseModel):
+    cell_range: str
+    name: str
+    style_name: str = Field(default='', strict=True)
+    show_first_column: bool = Field(default=True, strict=True)
+    show_last_column: bool = Field(default=True, strict=True)
+    show_row_stripes: bool = Field(default=False, strict=True)
+    show_column_stripes: bool = Field(default=True, strict=True)
+    validate_table: bool = Field(default=True, strict=True)
+
+    @field_validator('cell_range')
+    @classmethod
+    def validate_cell_range(cls, cell_range: str) -> str:
+        if ':' not in cell_range:
+            raise ValueError('Invalid cell range. Expected format: A1:B2')
+        cell_range_split = cell_range.split(':')
+        if len(cell_range_split) != 2:
+            raise ValueError('Invalid cell range. Expected format: A1:B2')
+
+        _validate_cell_reference(cell_range_split[0])
+        _validate_cell_reference(cell_range_split[1])
+
+        return cell_range
+
+    @field_validator('style_name')
+    @classmethod
+    def validate_style_name(cls, style_name: str) -> str:
+        if style_name not in _table_style:
+            raise ValueError(f'Invalid table style name. Expected one of {_table_style}')
+        return style_name
+
+
+class TableFinalValidation(BaseModel):
+    data: list
+    table_list: list[dict[str, Any]]
+
+    @model_validator(mode='after')
+    def validate_table_list(self) -> Self:
+        for t in self.table_list:
+            if t['validate_table'] is False:
+                continue
+            t_split = t['range'].split(':')
+            start_row, start_col = cell_reference_to_index(t_split[0])
+            end_row, end_col = cell_reference_to_index(t_split[1])
+
+            # Check if table range is valid, end_col should +1 because of length comparison
+            if end_col + 1 > len(self.data[start_row]):
+                raise ValueError(
+                    f"Invalid table range for {t['name']}. "
+                    'Please write a row for table first row.'
+                )
+
+            if len(set(self.data[start_row])) != len(self.data[start_row]):
+                raise ValueError(
+                    'Invalid table header. ' 'The first row contains duplicate values.'
+                )
+
+            end_row = len(self.data) - 1 if end_row >= len(self.data) else end_row
+            for col in range(start_col, end_col + 1):
+                column_data = [
+                    self.data[row][col] for row in range(start_row, end_row + 1) if self.data[row]
+                ]
+                first_element = column_data[0]
+                seen = set(column_data[1:])
+                if first_element in seen:
+                    raise ValueError('Invalid table data. Column contains duplicate values.')
+
+        return self
+
+
+class PanesValidator(BaseModel):
+    freeze: bool = Field(default=False, strict=True)
+    split: bool = Field(default=False, strict=True)
+    x_split: int = Field(default=0, strict=True)
+    y_split: int = Field(default=0, strict=True)
+    top_left_cell: str = Field(default='', strict=True)
+    active_pane: Literal['bottomLeft', 'bottomRight', 'topLeft', 'topRight', ''] = ''
+    selection: Optional[SetPanesSelection | list[Selection] | Selection] = None
+
+    @model_validator(mode='after')
+    def validate_panes(self) -> Self:
+        if self.x_split < 0 or self.y_split < 0:
+            raise ValueError('Split position should be positive.')
+        if self.top_left_cell != '':
+            _validate_cell_reference(self.top_left_cell)
+        return self
+
+
+class DataValidationValidator(BaseModel):
+    sq_ref: str = Field(default=False, strict=True)
+    set_range: Optional[list[int | float]] = None
+    input_msg: Optional[list[str]] = None
+    drop_list: Optional[list[str | int | float] | str] = None
+    error_msg: Optional[list[str]] = None
+
+    @field_validator('sq_ref')
+    @classmethod
+    def validate_style_name(cls, sq_ref: str) -> str:
+        if ':' in sq_ref:
+            sq_ref_list = sq_ref.split(':')
+            _validate_cell_reference(sq_ref_list[0])
+            _validate_cell_reference(sq_ref_list[1])
+        else:
+            _validate_cell_reference(sq_ref)
+        return sq_ref
+
+
+class AutoFilterValidator(BaseModel):
+    target_range: str
+
+    @field_validator('target_range')
+    @classmethod
+    def validate_target_range(cls, target_range: str) -> str:
+        if ':' not in target_range:
+            raise ValueError('Invalid target range. Target range should be in the format "A1:B2".')
+        target_list = target_range.split(':')
+        if len(target_list) != 2:
+            raise ValueError('Invalid target range. Target range should be in the format "A1:B2".')
+        _validate_cell_reference(target_list[0])
+        _validate_cell_reference(target_list[1])
+
+        return target_range
+
+
+class CommentValidator(BaseModel):
+    cell: str
+    author: str
+    text: CommentTextStructure | CommentText | list[CommentText]
+
+    @field_validator('cell')
+    @classmethod
+    def validate_cell(cls, cell: str) -> str:
+        _validate_cell_reference(cell)
+        return cell
+
+
+# Register validators and use them in the validate_call decorator
+VALIDATORS = {
+    'create_table': TableValidator,
+    'set_panes': PanesValidator,
+    'set_data_validation': DataValidationValidator,
+    'auto_filter': AutoFilterValidator,
+    'add_comment': CommentValidator,
+}
+
+
+def validate_call(func):
+    def wrapper(*args, **kwargs):
+        func_name = func.__name__
+        if func_name not in VALIDATORS:
+            logger.warning(f'No validator found for function {func_name}. Skipping validation.')
+            return func(*args, **kwargs)
+
+        validator = VALIDATORS[func_name]
+        model_fields = validator.model_fields
+        has_self = 'self' in func.__code__.co_varnames
+
+        actual_args = args[1:] if has_self else args
+
+        _kwargs = dict(zip(model_fields, actual_args), **kwargs)
+        validator(**_kwargs)
+
+        return func(*args, **kwargs)
+
+    return wrapper