pyfastexcel 0.0.8__tar.gz → 0.0.9__tar.gz

{pyfastexcel-0.0.8 → pyfastexcel-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyfastexcel
-Version: 0.0.8
+Version: 0.0.9
 Summary: High performace excel file generation library.
 Home-page: https://github.com/Zncl2222/pyfastexcel
 Author: Zncl2222
@@ -100,7 +100,7 @@ If you prefer to build the package manually, follow these steps:
 
 ## Usage
 
-The index assignment is now avaliable in `Workbook` and the `FastWriter`.
+The index assignment is now avaliable in `Workbook` and the `StreamWriter`.
 Here is the example usage:
 
 ```python
@@ -146,8 +146,8 @@ if __name__ == '__main__':
 
 ```
 
-You can also using the `FastWriter` or `NormalWriter` which was the
-subclass of `Workbook` to write excel row by row, see the more in documentations [quickstart](https://pyfastexcel.readthedocs.io/en/stable/quickstart/).
+You can also using the `StreamWriter` which was the
+subclass of `Workbook` to write excel row by row, see more in [StreamWriter](https://pyfastexcel.readthedocs.io/en/stable/writer/).
 
 ## Documentation
 

{pyfastexcel-0.0.8 → pyfastexcel-0.0.9}/README.md

@@ -76,7 +76,7 @@ If you prefer to build the package manually, follow these steps:
 
 ## Usage
 
-The index assignment is now avaliable in `Workbook` and the `FastWriter`.
+The index assignment is now avaliable in `Workbook` and the `StreamWriter`.
 Here is the example usage:
 
 ```python
@@ -122,8 +122,8 @@ if __name__ == '__main__':
 
 ```
 
-You can also using the `FastWriter` or `NormalWriter` which was the
-subclass of `Workbook` to write excel row by row, see the more in documentations [quickstart](https://pyfastexcel.readthedocs.io/en/stable/quickstart/).
+You can also using the `StreamWriter` which was the
+subclass of `Workbook` to write excel row by row, see more in [StreamWriter](https://pyfastexcel.readthedocs.io/en/stable/writer/).
 
 ## Documentation
 

pyfastexcel-0.0.9/pyfastexcel/_typing.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Literal, TypedDict, Optional, List, Union
+
+
+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
+
+
+CommentTextStructure = Union[str, List[str], CommentTextDict, List[CommentTextDict]]
+SetPanesSelection = List[SelectionDict]

{pyfastexcel-0.0.8 → pyfastexcel-0.0.9}/pyfastexcel/driver.py

@@ -20,10 +20,9 @@ class ExcelDriver:
     A driver class to write data to Excel files using custom styles.
 
     ### Attributes:
-        BORDER_TO_INDEX (dict[str, int]): Mapping of border styles to excelize's
-        corresponding index.
         _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.
@@ -58,15 +57,22 @@ class ExcelDriver:
         'SHA-512',
     )
 
-    def __init__(self):
+    def __init__(self, pre_allocate: dict[str, int] = None, plain_data: list[list[str]] = None):
         """
-        Initializes the PyExcelizeDriver.
+        Initializes the Workbook with default settings and initializes Sheet1.
 
-        It initializes the Excel data, file properties, default sheet,
-        current sheet, and style mappings.
+        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(),
+            'Sheet1': WorkSheet(pre_allocate=pre_allocate, plain_data=plain_data),
         }
         self.file_props = self._get_default_file_props()
         self.sheet = 'Sheet1'

{pyfastexcel-0.0.8 → pyfastexcel-0.0.9}/pyfastexcel/utils.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import re
 import string
 import warnings
+from dataclasses import dataclass
 from typing import Any, Literal
 
 from openpyxl_style_writer import CustomStyle
@@ -10,6 +11,44 @@ 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 deprecated_warning(msg: str):
     warnings.warn(
         msg,
@@ -48,6 +87,17 @@ def validate_and_format_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, str]:
     '''
     Separate the alpha and numeric part of a string.
@@ -61,6 +111,9 @@ def _separate_alpha_numeric(input_string: str) -> tuple[str, str]:
 
 
 def _is_valid_column(column: str) -> bool:
+    """
+    Validate the alphabet part of the column.
+    """
     column = column.upper()
     index = 0
     for c in column:
@@ -69,6 +122,9 @@ def _is_valid_column(column: str) -> bool:
 
 
 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:
@@ -85,6 +141,9 @@ def column_to_index(column: str) -> int:
 
 
 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:
@@ -96,14 +155,17 @@ def index_to_column(index: int) -> str:
     return name
 
 
-def excel_index_to_list_index(index: str) -> tuple[int, int]:
+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_excel_index(index: str) -> bool:
+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):

{pyfastexcel-0.0.8 → pyfastexcel-0.0.9}/pyfastexcel/workbook.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Literal
+
 from pyfastexcel.driver import ExcelDriver, WorkSheet
 from pyfastexcel.utils import deprecated_warning
 
@@ -43,16 +45,26 @@ class Workbook(ExcelDriver):
         self._sheet_list = tuple(self.workbook.keys())
         self.sheet = self._sheet_list[0]
 
-    def create_sheet(self, sheet_name: str) -> None:
+    def create_sheet(
+        self,
+        sheet_name: str,
+        pre_allocate: dict[str, int] = None,
+        plain_data: list[list] = None,
+    ) -> None:
         """
         Creates a new sheet, and set it as current self.sheet.
 
         Args:
             sheet_name (str): The name of the new sheet.
+            pre_allocate (dict[str, int], optional): A dictionary containing
+                'n_rows' and 'n_cols' keys specifying the dimensions
+                for pre-allocating data in new sheet.
+            plain_data (list[list[str]], optional): A 2D list of strings
+                representing initial data to populate new sheet.
         """
         if self.workbook.get(sheet_name) is not None:
             raise ValueError(f'Sheet {sheet_name} already exists.')
-        self.workbook[sheet_name] = WorkSheet()
+        self.workbook[sheet_name] = WorkSheet(pre_allocate=pre_allocate, plain_data=plain_data)
         self.sheet = sheet_name
         self._sheet_list = tuple([x for x in self._sheet_list] + [sheet_name])
 
@@ -122,3 +134,65 @@ class Workbook(ExcelDriver):
     def auto_filter(self, sheet: str, target_range: str) -> None:
         self._check_if_sheet_exists(sheet)
         self.workbook[sheet].auto_filter(target_range)
+
+    def set_panes(
+        self,
+        sheet: str,
+        freeze: bool = False,
+        split: bool = False,
+        x_split: int = 0,
+        y_split: int = 0,
+        top_left_cell: str = '',
+        active_pane: Literal['bottomLeft', 'bottomRight', 'topLeft', 'topRight', ''] = '',
+        selection: list[dict[str, str]] = None,
+    ) -> None:
+        self._check_if_sheet_exists(sheet)
+        self.workbook[sheet].set_panes(
+            freeze=freeze,
+            split=split,
+            x_split=x_split,
+            y_split=y_split,
+            top_left_cell=top_left_cell,
+            active_pane=active_pane,
+            selection=selection,
+        )
+
+    def set_data_validation(
+        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,
+    ):
+        self._check_if_sheet_exists(sheet)
+        self.workbook[sheet].set_data_validation(
+            sq_ref=sq_ref,
+            set_range=set_range,
+            input_msg=input_msg,
+            drop_list=drop_list,
+            error_msg=error_msg,
+        )
+
+    def add_comment(
+        self,
+        sheet: str,
+        cell: str,
+        author: str,
+        text: str | dict[str, str] | list[str | dict[str, str]],
+    ) -> None:
+        """
+        Adds a comment to the specified cell.
+        Args:
+            sheet (str): The name of the sheet.
+            cell (str): The cell location to add the comment.
+            author (str): The author of the comment.
+            text (str | dict[str, str] | list[str | dict[str, str]]): The text of the comment.
+        Raises:
+            ValueError: If the cell location is invalid.
+        Returns:
+            None
+        """
+        self._check_if_sheet_exists(sheet)
+        self.workbook[sheet].add_comment(cell, author, text)

{pyfastexcel-0.0.8 → pyfastexcel-0.0.9}/pyfastexcel/worksheet.py

@@ -1,18 +1,22 @@
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Literal, Optional, List
 
 from openpyxl_style_writer import CustomStyle
 
 from .style import StyleManager
+from ._typing import CommentTextStructure, SetPanesSelection
 from .utils import (
+    CommentText,
+    Selection,
     _separate_alpha_numeric,
-    _validate_excel_index,
+    _validate_cell_reference,
     column_to_index,
     deprecated_warning,
-    excel_index_to_list_index,
+    cell_reference_to_index,
     validate_and_format_value,
     validate_and_register_style,
+    transfer_string_slice_to_slice,
 )
 
 
@@ -59,13 +63,37 @@ class WorkSheet:
             index. Raises TypeError if index_supported is False.
     """
 
-    def __init__(self):
+    def __init__(
+        self,
+        pre_allocate: Optional[dict[str, int]] = None,
+        plain_data: Optional[list[list[str]]] = None,
+    ):
         """
-        Initializes a WorkSheet instance.
+        Initializes a WorkSheet instance with optional pre-allocation of data or initialization
+        with plain data.
 
         Args:
-            index_supported (bool, optional): A flag indicating whether
-                index-based access is supported. Defaults to False.
+            pre_allocate (dict[str, int], optional): A dictionary containing 'n_rows' and 'n_cols'
+                keys specifying the dimensions for pre-allocating data.
+                This can enhancement the performance when you need to write a large excel
+            plain_data (list[list[str]], optional): A 2D list of strings representing the
+                initial data to populate the worksheet.
+
+        Notes:
+            If both `pre_allocate` and `plain_data` are provided, `plain_data` takes precedence.
+
+        Attributes:
+            sheet (dict): Default sheet settings.
+            data (list[list]): The main data structure holding worksheet contents.
+            header (list): List of header row items.
+            merge_cells (list): List of merged cell coordinates.
+            width (dict): Column widths.
+            height (dict): Row heights.
+            auto_filter_set (set): Set of auto-filter settings.
+
+        Raises:
+            TypeError: If `plain_data` is provided but is not a valid 2D list of strings.
+
         """
         self.sheet = self._get_default_sheet()
         self.data = [[('', 'DEFAULT_STYLE')]]
@@ -73,7 +101,37 @@ class WorkSheet:
         self.merge_cells = []
         self.width = {}
         self.height = {}
+        self.panes = {}
+        self.comment = []
         self.auto_filter_set = set()
+        self.data_validation_set = []
+
+        if plain_data is not None and pre_allocate is not None:
+            raise ValueError(
+                "You can only specify either 'pre_allocate' or 'plain_data' at a time, not both.",
+            )
+
+        if pre_allocate is not None:
+            if (
+                not isinstance(pre_allocate, dict)
+                or 'n_rows' not in pre_allocate
+                or 'n_cols' not in pre_allocate
+            ):
+                raise TypeError('Invalid pre_allocate dictionary format.')
+            if not isinstance(pre_allocate['n_rows'], int) or not isinstance(
+                pre_allocate['n_cols'],
+                int,
+            ):
+                raise TypeError('n_rows and n_cols must be integers.')
+            self.data = [[None] * pre_allocate['n_cols'] for _ in range(pre_allocate['n_rows'])]
+
+        if plain_data is not None:
+            if not isinstance(plain_data, list) or any(
+                not isinstance(row, list) for row in plain_data
+            ):
+                raise TypeError('plain_data should be a valid 2D list of strings.')
+            self.data = plain_data
+            self.sheet['NoStyle'] = True
 
     def cell(
         self,
@@ -135,7 +193,11 @@ class WorkSheet:
             style = StyleManager._STYLE_NAME_MAP[style]
 
         if isinstance(target, str):
-            self._apply_style_to_string_target(target, style)
+            if ':' in target:
+                target = transfer_string_slice_to_slice(target)
+                self._apply_style_to_slice_target(target, style)
+            else:
+                self._apply_style_to_string_target(target, style)
         elif isinstance(target, slice):
             self._apply_style_to_slice_target(target, style)
         elif isinstance(target, list) and len(target) == 2:
@@ -144,13 +206,8 @@ class WorkSheet:
             raise TypeError('Target should be a string, slice, or list[row, index].')
 
     def _apply_style_to_string_target(self, target: str, style: str):
-        if ':' not in target:
-            row, col = excel_index_to_list_index(target)
-            self.data[row][col] = (self.data[row][col][0], style)
-        else:
-            target_slice = target.split(':')
-            target = slice(target_slice[0], target_slice[1])
-            self._apply_style_to_slice_target(target, style)
+        row, col = cell_reference_to_index(target)
+        self.data[row][col] = (self.data[row][col][0], style)
 
     def _apply_style_to_slice_target(self, target: slice, style: str):
         start_row, start_col, col_stop = self._extract_slice_indices(target)
@@ -251,13 +308,161 @@ class WorkSheet:
         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_excel_index(target_list[0])
-        _validate_excel_index(target_list[1])
+        _validate_cell_reference(target_list[0])
+        _validate_cell_reference(target_list[1])
         self.auto_filter_set.add(target_range)
 
+    def set_panes(
+        self,
+        freeze: bool = False,
+        split: bool = False,
+        x_split: int = 0,
+        y_split: int = 0,
+        top_left_cell: str = '',
+        active_pane: Literal['bottomLeft', 'bottomRight', 'topLeft', 'topRight', ''] = '',
+        selection: Optional[SetPanesSelection | list[Selection]] = None,
+    ) -> 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 = []
+        self.panes = {
+            'freeze': freeze,
+            'split': split,
+            'x_split': x_split,
+            'y_split': y_split,
+            'top_left_cell': top_left_cell,
+            'active_pane': active_pane,
+            'selection': selection,
+        }
+
+    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,
+        error_msg: Optional[list[str]] = None,
+    ):
+        """
+        Set data validation for the specified range.
+
+        Args:
+            sq_ref (str): The range to set the data validation.
+            set_range (list[int | float]): The range of values to set the data validation.
+            input (list[str]): The input message for the data validation.
+            drop_list (list[str] | str): The drop list for the data validation.
+            error (list[str]): The error message for the data validation.
+
+        Raises:
+            ValueError: If the range is invalid.
+
+        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['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_set.append(dv)
+
+    def add_comment(
+        self,
+        cell: str,
+        author: str,
+        text: CommentTextStructure | CommentText | List[CommentText],
+    ) -> None:
+        """
+        Adds a comment to the specified cell.
+        Args:
+            cell (str): The cell location to add the comment.
+            author (str): The author of the comment.
+            text (str | dict[str, str] | list[str | dict[str, str]]): The text of the comment.
+        Raises:
+            ValueError: If the cell location is invalid.
+        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.')
+        self.comment.append({'cell': cell, 'author': author, 'paragraph': text})
+
     def _expand_row_and_cols(self, target_row: int, target_col: int):
         data_row_len = len(self.data)
         data_col_len = len(self.data[0])
+
+        if data_row_len > target_row and len(self.data[target_row]) > target_col:
+            return
+
         # Case when the memory space of self.data row is enough
         # but the memory space of the target_col is not enough
         if data_row_len > target_row:
@@ -284,6 +489,10 @@ class WorkSheet:
             'Width': self.width,
             'Height': self.height,
             'AutoFilter': self.auto_filter_set,
+            'Panes': self.panes,
+            'DataValidation': self.data_validation_set,
+            'NoStyle': self.sheet['NoStyle'],
+            'Comment': self.comment,
         }
         return self.sheet
 
@@ -295,6 +504,10 @@ class WorkSheet:
             'Width': {},
             'Height': {},
             'AutoFilter': set(),
+            'Panes': {},
+            'DataValidation': [],
+            'NoStyle': False,
+            'Comment': [],
         }
 
     def _validate_value_and_set_default(self, value: Any):
@@ -349,6 +562,9 @@ class WorkSheet:
         elif isinstance(key, int):
             return self.data[key]
         elif isinstance(key, str):
+            if ':' in key:
+                target = transfer_string_slice_to_slice(key)
+                return self._get_cell_by_slice(target)
             return self._get_cell_by_location(key)
 
     def __setitem__(self, key: str | slice | int, value: Any) -> None:
@@ -357,7 +573,11 @@ class WorkSheet:
         elif isinstance(key, int):
             self._set_row_by_index(key, value)
         elif isinstance(key, str):
-            self._set_cell_by_location(key, value)
+            if ':' in key:
+                target = transfer_string_slice_to_slice(key)
+                self._set_cell_by_slice(target, value)
+            else:
+                self._set_cell_by_location(key, value)
         else:
             raise TypeError('Key should be a string or slice.')
 
@@ -369,7 +589,7 @@ class WorkSheet:
         return self.data[int(start_row) - 1]
 
     def _get_cell_by_location(self, key: str) -> tuple:
-        row, col = excel_index_to_list_index(key)
+        row, col = cell_reference_to_index(key)
         return self.data[row][col]
 
     def _extract_slice_indices(self, cell_slice: slice) -> tuple[int, int, int]:
@@ -377,8 +597,8 @@ class WorkSheet:
         _, stop_row = _separate_alpha_numeric(cell_slice.stop)
         if start_row != stop_row:
             raise ValueError('Only support row-wise slicing.')
-        start_row, start_col = excel_index_to_list_index(cell_slice.start)
-        _, col_stop = excel_index_to_list_index(cell_slice.stop)
+        start_row, start_col = cell_reference_to_index(cell_slice.start)
+        _, col_stop = cell_reference_to_index(cell_slice.stop)
         self._expand_row_and_cols(start_row, col_stop)
         return start_row, start_col, col_stop
 
@@ -398,7 +618,7 @@ class WorkSheet:
         self.data[row] = value
 
     def _set_cell_by_location(self, key: str, value: Any) -> None:
-        row, col = excel_index_to_list_index(key)
+        row, col = cell_reference_to_index(key)
         value = self._validate_value_and_set_default(value)
         try:
             self.data[row][col] = value

{pyfastexcel-0.0.8 → pyfastexcel-0.0.9}/pyfastexcel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyfastexcel
-Version: 0.0.8
+Version: 0.0.9
 Summary: High performace excel file generation library.
 Home-page: https://github.com/Zncl2222/pyfastexcel
 Author: Zncl2222
@@ -100,7 +100,7 @@ If you prefer to build the package manually, follow these steps:
 
 ## Usage
 
-The index assignment is now avaliable in `Workbook` and the `FastWriter`.
+The index assignment is now avaliable in `Workbook` and the `StreamWriter`.
 Here is the example usage:
 
 ```python
@@ -146,8 +146,8 @@ if __name__ == '__main__':
 
 ```
 
-You can also using the `FastWriter` or `NormalWriter` which was the
-subclass of `Workbook` to write excel row by row, see the more in documentations [quickstart](https://pyfastexcel.readthedocs.io/en/stable/quickstart/).
+You can also using the `StreamWriter` which was the
+subclass of `Workbook` to write excel row by row, see more in [StreamWriter](https://pyfastexcel.readthedocs.io/en/stable/writer/).
 
 ## Documentation
 

{pyfastexcel-0.0.8 → pyfastexcel-0.0.9}/pyfastexcel.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 setup.cfg
 setup.py
 pyfastexcel/__init__.py
+pyfastexcel/_typing.py
 pyfastexcel/driver.py
 pyfastexcel/pyfastexcel.dll
 pyfastexcel/pyfastexcel.so

{pyfastexcel-0.0.8 → pyfastexcel-0.0.9}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = pyfastexcel
-version = 0.0.8
+version = 0.0.9
 description = High performace excel file generation library.
 long_description = file: README.md
 long_description_content_type = text/markdown