pyfastexcel 0.0.6__tar.gz → 0.0.7__tar.gz

pyfastexcel-0.0.7/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.1
+Name: pyfastexcel
+Version: 0.0.7
+Summary: High performace excel file generation library.
+Home-page: https://github.com/Zncl2222/pyfastexcel
+Author: Zncl2222
+Author-email: 3002shinning@gmail.com
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Go
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msgspec
+Requires-Dist: openpyxl-style-writer>=1.1.3
+
+# pyfastexcel
+
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Zncl2222/pyfastexcel/go.yml?logo=go)
+[![Go Report Card](https://goreportcard.com/badge/github.com/Zncl2222/pyfastexcel)](https://goreportcard.com/report/github.com/Zncl2222/pyfastexcel)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Zncl2222/pyfastexcel/pre-commit.yml?logo=pre-commit&label=pre-commit)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Zncl2222/pyfastexcel/codeql.yml?logo=github&label=CodeQL)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/03f42030775045b791586dee20288905)](https://app.codacy.com/gh/Zncl2222/pyfastexcel/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![codecov](https://codecov.io/gh/Zncl2222/pyfastexcel/graph/badge.svg?token=6I03AWUUWL)](https://codecov.io/gh/Zncl2222/pyfastexcel)
+[![Documentation Status](https://readthedocs.org/projects/pyfastexcel/badge/?version=stable)](https://pyfastexcel.readthedocs.io/en/stable/?badge=stable)
+
+This package enables high-performance Excel writing by integrating with the
+streaming API from the golang package
+[excelize](https://github.com/qax-os/excelize). Users can leverage this
+functionality without the need to write any Go code, as the entire process
+can be accomplished through Python.
+
+## Features
+
+- Python and Golang Integration: Seamlessly call Golang built shared
+libraries from Python.
+
+- No Golang Code Required: Users can solely rely on Python for Excel file
+generation, eliminating the need for Golang expertise.
+
+## Installation
+
+### Install via pip (Recommended)
+
+You can easily install the package via pip
+
+```bash
+pip install pyfastexcel
+```
+
+### Install manually
+
+If you prefer to build the package manually, follow these steps:
+
+1. Clone the repository:
+
+    ```bash
+    git clone https://github.com/Zncl2222/pyfastexcel.git
+    ```
+
+2. Go to the project root directory:
+
+    ```bash
+    cd pyfastexcel
+    ```
+
+3. Install the required golang packages:
+
+    ```bash
+    go mod download
+    ```
+
+4. Build the Golang shared library using the Makefile:
+
+    ```bash
+    make
+    ```
+
+5. Install the required python packages:
+
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+    or
+
+    ```bash
+    pipenv install
+    ```
+
+6. Import the project and start using it!
+
+## Usage
+
+The index assignment is now avaliable in `Workbook` and the `FastWriter`.
+Here is the example usage:
+
+```python
+from pyfastexcel import Workbook
+from pyfastexcel.utils import set_custom_style
+
+# CustomStyle will be integrate to the pyfatexcel in next version
+# Beside, CustomStyle will be re-implement in future to make it no-longer
+# depend on openpyxl_style writer and openpyxl
+from openpyxl_style_writer import CustomStyle
+
+
+if __name__ == '__main__':
+    # Workbook
+    wb = Workbook()
+
+    # Set and register CustomStyle
+    bold_style = CustomStyle(font_size=15, font_bold=True)
+    set_custom_style('bold_style', bold_style)
+
+    ws = wb['Sheet1']
+    # Write value with default style
+    ws['A1'] = 'A1 value'
+    # Write value with custom style
+    ws['B1'] = ('B1 value', 'bold_style')
+
+    # Write value in slice with default style
+    ws['A2': 'C2'] = [1, 2, 3]
+    # Write value in slice with custom style
+    ws['A3': 'C3'] = [(1, 'bold_style'), (2, 'bold_style'), (3, 'bold_style')]
+
+    # Write value by row with default style (python index 0 is the index 1 in excel)
+    ws[3] = [9, 8, 'go']
+    # Write value by row with custom style
+    ws[4] = [(9, 'bold_style'), (8, 'bold_style'), ('go', 'bold_style')]
+
+    # Send request to golang lib and create excel
+    wb.read_lib_and_create_excel()
+
+    # File path to save
+    file_path = 'pyexample_workbook.xlsx'
+    wb.save(file_path)
+
+```
+
+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/).
+
+## Documentation
+
+The documentation is hosted on Read the Docs.
+
+- [Development Version](https://pyfastexcel.readthedocs.io/en/latest/)
+
+- [Latest Stable Version](https://pyfastexcel.readthedocs.io/en/stable/)
+
+## How it Works
+
+The core functionality revolves around encoding Excel cell data and styles,
+or any other Excel properties, into a JSON string within Python. This JSON
+payload is then passed through ctypes to a Golang shared library. In Golang,
+the JSON is parsed, and using the streaming writer of
+[excelize](https://github.com/qax-os/excelize) to wrtie excel in
+high performance.
+
+## Current Limitations & Future Plans
+
+### Problem 1: Dependence on Other Excel Package
+
+Limitations:
+
+This project currently depends on the `CustomStyle` object of
+the [openpyxl_style_writer](https://github.com/Zncl2222/openpyxl_style_writer)
+package, which is built for openpyxl to write styles in write-only
+mode more efficiently without duplicating code.
+
+Future Plans:
+
+This project plans to create its own `Style` object, making it no longer
+dependent on the mentioned package.

pyfastexcel-0.0.7/README.md

@@ -0,0 +1,159 @@
+# pyfastexcel
+
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Zncl2222/pyfastexcel/go.yml?logo=go)
+[![Go Report Card](https://goreportcard.com/badge/github.com/Zncl2222/pyfastexcel)](https://goreportcard.com/report/github.com/Zncl2222/pyfastexcel)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Zncl2222/pyfastexcel/pre-commit.yml?logo=pre-commit&label=pre-commit)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Zncl2222/pyfastexcel/codeql.yml?logo=github&label=CodeQL)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/03f42030775045b791586dee20288905)](https://app.codacy.com/gh/Zncl2222/pyfastexcel/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![codecov](https://codecov.io/gh/Zncl2222/pyfastexcel/graph/badge.svg?token=6I03AWUUWL)](https://codecov.io/gh/Zncl2222/pyfastexcel)
+[![Documentation Status](https://readthedocs.org/projects/pyfastexcel/badge/?version=stable)](https://pyfastexcel.readthedocs.io/en/stable/?badge=stable)
+
+This package enables high-performance Excel writing by integrating with the
+streaming API from the golang package
+[excelize](https://github.com/qax-os/excelize). Users can leverage this
+functionality without the need to write any Go code, as the entire process
+can be accomplished through Python.
+
+## Features
+
+- Python and Golang Integration: Seamlessly call Golang built shared
+libraries from Python.
+
+- No Golang Code Required: Users can solely rely on Python for Excel file
+generation, eliminating the need for Golang expertise.
+
+## Installation
+
+### Install via pip (Recommended)
+
+You can easily install the package via pip
+
+```bash
+pip install pyfastexcel
+```
+
+### Install manually
+
+If you prefer to build the package manually, follow these steps:
+
+1. Clone the repository:
+
+    ```bash
+    git clone https://github.com/Zncl2222/pyfastexcel.git
+    ```
+
+2. Go to the project root directory:
+
+    ```bash
+    cd pyfastexcel
+    ```
+
+3. Install the required golang packages:
+
+    ```bash
+    go mod download
+    ```
+
+4. Build the Golang shared library using the Makefile:
+
+    ```bash
+    make
+    ```
+
+5. Install the required python packages:
+
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+    or
+
+    ```bash
+    pipenv install
+    ```
+
+6. Import the project and start using it!
+
+## Usage
+
+The index assignment is now avaliable in `Workbook` and the `FastWriter`.
+Here is the example usage:
+
+```python
+from pyfastexcel import Workbook
+from pyfastexcel.utils import set_custom_style
+
+# CustomStyle will be integrate to the pyfatexcel in next version
+# Beside, CustomStyle will be re-implement in future to make it no-longer
+# depend on openpyxl_style writer and openpyxl
+from openpyxl_style_writer import CustomStyle
+
+
+if __name__ == '__main__':
+    # Workbook
+    wb = Workbook()
+
+    # Set and register CustomStyle
+    bold_style = CustomStyle(font_size=15, font_bold=True)
+    set_custom_style('bold_style', bold_style)
+
+    ws = wb['Sheet1']
+    # Write value with default style
+    ws['A1'] = 'A1 value'
+    # Write value with custom style
+    ws['B1'] = ('B1 value', 'bold_style')
+
+    # Write value in slice with default style
+    ws['A2': 'C2'] = [1, 2, 3]
+    # Write value in slice with custom style
+    ws['A3': 'C3'] = [(1, 'bold_style'), (2, 'bold_style'), (3, 'bold_style')]
+
+    # Write value by row with default style (python index 0 is the index 1 in excel)
+    ws[3] = [9, 8, 'go']
+    # Write value by row with custom style
+    ws[4] = [(9, 'bold_style'), (8, 'bold_style'), ('go', 'bold_style')]
+
+    # Send request to golang lib and create excel
+    wb.read_lib_and_create_excel()
+
+    # File path to save
+    file_path = 'pyexample_workbook.xlsx'
+    wb.save(file_path)
+
+```
+
+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/).
+
+## Documentation
+
+The documentation is hosted on Read the Docs.
+
+- [Development Version](https://pyfastexcel.readthedocs.io/en/latest/)
+
+- [Latest Stable Version](https://pyfastexcel.readthedocs.io/en/stable/)
+
+## How it Works
+
+The core functionality revolves around encoding Excel cell data and styles,
+or any other Excel properties, into a JSON string within Python. This JSON
+payload is then passed through ctypes to a Golang shared library. In Golang,
+the JSON is parsed, and using the streaming writer of
+[excelize](https://github.com/qax-os/excelize) to wrtie excel in
+high performance.
+
+## Current Limitations & Future Plans
+
+### Problem 1: Dependence on Other Excel Package
+
+Limitations:
+
+This project currently depends on the `CustomStyle` object of
+the [openpyxl_style_writer](https://github.com/Zncl2222/openpyxl_style_writer)
+package, which is built for openpyxl to write styles in write-only
+mode more efficiently without duplicating code.
+
+Future Plans:
+
+This project plans to create its own `Style` object, making it no longer
+dependent on the mentioned package.

pyfastexcel-0.0.7/pyfastexcel/__init__.py

@@ -0,0 +1,13 @@
+from openpyxl_style_writer import CustomStyle, DefaultStyle
+
+from pyfastexcel.writer import FastWriter, NormalWriter, Workbook
+
+__all__ = [
+    'Workbook',
+    'FastWriter',
+    'NormalWriter',
+    # Temporary link the CustomStyle from openpyxl_style_writer for
+    # convinent usage.
+    'CustomStyle',
+    'DefaultStyle',
+]

{pyfastexcel-0.0.6 → pyfastexcel-0.0.7}/pyfastexcel/driver.py

@@ -11,12 +11,13 @@ from typing import Any
 import msgspec
 from openpyxl_style_writer import CustomStyle
 
-from .exceptions import CreateFileNotCalledError
 from .utils import (
     column_to_index,
     excel_index_to_list_index,
     extract_numeric_part,
     separate_alpha_numeric,
+    validate_and_format_value,
+    validate_and_register_style,
 )
 
 BASE_DIR = Path(__file__).resolve().parent
@@ -109,6 +110,7 @@ class ExcelDriver:
         self.file_props = self._get_default_file_props()
         self.sheet = 'Sheet1'
         self._sheet_list = tuple(['Sheet1'])
+        self._dict_wb = {}
 
     @property
     def sheet_list(self):
@@ -119,11 +121,16 @@ class ExcelDriver:
         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 save(self, path: str = './pyfastexcel.xlsx') -> None:
         if not hasattr(self, 'decoded_bytes'):
-            raise CreateFileNotCalledError(
-                'Function read_lib_and_create_excel should be ' + 'called before saving the file.',
-            )
+            self.read_lib_and_create_excel()
 
         with open(path, 'wb') as file:
             file.write(self.decoded_bytes)
@@ -150,10 +157,10 @@ class ExcelDriver:
 
         # Transfer all WorkSheet Object to the sheet dictionary in the workbook.
         for sheet in self._sheet_list:
-            self.workbook[sheet] = self.workbook[sheet]._transfer_to_dict()
+            self._dict_wb[sheet] = self.workbook[sheet]._transfer_to_dict()
 
         results = {
-            'content': self.workbook,
+            'content': self._dict_wb,
             'file_props': self.file_props,
             'style': self._style_map,
         }
@@ -166,6 +173,7 @@ class ExcelDriver:
         byte_data = create_excel(json_data)
         self.decoded_bytes = base64.b64decode(ctypes.cast(byte_data, ctypes.c_char_p).value)
         free_pointer(byte_data)
+        ExcelDriver.reset_style_configs()
         return self.decoded_bytes
 
     def _read_lib(self, lib_path: str) -> ctypes.CDLL:
@@ -371,6 +379,9 @@ class WorkSheet:
             Validates the input value and ensures it is a tuple with the correct
             format.
 
+        set_style(target: str | slice | list[int, int], style: CustomStyle | str) -> None:
+            Applies a style to specified cells.
+
         __getitem__(key: str | slice | int) -> tuple | list[tuple]:
             If index_supported is True, retrieves the cell value at the
             specified index. Raises TypeError if index_supported is False.
@@ -427,6 +438,71 @@ class WorkSheet:
             self._expand_row_and_cols(row, column)
             self.data[row][column] = value
 
+    def set_style(
+        self,
+        target: str | slice | list[int, int],
+        style: CustomStyle | str,
+    ) -> None:
+        """
+        Applies a specified style to a target range of cells.
+
+        Args:
+            target (str | slice | list[int, int]): Target cells to apply style.
+            style (CustomStyle | str): Style to apply to the cells.
+
+        Raises:
+            TypeError: If target type is invalid.
+            ValueError: If style is not registered.
+        """
+        if self.index_supported is False:
+            raise IndexError('Index is not supported in this Writer.')
+
+        if isinstance(style, str):
+            if ExcelDriver.REGISTERED_STYLES.get(style) is None:
+                raise ValueError(
+                    f'Style not found: {style}. Style should be register by '
+                    'set_custom_style function when you set a style with '
+                    'string.',
+                )
+        elif isinstance(style, CustomStyle):
+            if ExcelDriver._STYLE_NAME_MAP.get(style) is None:
+                validate_and_register_style(style)
+            style = ExcelDriver._STYLE_NAME_MAP[style]
+
+        if isinstance(target, str):
+            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:
+            self._apply_style_to_list_target(target, style)
+        else:
+            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)
+
+    def _apply_style_to_slice_target(self, target: slice, style: str):
+        start_row, start_col, col_stop = self._extract_slice_indices(target)
+        for col in range(start_col, col_stop + 1):
+            self.data[start_row][col] = (self.data[start_row][col][0], style)
+
+    def _apply_style_to_list_target(self, target: list[int, int], style: str):
+        row = target[0]
+        col = target[1]
+        if not isinstance(row, int) or not isinstance(col, int):
+            raise TypeError('Target should be a list of integers.')
+        if row < 0 or row > 1048576:
+            raise ValueError(f'Invalid row index: {row}')
+        if col < 0 or col > 16384:
+            raise ValueError(f'Invalid column index: {col}')
+        self.data[row][col] = (self.data[row][col][0], style)
+
     def set_cell_width(self, col: str | int, value: int) -> None:
         if isinstance(col, str):
             col = column_to_index(col)
@@ -550,19 +626,25 @@ class WorkSheet:
             or a CustomStyle object.
         """
         if not isinstance(value, tuple):
-            # Covert to string if value is not numeric or string
-            if not isinstance(value, (int, float, str)):
-                value = f'{value}'
-            value = (value, 'DEFAULT_STYLE')
+            value = validate_and_format_value(value)
         else:
             if len(value) != 2:
                 raise ValueError(
-                    'Cell value should be a tuple with two element' ' like (value, style).',
+                    'Cell value should be a tuple with two element like (value, style).',
                 )
             if not isinstance(value[1], (str, CustomStyle)):
                 raise TypeError(
                     '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.
+            if (
+                isinstance(value[1], CustomStyle)
+                and ExcelDriver._STYLE_NAME_MAP.get(value[1]) is None
+            ):
+                validate_and_register_style(value[1])
+                style = ExcelDriver._STYLE_NAME_MAP[value[1]]
+                value = (value[0], style)
         return value
 
     def __getitem__(self, key: str | slice) -> tuple | list[tuple]:
@@ -600,7 +682,7 @@ class WorkSheet:
         row, col = excel_index_to_list_index(key)
         return self.data[row][col]
 
-    def _set_cell_by_slice(self, cell_slice: slice, value: Any) -> None:
+    def _extract_slice_indices(self, cell_slice: slice) -> tuple[int, int, int]:
         start_row = extract_numeric_part(cell_slice.start)
         stop_row = extract_numeric_part(cell_slice.stop)
         if start_row != stop_row:
@@ -608,6 +690,10 @@ class WorkSheet:
         start_row, start_col = excel_index_to_list_index(cell_slice.start)
         _, col_stop = excel_index_to_list_index(cell_slice.stop)
         self._expand_row_and_cols(start_row, col_stop)
+        return start_row, start_col, col_stop
+
+    def _set_cell_by_slice(self, cell_slice: slice, value: Any) -> None:
+        start_row, start_col, col_stop = self._extract_slice_indices(cell_slice)
         for idx, col in enumerate(range(start_col, col_stop + 1)):
             val = self._validate_value_and_set_default(value[idx])
             self.data[start_row][col] = val

{pyfastexcel-0.0.6 → pyfastexcel-0.0.7}/pyfastexcel/utils.py

@@ -2,17 +2,18 @@ from __future__ import annotations
 
 import re
 import string
+from typing import Any, Literal
 
 from openpyxl_style_writer import CustomStyle
 
 
-def set_custom_style(style_name: str, style: CustomStyle):
+def set_custom_style(style_name: str, style: CustomStyle) -> None:
     from .driver import ExcelDriver
 
     ExcelDriver.set_custom_style(style_name, style)
 
 
-def style_validation(style: CustomStyle):
+def validate_and_register_style(style: CustomStyle) -> None:
     from .driver import ExcelDriver
 
     if not isinstance(style, CustomStyle):
@@ -23,6 +24,19 @@ def style_validation(style: CustomStyle):
     ExcelDriver._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 separate_alpha_numeric(input_string: str):
     alpha_part = re.findall(r'[a-zA-Z]+', input_string)
     num_part = re.findall(r'[0-9]+', input_string)

{pyfastexcel-0.0.6 → pyfastexcel-0.0.7}/pyfastexcel/writer.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+from typing import Any
+
 from openpyxl_style_writer import CustomStyle
 
 from pyfastexcel.driver import ExcelDriver, WorkSheet
 
-from .utils import style_validation
+from .utils import validate_and_format_value, validate_and_register_style
 
 
 class Workbook(ExcelDriver):
@@ -149,18 +151,19 @@ class FastWriter(Workbook):
         self.current_row = 0
         self.current_col = 0
 
-    def row_append(self, value: str, style: str | CustomStyle = 'DEFAULT_STYLE'):
+    def row_append(self, value: Any, style: str | CustomStyle = 'DEFAULT_STYLE'):
         """
         Appends a value to a specific row and column.
 
         Args:
-            value (str): The value to be appended.
+            value (Any): The value to be appended.
             style (str): The style of the value.
         """
         if isinstance(style, CustomStyle):
             if self._STYLE_NAME_MAP.get(style) is None:
-                style_validation(style)
+                validate_and_register_style(style)
             style = self._STYLE_NAME_MAP[style]
+        value = validate_and_format_value(value, set_default_style=False)
         self._row_list[self.current_row][self.current_col] = (value, style)
         self.current_col += 1
 
@@ -236,28 +239,25 @@ class NormalWriter(Workbook):
         self._row_list = []
         self.data = data
 
-    def row_append(self, value: str, style: str | CustomStyle = 'DEFAULT_STYLE'):
+    def row_append(self, value: Any, style: str | CustomStyle = 'DEFAULT_STYLE'):
         """
         Appends a value to the row list.
 
         Args:
-            value (str): The value to be appended.
+            value (Any): The value to be appended.
             style (str | CustomStyle): The style of the value, can be either
                 a style name or a CustomStyle object.
         """
         if isinstance(style, CustomStyle):
             if self._STYLE_NAME_MAP.get(style) is None:
-                style_validation(style)
+                validate_and_register_style(style)
             style = self._STYLE_NAME_MAP[style]
+        value = validate_and_format_value(value, set_default_style=False)
         self._row_list.append((value, style))
 
     def create_row(self):
         """
         Creates a row in the Excel data, and clean the current _row_list.
-
-        Args:
-            is_header (bool, optional): Indicates whether the row is a header
-                row. Defaults to False.
         """
         self.workbook[self.sheet].data.append(self._row_list)
         self._row_list = []