pyfastexcel 0.0.1__py3-none-any.whl

pyfastexcel/driver.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import sys
+
+from typing import Any
+from openpyxl_style_writer import RowWriter, CustomStyle
+from pathlib import Path
+
+import ctypes
+import msgspec
+import base64
+
+BASE_DIR = Path(__file__).resolve().parent
+
+
+class PyExcelizeDriver(RowWriter):
+    BORDER_TO_INDEX = {
+        None: 0,
+        'thick': 5,
+        'slantDashDot': 13,
+        'dotted': 4,
+        'hair': 7,
+        'dashed': 3,
+        'double': 6,
+        'mediumDashDotDot': 12,
+        'medium': 2,
+        'dashDotDot': 11,
+        'thin': 1,
+        'dashDot': 9,
+        'mediumDashed': 8,
+        'mediumDashDot': 10,
+    }
+
+    def __init__(self):
+        self.pyexcelize_data = {'Sheet1': self._get_default_sheet()}
+        self.sheet = 'Sheet1'
+        self.style_name_map = {}
+
+    def _get_default_sheet(self) -> dict[str, dict[str, list]]:
+        return {
+            'Header': [],
+            'Data': [],
+            'MergeCells': [],
+            'Width': [],
+        }
+
+    def create_excel(self) -> bytes:
+        self._create_style()
+        self._create_single_header()
+        self._create_body()
+        return self._read_lib_and_create_excel()
+
+    def remove_sheet(self, sheet: str) -> None:
+        self.pyexcelize_data.pop(sheet)
+
+    def create_sheet(self, sheet_name: str) -> None:
+        self.pyexcelize_data[sheet_name] = self._get_defualt_sheet()
+
+    def switch_sheet(self, sheet_name: str) -> None:
+        self.sheet = sheet_name
+        if self.pyexcelize_data.get(sheet_name) is None:
+            self.pyexcelize_data[sheet_name] = self._get_default_sheet()
+
+    def create_single_header(self) -> None:
+        pass
+
+    def create_body(self) -> None:
+        pass
+
+    def _read_lib(self, lib_path: str) -> str:
+        lib_path = f'{BASE_DIR}/pyfastexcel' if lib_path is None else lib_path
+        if lib_path.split('.')[-1] not in ('so', 'dll'):
+            if sys.platform.startswith('linux'):
+                lib_path += '.so'
+            elif sys.platform.startswith('win32'):
+                lib_path += '.dll'
+        lib = ctypes.CDLL(lib_path, winmode=0)
+        return lib
+
+    def _read_lib_and_create_excel(self, lib_path: str = None) -> bytes:
+        pyexcelize = self._read_lib(lib_path)
+        json_data = msgspec.json.encode(self.pyexcelize_data)
+        create_excel = pyexcelize.Export
+        free_pointer = pyexcelize.FreeCPointer
+        free_pointer.argtypes = [ctypes.c_void_p]
+        create_excel.argtypes = [ctypes.c_char_p]
+        create_excel.restype = ctypes.c_void_p
+        byte_data = create_excel(json_data)
+        decoded_bytes = base64.b64decode(ctypes.cast(byte_data, ctypes.c_char_p).value)
+        free_pointer(byte_data)
+        return decoded_bytes
+
+    def _create_style(self) -> None:
+        style_collections = self._get_style_collections()
+        self.style_map_name = {val: key for key, val in style_collections.items()}
+        self.style_map = {}
+        for key, val in style_collections.items():
+            self._update_style_map(key, val)
+        self.pyexcelize_data['Style'] = self.style_map
+
+    def _get_style_collections(self) -> dict[str, CustomStyle]:
+        return {
+            attr: getattr(self, attr)
+            for attr in dir(self)
+            if not callable(getattr(self, attr)) and isinstance(getattr(self, attr), CustomStyle)
+        }
+
+    def _get_default_style(self) -> dict[str, dict[str, Any] | str]:
+        return {
+            'Font': {},
+            'Fill': {},
+            'Border': {},
+            'Alignment': {},
+            'Protection': {},
+            'CustomNumFmt': 'general',
+        }
+
+    def _update_style_map(self, style_name: str, custom_style: CustomStyle) -> None:
+        self.style_map[style_name] = self._get_default_style()
+        self.style_map[style_name]['Font'] = self._get_font_style(custom_style)
+        self.style_map[style_name]['Fill'] = self._get_fill_style(custom_style)
+        self.style_map[style_name]['Border'] = self._get_border_style(custom_style)
+        self.style_map[style_name]['Alignment'] = self._get_alignment_style(custom_style)
+        self.style_map[style_name]['Protection'] = self._get_protection_style(custom_style)
+        self.style_map[style_name]['CustomNumFmt'] = custom_style.number_format
+
+    def _get_font_style(self, style: CustomStyle) -> dict[str, str | int | bool | None]:
+        font_style_map = {}
+        if style.font.name:
+            font_style_map['Name'] = style.font.name
+        if style.font.sz:
+            font_style_map['Size'] = style.font.sz
+        if style.font.family:
+            font_style_map['Family'] = style.font.family
+        if style.font.b:
+            font_style_map['Bold'] = style.font.b
+        if style.font.i:
+            font_style_map['Italic'] = style.font.i
+        if style.font.strike:
+            font_style_map['Strike'] = style.font.strike
+        if style.font.u:
+            font_style_map['UnderLine'] = style.font.u
+        if style.font.color.rgb:
+            font_style_map['Color'] = f'#{style.font.color.rgb[2:]}'
+        return font_style_map
+
+    def _get_fill_style(self, style: CustomStyle) -> dict[str, str]:
+        fill_style_map = {}
+        if style.fill.fgColor.rgb:
+            fill_style_map['Color'] = f'#{style.fill.fgColor.rgb[2:]}'
+        fill_style_map['Type'] = 'pattern'
+        fill_style_map['Pattern'] = 1
+        return fill_style_map
+
+    def _get_border_style(self, style: CustomStyle) -> dict[str, str]:
+        border_style_map = {}
+        direction = ['left', 'right', 'top', 'bottom']
+
+        for d in direction:
+            border_style_map[d] = {}
+
+        if style.border.left.style:
+            border_style_map['left']['Style'] = self.BORDER_TO_INDEX[style.border.left.style]
+        if style.border.right.style:
+            border_style_map['right']['Style'] = self.BORDER_TO_INDEX[style.border.right.style]
+        if style.border.top.style:
+            border_style_map['top']['Style'] = self.BORDER_TO_INDEX[style.border.top.style]
+        if style.border.bottom.style:
+            border_style_map['bottom']['Style'] = self.BORDER_TO_INDEX[style.border.bottom.style]
+
+        if style.border.left.color.rgb:
+            border_style_map['left']['Color'] = f'#{style.border.left.color.rgb[2:]}'
+        if style.border.right.color.rgb:
+            border_style_map['right']['Color'] = f'#{style.border.right.color.rgb[2:]}'
+        if style.border.top.color.rgb:
+            border_style_map['top']['Color'] = f'#{style.border.top.color.rgb[2:]}'
+        if style.border.bottom.color.rgb:
+            border_style_map['bottom']['Color'] = f'#{style.border.bottom.color.rgb[2:]}'
+        return border_style_map
+
+    def _get_alignment_style(self, style: CustomStyle) -> dict[str, str]:
+        ali_style_map = {}
+
+        if style.ali.horizontal:
+            ali_style_map['Horizontal'] = style.ali.horizontal
+        if style.ali.vertical:
+            ali_style_map['Vertical'] = style.ali.vertical
+        if style.ali.wrapText:
+            ali_style_map['WrapText'] = style.ali.wrapText
+        if style.ali.shrinkToFit:
+            ali_style_map['ShrinkToFit'] = style.ali.shrinkToFit
+        if style.ali.indent:
+            ali_style_map['Indent'] = style.ali.indent
+        if style.ali.readingOrder:
+            ali_style_map['ReadingOrder'] = style.ali.readingOrder
+        if style.ali.textRotation:
+            ali_style_map['TextRotation'] = style.ali.textRotation
+        if style.ali.justifyLastLine:
+            ali_style_map['JustifyLastLine'] = style.ali.justifyLastLine
+        if style.ali.relativeIndent:
+            ali_style_map['RelativeIndent'] = style.ali.relativeIndent
+
+        return ali_style_map
+
+    def _get_protection_style(self, style: CustomStyle) -> dict[str, str]:
+        protection_style_map = {}
+        if style.protection.locked:
+            protection_style_map['Locked'] = style.protection.locked
+        if style.protection.hidden:
+            protection_style_map['Hidden'] = style.protection.hidden
+        return protection_style_map
+
+
+class FastWriter(PyExcelizeDriver):
+    def __init__(self, data: list[dict[str, str]]):
+        super().__init__()
+        # The data is list[dict[str, str]] as default, if your data is other dtype
+        # You should override the __init___ method to allocate correct space for __row_list
+        self._row_list = [[None] * (len(data[0])) for _ in range(len(data))]
+        self.data = data
+
+    def row_append(self, value: str, style: str, row_idx: int, col_idx: int):
+        if isinstance(style, CustomStyle):
+            style = self.style_map_name[style]
+        self._row_list[row_idx][col_idx] = (value, style)
+
+    def _pop_none_from_row_list(self, idx: int) -> None:
+        for i in range(len(self._row_list[idx]) - 1, 0, -1):
+            if self._row_list[idx][i] is None:
+                self._row_list[idx].pop()
+            else:
+                break
+
+    def apply_to_header(self, idx: int = 0):
+        original_len = len(self._row_list[idx])
+        self._pop_none_from_row_list(idx)
+        self.pyexcelize_data[self.sheet]['Header'] = self._row_list[idx]
+        # Reset row_list for body creation
+        self._row_list[idx] = [None] * original_len
+
+    def create_row(self, idx):
+        self._pop_none_from_row_list(idx)
+        self.pyexcelize_data[self.sheet]['Data'].append(self._row_list[idx])
+
+
+class NormalWriter(PyExcelizeDriver):
+    def __init__(self, data: list[dict[str, str]]):
+        super().__init__()
+        self._row_list = []
+        self.data = data
+
+    def row_append(self, value: str, style: str | CustomStyle):
+        if isinstance(style, CustomStyle):
+            style = self.style_map_name[style]
+        self._row_list.append((value, style))
+
+    def create_row(self, is_header: bool = False):
+        key = 'Header' if is_header is True else 'Data'
+        self.pyexcelize_data[self.sheet][key].append(self._row_list)
+        self._row_list = []

pyfastexcel-0.0.1.dist-info/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Jian Yu, Chen
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pyfastexcel-0.0.1.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: pyfastexcel
+Version: 0.0.1
+Summary: High performace excel file generation library.
+Home-page: https://github.com/Zncl2222/pyfastexcel
+Author: Zncl2222
+Author-email: 3002shinning@gmail.com
+License: BSD-3-Clause
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: BSD 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
+
+# pyfastexcel
+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.
+
+## Installation
+```bash
+pip install pyfastexcel
+```
+
+## Introduction
+
+Comming soon...
+
+
+## Usage
+
+Comming soon...

pyfastexcel-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+pyfastexcel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyfastexcel/driver.py,sha256=AiJP2qWIXG-jJS_aiNmA6z17WSNA3676jCUnDEwVXOk,9969
+pyfastexcel/pyfastexcel.dll,sha256=Ow0zLQ1IUbn2eueMXG4K2FbVNGjnRrSkdEjvXNT6xOU,9653916
+pyfastexcel/pyfastexcel.so,sha256=qYAklVzlYPagfQ3SqIUI7HWbXlYAjQxzkUiAcXAl0Pk,6773624
+pyfastexcel-0.0.1.dist-info/LICENSE,sha256=kBvf8yHo7qOBx-m8Yd0aj6vRanVBcem_VUxNvbqzHpY,1500
+pyfastexcel-0.0.1.dist-info/METADATA,sha256=8htpOAtLqcqGPJN_4FCn5hGgYJGqmyb1xeXtXDB1uG8,1299
+pyfastexcel-0.0.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+pyfastexcel-0.0.1.dist-info/top_level.txt,sha256=OFydmanH9QXbV8Z2zDwxShLA1LbdRLbdbOa8xcTbYBE,12
+pyfastexcel-0.0.1.dist-info/RECORD,,

pyfastexcel-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyfastexcel-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyfastexcel