pyfastexcel 0.1.2__tar.gz → 0.1.4__tar.gz

{pyfastexcel-0.1.2 → pyfastexcel-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyfastexcel
-Version: 0.1.2
+Version: 0.1.4
 Summary: High performace excel file generation library.
 Home-page: https://github.com/Zncl2222/pyfastexcel
 Author: Zncl2222
@@ -21,6 +21,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: msgspec
 Requires-Dist: openpyxl-style-writer>=1.1.3
+Requires-Dist: pydantic
+Requires-Dist: eval-type-backport; python_version < "3.9"
 
 # pyfastexcel
 

{pyfastexcel-0.1.2 → pyfastexcel-0.1.4}/pyfastexcel/_typing.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Literal, Protocol, TypedDict, Optional, List, Union
+from typing import Literal, Protocol, Optional, List, Union, TypeVar
+from typing_extensions import TypedDict
 
 
 class CommentTextDict(TypedDict, total=False):
@@ -25,5 +26,6 @@ class Writable(Protocol):
     def write(self, content: str) -> None: ...
 
 
+Self = TypeVar('Self')
 CommentTextStructure = Union[str, List[str], CommentTextDict, List[CommentTextDict]]
 SetPanesSelection = List[SelectionDict]

{pyfastexcel-0.1.2 → pyfastexcel-0.1.4}/pyfastexcel/driver.py

@@ -16,6 +16,7 @@ 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
@@ -160,6 +161,11 @@ class ExcelDriver:
                 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,
+                )
 
         # Set writer (if some of the function that excelize StremWriter is not support, and
         # system will use normal writer to write the excel)

pyfastexcel-0.1.4/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-0.1.2 → pyfastexcel-0.1.4}/pyfastexcel/utils.py

@@ -4,7 +4,9 @@ import logging
 import re
 import string
 import warnings
-from dataclasses import dataclass
+
+# from dataclasses import dataclass
+from pydantic.dataclasses import dataclass
 from typing import Any, Literal
 
 from openpyxl_style_writer import CustomStyle

pyfastexcel-0.1.4/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

{pyfastexcel-0.1.2 → pyfastexcel-0.1.4}/pyfastexcel/workbook.py

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
-from typing import Literal, Optional, overload
+from typing import Literal, Optional, overload, List
 
 from pyfastexcel.driver import ExcelDriver, WorkSheet
 from pyfastexcel.utils import deprecated_warning
 
+from pydantic import validate_call as pydantic_validate_call
+
+from ._typing import CommentTextStructure, SetPanesSelection
+from .utils import CommentText, Selection
+
 
 class Workbook(ExcelDriver):
     """
@@ -102,6 +107,7 @@ class Workbook(ExcelDriver):
         self._check_if_sheet_exists(sheet_name)
         self.sheet = sheet_name
 
+    @pydantic_validate_call
     def set_file_props(self, key: str, value: str) -> None:
         """
         Sets a file property.
@@ -117,6 +123,7 @@ class Workbook(ExcelDriver):
             raise ValueError(f'Invalid file property: {key}')
         self.file_props[key] = value
 
+    @pydantic_validate_call
     def protect_workbook(
         self,
         algorithm: str,
@@ -194,7 +201,7 @@ class Workbook(ExcelDriver):
         y_split: int = 0,
         top_left_cell: str = '',
         active_pane: Literal['bottomLeft', 'bottomRight', 'topLeft', 'topRight', ''] = '',
-        selection: list[dict[str, str]] = None,
+        selection: Optional[SetPanesSelection | list[Selection] | Selection] = None,
     ) -> None:
         self._check_if_sheet_exists(sheet)
         self.workbook[sheet].set_panes(
@@ -211,10 +218,10 @@ class Workbook(ExcelDriver):
         self,
         sheet: str,
         sq_ref: str = '',
-        set_range: list[int | float] = None,
-        input_msg: list[str] = None,
-        drop_list: list[str] | str = None,
-        error_msg: list[str] = None,
+        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,
     ):
         self._check_if_sheet_exists(sheet)
         self.workbook[sheet].set_data_validation(
@@ -230,7 +237,7 @@ class Workbook(ExcelDriver):
         sheet: str,
         cell: str,
         author: str,
-        text: str | dict[str, str] | list[str | dict[str, str]],
+        text: CommentTextStructure | CommentText | List[CommentText],
     ) -> None:
         """
         Adds a comment to the specified cell.
@@ -282,3 +289,27 @@ class Workbook(ExcelDriver):
             hidden,
             engine,
         )
+
+    def create_table(
+        self,
+        sheet: str,
+        cell_range: str,
+        name: str,
+        style_name: str = '',
+        show_first_column: bool = True,
+        show_last_column: bool = True,
+        show_row_stripes: bool = False,
+        show_column_stripes: bool = True,
+        validate_table: bool = True,
+    ):
+        self._check_if_sheet_exists(sheet)
+        self.workbook[self.sheet].create_table(
+            cell_range,
+            name,
+            style_name,
+            show_first_column,
+            show_last_column,
+            show_row_stripes,
+            show_column_stripes,
+            validate_table,
+        )

{pyfastexcel-0.1.2 → pyfastexcel-0.1.4}/pyfastexcel/worksheet.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import Any, Literal, Optional, List, overload
 
 from openpyxl_style_writer import CustomStyle
+from pydantic import validate_call as pydantic_validate_call
 
 from .style import StyleManager
 from ._typing import CommentTextStructure, SetPanesSelection
@@ -10,7 +11,6 @@ from .utils import (
     CommentText,
     Selection,
     _separate_alpha_numeric,
-    _validate_cell_reference,
     column_to_index,
     deprecated_warning,
     cell_reference_to_index,
@@ -18,6 +18,8 @@ from .utils import (
     validate_and_register_style,
     transfer_string_slice_to_slice,
 )
+from .validators import validate_call
+from .serializers import CommentSerializer, PanesSerializer, DataValidationSerializer
 
 
 class WorkSheetBase:
@@ -71,6 +73,7 @@ class WorkSheetBase:
         self._data_validation_list = []
         self._grouped_columns_list = []
         self._grouped_rows_list = []
+        self._table_list = []
         # Using pyfastexcel to write as default
         self._engine: Literal['pyfastexcel', 'openpyxl'] = 'pyfastexcel'
 
@@ -131,8 +134,10 @@ class WorkSheetBase:
 
     def _expand_row_and_cols(self, target_row: int, target_col: int) -> None:
         data_row_len = len(self._data)
+        d = ()
         if data_row_len == 0:
-            self._data.append([('', 'DEFAULT_STYLE')])
+            # self._data.append([('', 'DEFAULT_STYLE')])
+            self._data.append([d])
             data_row_len = 1
         data_col_len = len(self._data[0])
 
@@ -144,17 +149,14 @@ class WorkSheetBase:
         if data_row_len > target_row:
             if data_col_len <= target_col:
                 self._data[target_row].extend(
-                    [('', 'DEFAULT_STYLE') for _ in range(target_col + 1 - data_col_len)],
+                    [d for _ in range(target_col + 1 - data_col_len)],
                 )
         else:
             current_row = max(data_row_len, target_row + 1)
             current_col = max(data_col_len, target_col + 1)
-            default_value = ('', 'DEFAULT_STYLE')
+            # default_value = ('', 'DEFAULT_STYLE')
             self._data.extend(
-                [
-                    [default_value for _ in range(current_col)]
-                    for _ in range(current_row - data_row_len)
-                ],
+                [[d for _ in range(current_col)] for _ in range(current_row - data_row_len)],
             )
 
     def _transfer_to_dict(self) -> dict[str, Any]:
@@ -170,6 +172,7 @@ class WorkSheetBase:
             'Comment': self._comment_list,
             'GroupedRow': self._grouped_rows_list,
             'GroupedCol': self._grouped_columns_list,
+            'Table': self._table_list,
         }
         return self._sheet
 
@@ -186,6 +189,7 @@ class WorkSheetBase:
             'Comment': [],
             'GroupedRow': [],
             'GroupedCol': [],
+            'Table': [],
         }
 
     def _validate_value_and_set_default(self, value: Any):
@@ -224,7 +228,7 @@ class WorkSheetBase:
                     'Style should be a string or CustomStyle object.',
                 )
             # The case that user do not register the Custom Style by 'Class attributes'
-            # or set_cumston_style function.
+            # or set_custom_style function.
             if (
                 isinstance(value[1], CustomStyle)
                 and StyleManager._STYLE_NAME_MAP.get(value[1]) is None
@@ -352,7 +356,7 @@ class WorkSheet(WorkSheetBase):
         self,
         row: int,
         column: int,
-        value: any,
+        value: Any,
         style: str | CustomStyle = 'DEFAULT_STYLE',
     ) -> None:
         """
@@ -420,6 +424,7 @@ class WorkSheet(WorkSheetBase):
         else:
             raise TypeError('Target should be a string, slice, or list[row, index].')
 
+    @pydantic_validate_call
     def set_cell_width(self, col: str | int, value: int) -> None:
         if isinstance(col, str):
             col = column_to_index(col)
@@ -427,6 +432,7 @@ class WorkSheet(WorkSheetBase):
             raise ValueError(f'Invalid column index: {col}')
         self._width_dict[col] = value
 
+    @pydantic_validate_call
     def set_cell_height(self, row: int, value: int) -> None:
         if row < 1 or row > 1048576:
             raise ValueError(f'Invalid row index: {row}')
@@ -532,6 +538,7 @@ class WorkSheet(WorkSheetBase):
 
         self._merged_cells_list.append((top_left_cell, bottom_right_cell))
 
+    @validate_call
     def auto_filter(self, target_range: str) -> None:
         """
         Sets the auto filter for the specified range.
@@ -545,13 +552,9 @@ class WorkSheet(WorkSheetBase):
         Returns:
             None
         """
-        if ':' not in target_range:
-            raise ValueError('Invalid target range. Target range should be in the format "A1:B2".')
-        target_list = target_range.split(':')
-        _validate_cell_reference(target_list[0])
-        _validate_cell_reference(target_list[1])
         self._auto_filter_set.add(target_range)
 
+    @validate_call
     def set_panes(
         self,
         freeze: bool = False,
@@ -560,7 +563,7 @@ class WorkSheet(WorkSheetBase):
         y_split: int = 0,
         top_left_cell: str = '',
         active_pane: Literal['bottomLeft', 'bottomRight', 'topLeft', 'topRight', ''] = '',
-        selection: Optional[SetPanesSelection | list[Selection]] = None,
+        selection: Optional[SetPanesSelection | list[Selection] | Selection] = None,
     ) -> None:
         """
         Sets the panes for the worksheet with options for freezing, splitting, and selection.
@@ -583,21 +586,7 @@ class WorkSheet(WorkSheetBase):
         Returns:
             None
         """
-        if x_split < 0 or y_split < 0:
-            raise ValueError('Split position should be positive.')
-        if top_left_cell != '':
-            _validate_cell_reference(top_left_cell)
-        if active_pane not in ['bottomLeft', 'bottomRight', 'topLeft', 'topRight', '']:
-            raise ValueError(
-                'Invalid active pane. The options are bottomLeft, bottomRight, topLeft, topRight.',
-            )
-
-        if selection is None:
-            selection = []
-        elif not isinstance(selection, list):
-            selection = [selection]
-
-        selection = [item.to_dict() for item in selection if isinstance(item, Selection)]
+        selection = PanesSerializer.serialize_selection(selection)
 
         self._panes_dict = {
             'freeze': freeze,
@@ -609,12 +598,13 @@ class WorkSheet(WorkSheetBase):
             'selection': selection,
         }
 
+    @validate_call
     def set_data_validation(
         self,
         sq_ref: str = '',
         set_range: Optional[list[int | float]] = None,
         input_msg: Optional[list[str]] = None,
-        drop_list: Optional[list[str] | str] = None,
+        drop_list: Optional[list[str | int | float] | str] = None,
         error_msg: Optional[list[str]] = None,
     ):
         """
@@ -633,54 +623,16 @@ class WorkSheet(WorkSheetBase):
         Returns:
             None
         """
-        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)
-
-        drop_list_key = 'drop_list'
-        if isinstance(drop_list, str):
-            if ':' not in drop_list:
-                raise ValueError(
-                    'Invalid drop list. Sequential Reference'
-                    'Drop list should be in the format "A1:B2".',
-                )
-            drop_list_split = drop_list.split(':')
-            _validate_cell_reference(drop_list_split[0])
-            _validate_cell_reference(drop_list_split[1])
-            drop_list_key = 'sqref_drop_list'
-        elif drop_list is not None:
-            if not isinstance(drop_list, list):
-                raise ValueError('Drop list should be a list of strings.')
-            drop_list = [str(x) for x in drop_list]
-
-        dv = {}
+        dv = DataValidationSerializer(
+            set_range=set_range,
+            input_msg=input_msg,
+            drop_list=drop_list,
+            error_msg=error_msg,
+        ).model_dump()
         dv['sq_ref'] = sq_ref
-        if set_range is not None:
-            if not isinstance(set_range, list) or len(set_range) != 2:
-                raise ValueError('Set range should be a list of two elements. Like [1, 10].')
-            dv['set_range'] = set_range
-        if input_msg is not None:
-            if not isinstance(input_msg, list) or len(input_msg) != 2:
-                raise ValueError(
-                    'Input message should be a list of two elements. Like ["Title", "Body"].',
-                )
-            dv['input_title'] = input_msg[0]
-            dv['input_body'] = input_msg[1]
-        if drop_list is not None:
-            dv[drop_list_key] = drop_list
-        if error_msg is not None:
-            if not isinstance(error_msg, list) or len(error_msg) != 2:
-                raise ValueError(
-                    'Error message should be a list of two elements. Like ["Title", "Body"].',
-                )
-            dv['error_title'] = error_msg[0]
-            dv['error_body'] = error_msg[1]
-
         self._data_validation_list.append(dv)
 
+    @validate_call
     def add_comment(
         self,
         cell: str,
@@ -698,30 +650,11 @@ class WorkSheet(WorkSheetBase):
         Returns:
             None
         """
-        _validate_cell_reference(cell)
-        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]
-        else:
-            raise ValueError('Comment text should be a string or a list of dictionaries.')
+        text = CommentSerializer.serialize_text(text)
+
         self._comment_list.append({'cell': cell, 'author': author, 'paragraph': text})
 
+    @pydantic_validate_call
     def group_columns(
         self,
         start_col: str,
@@ -756,6 +689,7 @@ class WorkSheet(WorkSheetBase):
         )
         self._engine = engine
 
+    @pydantic_validate_call
     def group_rows(
         self,
         start_row: int,
@@ -789,3 +723,47 @@ class WorkSheet(WorkSheetBase):
             }
         )
         self._engine = engine
+
+    @validate_call
+    def create_table(
+        self,
+        cell_range: str,
+        name: str,
+        style_name: str = '',
+        show_first_column: bool = True,
+        show_last_column: bool = True,
+        show_row_stripes: bool = False,
+        show_column_stripes: bool = True,
+        validate_table: bool = True,
+    ):
+        """
+        Creates a table within the specified cell range with given style and display options.
+
+        Args:
+            cell_range (str): The cell range where the table should be created (e.g., 'A1:D10').
+            name (str): The name of the table.
+            style_name (str): The style to apply to the table. Defaults to an empty string, which
+            applies the default style.
+            show_first_column (bool): Whether to emphasize the first column.
+            show_last_column (bool): Whether to emphasize the last column.
+            show_row_stripes (bool): Whether to show row stripes for alternate row shading.
+            show_column_stripes (bool): Whether to show column stripes for alternate column shading.
+            validate_table (bool): Whether to validate the table through TableFinalValidation.
+
+        Returns:
+            None
+        """
+        table = {
+            'range': cell_range,
+            'name': name,
+            'style_name': style_name,
+            'show_first_column': show_first_column,
+            'show_last_column': show_last_column,
+            'show_row_stripes': show_row_stripes,
+            'show_column_stripes': show_column_stripes,
+            # validate_table is a flag to decide whether
+            # to validate the table by TableFinalValidation
+            'validate_table': validate_table,
+        }
+
+        self._table_list.append(table)

{pyfastexcel-0.1.2 → pyfastexcel-0.1.4}/pyfastexcel/writer.py

@@ -133,14 +133,12 @@ class StreamWriter(Workbook):
         elif isinstance(style, str):
             style = self._handle_string_style(style, kwargs)
 
+        value = tuple((validate_and_format_value(x, set_default_style=False), style) for x in value)
+
         if create_row:
-            value = tuple(
-                (validate_and_format_value(x, set_default_style=False), style) for x in value
-            )
             self.workbook[self.sheet].data.append(value)
         else:
-            value = validate_and_format_value(value, set_default_style=False)
-            self._row_list.append((value, style))
+            self._row_list.extend(value)
 
     def create_row(self):
         """

{pyfastexcel-0.1.2 → pyfastexcel-0.1.4}/pyfastexcel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyfastexcel
-Version: 0.1.2
+Version: 0.1.4
 Summary: High performace excel file generation library.
 Home-page: https://github.com/Zncl2222/pyfastexcel
 Author: Zncl2222
@@ -21,6 +21,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: msgspec
 Requires-Dist: openpyxl-style-writer>=1.1.3
+Requires-Dist: pydantic
+Requires-Dist: eval-type-backport; python_version < "3.9"
 
 # pyfastexcel
 

{pyfastexcel-0.1.2 → pyfastexcel-0.1.4}/pyfastexcel.egg-info/SOURCES.txt

@@ -8,8 +8,10 @@ pyfastexcel/driver.py
 pyfastexcel/logformatter.py
 pyfastexcel/pyfastexcel.dll
 pyfastexcel/pyfastexcel.so
+pyfastexcel/serializers.py
 pyfastexcel/style.py
 pyfastexcel/utils.py
+pyfastexcel/validators.py
 pyfastexcel/workbook.py
 pyfastexcel/worksheet.py
 pyfastexcel/writer.py

pyfastexcel-0.1.4/pyfastexcel.egg-info/requires.txt

@@ -0,0 +1,6 @@
+msgspec
+openpyxl-style-writer>=1.1.3
+pydantic
+
+[:python_version < "3.9"]
+eval-type-backport

{pyfastexcel-0.1.2 → pyfastexcel-0.1.4}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = pyfastexcel
-version = 0.1.2
+version = 0.1.4
 description = High performace excel file generation library.
 long_description = file: README.md
 long_description_content_type = text/markdown
@@ -27,6 +27,8 @@ packages =
 install_requires = 
 	msgspec
 	openpyxl-style-writer>=1.1.3
+	pydantic
+	eval-type-backport;python_version < '3.9'
 python_requires = >=3.7
 include_package_data = true
 zip_safe = false

pyfastexcel-0.1.2/pyfastexcel.egg-info/requires.txt

@@ -1,2 +0,0 @@
-msgspec
-openpyxl-style-writer>=1.1.3