tpltable 0.3.2__tar.gz → 0.3.4__tar.gz

{tpltable-0.3.2 → tpltable-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tpltable
-Version: 0.3.2
+Version: 0.3.4
 Summary: define "Excel" "Table|StyleTable" "Row|Col|StyleRow|StyleCol". Can dynamic modify excel data & styles. Support multiple kinds of indexes. (70%)
 Author-email: 2229066748@qq.com
 Maintainer: Eagle'sBaby

{tpltable-0.3.2 → tpltable-0.3.4}/setup.py

@@ -5,7 +5,7 @@ from setuptools import find_packages, setup
 
 setup(
     name='tpltable',
-    version='0.3.2',
+    version='0.3.4',
     description='define "Excel" "Table|StyleTable" "Row|Col|StyleRow|StyleCol". Can dynamic modify excel data & styles. Support multiple kinds of indexes. (70%)',
     author_email='2229066748@qq.com',
     maintainer="Eagle'sBaby",

{tpltable-0.3.2 → tpltable-0.3.4}/tpltable/basic.py

@@ -19,7 +19,8 @@ from openpyxl.styles import Font, Color, Alignment, Border, Side, PatternFill
 NaN = pd.NA
 nan = pd.NA
 
-isnan = pd.isna
+def isnan(value):
+    return pd.isna(value) or str(value) == 'nan'
 
 # NOTE: Colorama Start -------------------------------------------------------------------------->
 # 初始化colorama
@@ -72,6 +73,11 @@ COLORAMA_STYLES = {
 
 __PAT_COORD = re.compile("([A-Z]+)(\d+)")
 
+
+# 模糊的行列索引混用警告
+class AmbiguousIndexWarning(UserWarning):
+    ...
+
 class Coord:
     def __init__(self, iloc_c, iloc_r):
         self._r:int = iloc_r
@@ -142,7 +148,7 @@ def index_from_string(letters:str, *, only_int:bool=False, should:str=None) -> U
     if letters.isdigit():
         if should == 's':
             warnings.warn(
-                f"Here should be a letter, but got '{letters}'. Regarded as '{get_column_letter(int(letters))}'."
+                AmbiguousIndexWarning(f"Here should be a letter (Col-Index), but got '{letters}' (Row-Index). Regarded as '{get_column_letter(int(letters))}'."),
             )
         return int(letters)
     _s = __PAT_COORD.match(letters)
@@ -153,7 +159,7 @@ def index_from_string(letters:str, *, only_int:bool=False, should:str=None) -> U
         return Coord(index_from_string(_c) - 1, int(_r) - 1)
     if should == 'i':
         warnings.warn(
-            f"Here should be an digit, but got '{letters}'. Regarded as '{_column_index_from_string(letters)}'."
+            AmbiguousIndexWarning(f"Here should be an digit (Row-Index), but got '{letters}' (Col-Index). Regarded as '{_column_index_from_string(letters)}'.")
         )
     return _column_index_from_string(letters)
 

tpltable-0.3.4/tpltable/core.py

@@ -0,0 +1,12 @@
+from tpltable.basic import *
+
+
+class UnitCell:
+    def __init__(self, value, style):
+        self.value = value
+        self.style = style
+
+    def __str__(self):
+        return str(self.value)
+
+

{tpltable-0.3.2 → tpltable-0.3.4}/tpltable/excel.py

@@ -342,6 +342,7 @@ class ExcelFileIOException(Exception):
 
 
 class Excel(ListkeysDict):
+    _DEFAULT_PREFIX = 'Sheet'
     def __init__(self, fpath: str = None, *, style: bool = True):
         """
         *Create an Excel object from an excel file or empty

{tpltable-0.3.2 → tpltable-0.3.4}/tpltable/style.py

@@ -77,6 +77,24 @@ COLOR_MAGENTA = '00FF00FF'
 COLOR_DARKMAGENTA = '00800080'
 COLOR_LIGHTMAGENTA = '00FFC0CB'
 
+SIDE_THIN_BLACK = Side(style='thin', color=COLOR_BLACK)
+
+BORDER_LTRB = Border(SIDE_THIN_BLACK, SIDE_THIN_BLACK, SIDE_THIN_BLACK, SIDE_THIN_BLACK)
+BORDER_NOLEFT = Border(None, SIDE_THIN_BLACK, SIDE_THIN_BLACK, SIDE_THIN_BLACK)
+BORDER_NORIGHT = Border(SIDE_THIN_BLACK, None, SIDE_THIN_BLACK, SIDE_THIN_BLACK)
+BORDER_NOTOP = Border(SIDE_THIN_BLACK, SIDE_THIN_BLACK, None, SIDE_THIN_BLACK)
+BORDER_NOBOTTOM = Border(SIDE_THIN_BLACK, SIDE_THIN_BLACK, SIDE_THIN_BLACK, None)
+BORDER_LT = Border(SIDE_THIN_BLACK, SIDE_THIN_BLACK, None, None)
+BORDER_RB = Border(None, None, SIDE_THIN_BLACK, SIDE_THIN_BLACK)
+BORDER_LB = Border(SIDE_THIN_BLACK, None, None, SIDE_THIN_BLACK)
+BORDER_RT = Border(None, SIDE_THIN_BLACK, SIDE_THIN_BLACK, None)
+BORDER_LR = Border(SIDE_THIN_BLACK, SIDE_THIN_BLACK, None, None)
+BORDER_TB = Border(None, None, SIDE_THIN_BLACK, SIDE_THIN_BLACK)
+BORDER_L = Border(SIDE_THIN_BLACK, None, None, None)
+BORDER_R = Border(None, SIDE_THIN_BLACK, None, None)
+BORDER_T = Border(None, None, SIDE_THIN_BLACK, None)
+BORDER_B = Border(None, None, None, SIDE_THIN_BLACK)
+
 
 def _GetCellStyle(ws, cell, style_type: str) -> object:
     if style_type == TYPE_COLOR:
@@ -241,11 +259,11 @@ class Style:
             #         border_style: Incomplete | None = None,
             _l, _r, _t, _b, _diag = _bd.left, _bd.right, _bd.top, _bd.bottom, _bd.diagonal
             return {
-                'left': {'style': _l.style, 'color': _l.color, 'border_style': _l.border_style},
-                'right': {'style': _r.style, 'color': _r.color, 'border_style': _r.border_style},
-                'top': {'style': _t.style, 'color': _t.color, 'border_style': _t.border_style},
-                'bottom': {'style': _b.style, 'color': _b.color, 'border_style': _b.border_style},
-                'diagonal': {'style': _diag.style, 'color': _diag.color, 'border_style': _diag.border_style},
+                'left': {'style': _l.style, 'color': _l.color, 'border_style': _l.border_style} if _l is not None else None,
+                'right': {'style': _r.style, 'color': _r.color, 'border_style': _r.border_style} if _r is not None else None,
+                'top': {'style': _t.style, 'color': _t.color, 'border_style': _t.border_style} if _t is not None else None,
+                'bottom': {'style': _b.style, 'color': _b.color, 'border_style': _b.border_style} if _b is not None else None,
+                'diagonal': {'style': _diag.style, 'color': _diag.color, 'border_style': _diag.border_style} if _diag is not None else None,
                 'diagonal_direction': _bd.diagonal_direction,
                 'vertical': _bd.vertical, 'horizontal': _bd.horizontal,
                 'diagonalUp': _bd.diagonalUp, 'diagonalDown': _bd.diagonalDown,
@@ -301,6 +319,9 @@ class Style:
         self[key] = value
 
 
+
+
+
 def _raw_style() -> Style:
     wb = Workbook()
     ws = wb.active

{tpltable-0.3.2 → tpltable-0.3.4}/tpltable/table.py

@@ -4,13 +4,99 @@ import warnings
 import numpy as np
 import pandas as pd
 from tpltable.core import *
-from tpltable.style import Style
+from tpltable.style import Style, TYPE_BORDER
 
 _PAT_COORD = re.compile(r"([A-Z]+)(\d+)")
+
+
 class EMPTY_INDEX:
     pass
 
-class _ExcelIndexsLike_1DArray:
+
+class _ExcelIndexsLike_1DArray_Def:
+
+    def _reindexself(self) -> None:
+        """
+        Reindex the Series
+        * Return None. Modify self._sr inplace.
+        :return:
+        """
+        raise NotImplementedError
+
+    def _reconstruct(self, other) -> None:
+        """
+        Reconstruct self
+        * Return None. Modify self._sr inplace.
+        :param other: inst of __class__. The other instance.
+        :return:
+        """
+        raise NotImplementedError
+
+    def _construct_new_from_index(self, new_index: Union[int, slice], *, inplace=False) -> '__class__() | None':
+        """
+        Construct a new __class__ from the new index
+        * Use this instead of directly create a new __class__ object. So you can override this method to add some other logic.
+        :param new_index: int|slice. The new index you want to index self
+        *
+        :param inplace: bool. If True, modify self inplace. If True, Return None.
+        :return: inst of __class__ | None
+        """
+        raise NotImplementedError
+
+    def _construct_new_from_insert(self, insert_index: int, *values, inplace=False) -> '__class__() | None':
+        """
+        Construct a new __class__ from the new index
+        * Use this instead of directly create a new __class__ object. So you can override this method to add some other logic.
+        :param insert_index: int. The index to insert before.
+        :param *values: Any. The values to insert.
+        :param inplace:
+        :return: inst of __class__ | None
+        """
+        raise NotImplementedError
+
+    def _construct_new_from_delete(self, delete_index: Union[int, slice], *, inplace=False) -> '__class__() | None':
+        """
+        Construct a new __class__ from the new index
+        * Use this instead of directly create a new __class__ object. So you can override this method to add some other logic.
+        :param delete_index: int|slice. The index to delete.
+        *
+        :param inplace: bool. If True, modify self inplace. If True, Return None.
+        :return: inst of __class__ | None
+        """
+        raise NotImplementedError
+
+    def on_subinstance(self, construction: object) -> '__class__()':
+        """
+        Hook function called when a subinstance is created.
+        * Return the new instance. So you can modify the new instance.
+        * When this method is called, self is not modified.
+        :param construction: inst of __class__. The subinstance created.
+        :return: inst of __class__ | None
+        """
+        return construction
+
+    def on_insert(self, construction: object) -> '__class__()':
+        """
+        Hook function called when a subinstance is created.
+        * Return the new instance. So you can modify the new instance.
+        * When this method is called, self is not modified.
+        :param construction: inst of __class__. The subinstance created.
+        :return: inst of __class__
+        """
+        return construction
+
+    def on_delete(self, construction: object) -> '__class__()':
+        """
+        Hook function called when a subinstance is created.
+        * Return the new instance. So you can modify the new instance.
+        * When this method is called, self is not modified.
+        :param construction: inst of __class__. The subinstance created.
+        :return: inst of __class__
+        """
+        return construction
+
+
+class _ExcelIndexsLike_1DArray_Base(_ExcelIndexsLike_1DArray_Def):
     _CLS_DEFAULT_INDEX_TYPE = None  # "i" or "s" or None
 
     # None: integer index, start with 0 and label'0'
@@ -18,37 +104,119 @@ class _ExcelIndexsLike_1DArray:
     # "s": letter index, start with 0 and label:'A'
     def __init__(self, _from=None, *, copy: bool = True):
         self._sr: pd.Series = None
-        if isinstance(_from, pd.Series):
-            self._sr = _from
-            if copy:
-                self._sr = self._sr.copy()
+
+        if isinstance(_from, list):
+            try:
+                _from = np.array(_from)
+            except Exception as e:
+                raise ValueError(f"Failed to convert list to 1D array. {e}")
+
+        if _from is None:
+            self._sr = pd.Series()
         elif isinstance(_from, np.ndarray):
             # check shape
             s = _from.shape
             if np.ndim(_from) != 1:
                 raise ValueError(f"Only 1D array is supported. But got {np.ndim(_from)}D array.(shape={s})")
             self._sr = pd.Series(_from)
-
-        elif isinstance(_from, list):
-            try:
-                arr = np.array(_from)
-                s = arr.shape
-                if np.ndim(arr) != 1:
-                    raise ValueError(f"Only 1D array is supported. But got {np.ndim(arr)}D array from list.(shape={s})")
-                self._sr = pd.Series(arr)
-            except Exception as e:
-                raise ValueError(f"Failed to convert list to 1D array. {e}")
+        elif isinstance(_from, pd.Series):
+            self._sr = _from
+            if copy:
+                self._sr = self._sr.copy()
+        elif isinstance(_from, _ExcelIndexsLike_1DArray_Base):
+            self._sr = _from._sr.copy()
         else:
             raise ValueError(f"Unsupported type: {type(_from)}")
 
-        self._reindex()
+        self._reindexself()
 
-    def _reindex(self):
+    def _reindexself(self):
+        """
+        Reindex the Series
+        * Return None. Modify self._sr inplace.
+        :return:
+        """
         if self._CLS_DEFAULT_INDEX_TYPE == "s":
             self._sr.index = [get_column_letter(i + 1) for i in range(self.size)]
         elif self._CLS_DEFAULT_INDEX_TYPE == "i":
             self._sr.index = [i + 1 for i in range(self.size)]
 
+    def _reconstruct(self, other):
+        """
+        Reconstruct self
+        * Return None. Modify self._sr inplace.
+        :param other: inst of __class__. The other instance.
+        :return:
+        """
+        self._sr = other._sr.copy()
+        self._reindexself()
+
+    def _construct_new_from_index(self, new_index: Union[int, slice], *, inplace=False) -> '__class__() | None':
+        """
+        Construct a new __class__ from the new index
+        * Use this instead of directly create a new __class__ object. So you can override this method to add some other logic.
+        :param new_index: int|slice. The new index you want to index self
+        *
+        :param inplace: bool. If True, modify self inplace. If True, Return None.
+        :return: inst of __class__ | None
+        """
+        _new = self.__class__(self._sr.iloc[new_index], copy=False)
+        _new = self.on_subinstance(_new)
+        if inplace:
+            self._reconstruct(_new)
+        else:
+            return _new
+
+    def _construct_new_from_insert(self, insert_index: int, *values, inplace=False) -> '__class__() | None':
+        """
+        Construct a new __class__ from the new index
+        * Use this instead of directly create a new __class__ object. So you can override this method to add some other logic.
+        :param insert_index: int. The index to insert before.
+        :param *values: Any. The values to insert.
+        :param inplace:
+        :return: inst of __class__ | None
+        """
+        _construct = self._sr.to_list()
+        values = list(values)
+        _construct = _construct[:insert_index] + values + _construct[insert_index:]
+        _new = self.__class__(_construct, copy=False)
+        _new = self.on_insert(_new)
+        if inplace:
+            self._reconstruct(_new)
+        else:
+            return _new
+
+    def _construct_new_from_delete(self, delete_index: Union[int, slice], *, inplace=False) -> '__class__() | None':
+        """
+        Construct a new __class__ from the new index
+        * Use this instead of directly create a new __class__ object. So you can override this method to add some other logic.
+        :param delete_index: int|slice. The index to delete. Special case: slice(None) means clear all.
+        *
+        :param inplace: bool. If True, modify self inplace. If True, Return None.
+        :return: inst of __class__ | None
+        """
+        if delete_index == slice(None):
+            _new = self.__class__()
+        else:
+            _new = self.__class__(self._sr.drop(self._sr.index[delete_index]), copy=False)
+        _new = self.on_delete(_new)
+
+        if inplace:
+            self._reconstruct(_new)
+        else:
+            return _new
+
+    def _parse_slice(self, key: slice) -> Tuple[int, int, int]:
+        """
+        Parse the slice to get the start, stop and step
+        :param key: slice. The slice to parse.
+        :return: start, stop, step
+        """
+        _start = key.start if key.start is not None else 0
+        _stop = key.stop if key.stop is not None else self.size
+        _step = key.step if key.step is not None else 1
+        return _start, _stop, _step
+
     def __str__(self):
         txt = str(self._sr)
 
@@ -61,6 +229,9 @@ class _ExcelIndexsLike_1DArray:
 
         return txt
 
+    def __len__(self):
+        return self.size
+
     @property
     def size(self):
         return self._sr.shape[0]
@@ -80,10 +251,12 @@ class _ExcelIndexsLike_1DArray:
         :return: type, real_index
             * type:
                 ' ': 简单索引类型
+                'n': 全选类型
                 "s": 文本ABC索引类型
                 "i": 文本123索引类型
                 "t??": slice类型, ? 可以是 ' nis'中的一个
         """
+        skey = skey.upper()
         # NOTE: index_from_string will thorw warning if the type is not matched
         # 先考虑是否是slice
         if ':' in skey:
@@ -94,20 +267,22 @@ class _ExcelIndexsLike_1DArray:
             _t1 = 'i' if l1.isdigit() else 's'
 
             start, end = index_from_string(l0, should=self._CLS_DEFAULT_INDEX_TYPE, only_int=True), index_from_string(l1, should=self._CLS_DEFAULT_INDEX_TYPE, only_int=True)
-            return f"t{_t0}{_t1}", slice(start, end + 1)
+            return f"t{_t0}{_t1}", slice(start, end + 1) if start <= end else slice(end, start + 1)  # NOTE: 'A:C' with 'C:A' is the same
 
         if _PAT_COORD.match(skey):
             raise ValueError(f"Unexpected index: {skey}.")
         _type = 'i' if skey.isdigit() else 's'
         return _type, index_from_string(skey, should=self._CLS_DEFAULT_INDEX_TYPE, only_int=True) - 1
 
-    def __dim1_parse_index_key(self, key) -> Tuple[U[str, None], U[int, slice]]:
+    def _dim1_parse_index_key(self, key, *, err_when_slice=False) -> Tuple[U[str, None], U[int, slice]]:
         """
         Parse the key to get the type and index
         :param key:
+        :param err_when_slice: bool. If True, raise error when slice is found.
         :return:  type, index
             * type:
                 ' ': 简单索引类型
+                'n': 全选类型
                 "s": 文本ABC索引类型
                 "i": 文本123索引类型
                 "t??": slice类型, ? 可以是 ' nis'中的一个
@@ -121,53 +296,47 @@ class _ExcelIndexsLike_1DArray:
             # NOTE:交给专用于处理字符串索引的函数处理
             return self.__dim1_parse_str_index(key)
         elif isinstance(key, slice):
+            if err_when_slice:
+                raise ValueError(f"Unexpected slice index: {key}. (Because param err_when_slice=True).")
             _a, _b, _step = key.start, key.stop, key.step
+            _atype, _aindex, _btype, _bindex = 'n', None, 'n', None
             if _a is None and _b is None:
                 return "tnn", key
-            _atype, _aindex, _btype, _bindex, _any_flag = 'n', None, 'n', None, False
             if _a is not None:
-                _atype, _aindex = self.__dim1_parse_index_key(_a)
-                _any_flag = True
+                _atype, _aindex = self._dim1_parse_index_key(_a)
             if _b is not None:
-                _btype, _bindex = self.__dim1_parse_index_key(_b)
-                _any_flag = True
-            assert _atype[0] != 't' and _btype[0] != 't', f"Unexpected slice index: {key}"
-            assert not _any_flag or _atype == _btype, f"Unexpected index: '{key}'. Which is not in the same type."
+                _btype, _bindex = self._dim1_parse_index_key(_b)
+            if _atype != _btype:
+                raise ValueError(f"Unexpected index: '{key}'. Which is not in the same type.")
+
             return f"t{_atype}{_btype}", slice(_aindex, _bindex, _step)
         else:
             raise ValueError(f"Unsupported type: {type(key)}")
 
     def __getitem__(self, key):
-        """
-
-        :param key:
-            only unit types:
-                int -> value
-                alpha -> value
-                slice -> sub Series (new CLS)
-        :return:
-        """
-        _stype, _index = self.__dim1_parse_index_key(key)
+        _stype, _index = self._dim1_parse_index_key(key)
         if _stype == 'n':
-            return self
-        elif _stype[0] != 't':
+            return self.copy()  # None or ... Type
+        elif _stype[0] != 't':  # return single value directly
             return self._sr.iloc[_index]
         else:
-            return self.__class__(self._sr.iloc[_index], copy=False)
+            return self._construct_new_from_index(_index)  # slice Type
 
     def __setitem__(self, key, value):
-        _stype, _index = self.__dim1_parse_index_key(key)
+        _stype, _index = self._dim1_parse_index_key(key)
         if _stype == 'n':
-            _index = slice()
-        self._sr.iloc[_index] = value
+            _index = slice(None)
+        self._sr.iloc[_index] = value  # NOTE: Set value won't change the shape. So no need to construct new one.
 
     def __delitem__(self, key):
-        _stype, _index = self.__dim1_parse_index_key(key)
+        _stype, _index = self._dim1_parse_index_key(key)
         if _stype == 'n':
             self.clear()
         else:
-            self._sr.drop(self._sr.index[_index], inplace=True)
-            self._reindex()
+            self._construct_new_from_delete(_index, inplace=True)
+
+
+class ExcelIndexsLike_1DArray(_ExcelIndexsLike_1DArray_Base):
 
     def append(self, *values):
         """
@@ -175,33 +344,30 @@ class _ExcelIndexsLike_1DArray:
         :param values: Any. The values to append.
         :return: None
         """
-        self._sr = self._sr._append(pd.Series(values), ignore_index=True)
-        self._reindex()
+        self._construct_new_from_insert(self.size, *values, inplace=True)
 
-    def insert(self, index, *values):
+    def insert(self, index: Union[str, int], *values):
         """
         Insert values before the index
-        :param index: int|str. The index to insert before. (Can be a column-letter string)
+        :param index: int|str. The index to insert before. (Can be a column-letter string) But not support slice.
         :param values: Any. The values to insert.
         :return: None
         """
-        _stype, _index = self.__dim1_parse_index_key(index)
+        _stype, _index = self._dim1_parse_index_key(index)
         if _stype[0] == "t" or _stype == "n":
             raise ValueError(f"Here only accept non-slice index In {self.__class__.__name__}. But got {index}")
 
-        _construct_list = self._sr.iloc[:_index].to_list() + list(values) + self._sr.iloc[_index:].to_list()
-        self._sr = pd.Series(_construct_list)
-        self._reindex()
+        self._construct_new_from_insert(_index, *values, inplace=True)
 
-    def pop(self, index, n: int = 1):
+    def pop(self, index: Union[str, int], n: int = 1):
         """
         Remove and return the value at the index
-        :param index: int|str. The index to remove. (Can be a column-letter string)
+        :param index: int|str. The index to remove. (Can be a column-letter string) But not support slice.
         :param n: int. The number of values to remove.
             - if index + n > size, remove until the end.
         :return: Any. The removed value. (If n > 1, return a list of values)
         """
-        _stype, _index = self.__dim1_parse_index_key(index)
+        _stype, _index = self._dim1_parse_index_key(index)
         if _stype[0] == "t" or _stype == "n":
             raise ValueError(f"Here only accept non-slice index In {self.__class__.__name__}. But got {index}")
 
@@ -210,9 +376,7 @@ class _ExcelIndexsLike_1DArray:
             end = self.size
 
         _poped = self._sr.iloc[_index:end].to_list()
-        _construct_list = self._sr.iloc[:_index].to_list() + self._sr.iloc[end:].to_list()
-        self._sr = pd.Series(_construct_list)
-        self._reindex()
+        self._construct_new_from_delete(slice(_index, end), inplace=True)
         if n == 1:
             return _poped[0]
         return _poped
@@ -223,10 +387,7 @@ class _ExcelIndexsLike_1DArray:
         :param other: Series/List/NumpyArray/ExcelIndexed-1D
         :return: None
         """
-        if not isinstance(other, _ExcelIndexsLike_1DArray):
-            other = self.__class__(other)
-        self._sr = self._sr._append(other._sr, ignore_index=True)
-        self._reindex()
+        self._construct_new_from_insert(self.size, *other, inplace=True)
 
     def index(self, value):
         """
@@ -261,22 +422,21 @@ class _ExcelIndexsLike_1DArray:
         Reverse the Series in place.
         :return: None
         """
-        self._sr = self._sr.iloc[::-1]
-        self._reindex()
+        self._construct_new_from_index(slice(None, None, -1), inplace=True)
 
     def clear(self):
         """
         Clear the Series.
         :return: None
         """
-        self._sr = pd.Series()
+        self._construct_new_from_delete(slice(None), inplace=True)
 
     def copy(self):
         """
         Return a shallow copy of the Series.
         :return: Series. A shallow copy of the Series.
         """
-        return self.__class__(self._sr.copy(), copy=False)
+        return self.__class__(self._sr.copy(), copy=False)  # NOTE: copy won't change the shape. So no need to construct new one.
 
     def sort(self, key=None, reverse=False):
         """
@@ -287,8 +447,8 @@ class _ExcelIndexsLike_1DArray:
         """
         _construct_list = self._sr.to_list()
         _construct_list.sort(key=key, reverse=reverse)
-        self._sr = pd.Series(_construct_list)
-        self._reindex()
+        self._sr = pd.Series(_construct_list)  # NOTE: sort won't change the shape. So no need to construct new one.
+        self._reindexself()
 
     def __iter__(self):
         return iter(self._sr)
@@ -297,7 +457,7 @@ class _ExcelIndexsLike_1DArray:
         return value in self._sr
 
     def __eq__(self, other):
-        if not isinstance(other, _ExcelIndexsLike_1DArray):
+        if not isinstance(other, ExcelIndexsLike_1DArray):
             other = self.__class__(other)
         return self._sr.equals(other._sr)
 
@@ -316,14 +476,14 @@ class _ExcelIndexsLike_1DArray:
         return self.__class__(_construct_list)
 
 
-class Row(_ExcelIndexsLike_1DArray):  # Like 1: (A B C D)
+class Row(ExcelIndexsLike_1DArray):  # Like 1: (A B C D)
     _CLS_DEFAULT_INDEX_TYPE = "s"
 
     def __str__(self):
         return "Row Series:\n" + super().__str__() + "\n"
 
 
-class Col(_ExcelIndexsLike_1DArray):  # Like A: (1 2 3 4)
+class Col(ExcelIndexsLike_1DArray):  # Like A: (1 2 3 4)
     _CLS_DEFAULT_INDEX_TYPE = "i"
 
     def __str__(self):
@@ -362,7 +522,7 @@ class _ExcelIndexsLike_2DArray:
                         warnings.warn(
                             f"Table's input should be rows, but got a column. Regarded as a row.(at index:{i})"
                         )
-                    elif isinstance(_l, _ExcelIndexsLike_1DArray):
+                    elif isinstance(_l, ExcelIndexsLike_1DArray):
                         _construct_list.append(_l._sr.to_list())
                     elif isinstance(_l, list):
                         _construct_list.append(_l.copy())
@@ -431,10 +591,8 @@ class _ExcelIndexsLike_2DArray:
                 _cnd[lt.ir, lt.ic] = ':' + _cnd[lt.ir, lt.ic][1:]
             _unhandled_mask[lt.ir:rb.ir + 1, lt.ic:rb.ic + 1] = False
 
-
         return str(pd.DataFrame(_cnd, index=self._df.index, columns=self._df.columns, copy=False))
 
-
     def __repr__(self):
         c = Coord(self._df.shape[1] - 1, self._df.shape[0] - 1)
         return f"Table[:'{c.letter}']"
@@ -776,6 +934,12 @@ class _ExcelIndexsLike_2DArray:
         sr, sc = self._df.shape
         sr, sc = sr - 1, sc - 1
 
+        if isinstance(ir, slice):
+            ir = ir.stop if ir.stop is not None else sr
+
+        if isinstance(ic, slice):
+            ic = ic.stop if ic.stop is not None else sc
+
         if ir is None:
             ir = sr
         if ic is None:
@@ -787,9 +951,9 @@ class _ExcelIndexsLike_2DArray:
 
         # enlarge the table
         _2d_list = self._df.values.tolist()
-        if ir >= sr:
+        if ir > sr:
             _2d_list += [[fill] * sc for _ in range(ir - sr)]
-        if ic >= sc:
+        if ic > sc:
             for _l in _2d_list:
                 _l.extend([fill] * (ic - sc))
         self._reconstruct(_2d_list, *self._other_raws, copy=False)
@@ -842,7 +1006,7 @@ class _ExcelIndexsLike_2DArray:
                 _i0 = slice(None)
             elif _is_i1_slice and _i1.start is None and _i1.stop is None:
                 _i1 = None
-            else:  # 单个元素赋值
+            else:  # 元素赋值
                 self._enlarge(_i0, _i1, fill=np.nan)
                 self._df.iloc[_i0, _i1] = value
 
@@ -940,7 +1104,6 @@ class _ExcelIndexsLike_2DArray:
             else:
                 self._df.iloc[_i0, _i1] = np.nan
 
-
     def append(self, *values, axis=0):
         """
         Append Rows to the end of the table
@@ -1002,9 +1165,9 @@ class _ExcelIndexsLike_2DArray:
 
         # 先考虑扩张
         if _r < _new_r:
-            self.append([[fill.copy() if _has_fill_copy else fill] * _c for _ in range(_new_r - _r)], axis=0)
+            self.append(*[[fill.copy() if _has_fill_copy else fill] * _c for _ in range(_new_r - _r)], axis=0)
         if _c < _new_c:
-            self.append([fill.copy() if _has_fill_copy else fill for _ in range(_new_c - _c)], axis=1)
+            self.append(*[fill.copy() if _has_fill_copy else fill for _ in range(_new_c - _c)], axis=1)
 
         # 再考虑缩小 NOTE: 缩小不必考虑label的问题
         if _r > _new_r:
@@ -1012,7 +1175,6 @@ class _ExcelIndexsLike_2DArray:
         if _c > _new_c:
             self._reconstruct(self._df.iloc[:, :_new_c], *self._other_raws, copy=False)
 
-
     def __iter__(self):
         for _r in self._df.values.tolist():
             yield _r
@@ -1033,6 +1195,8 @@ class _ExcelIndexsLike_2DArray:
             return not self._df.equals(other._df)
         return np.array(self._df) != other
 
+    def __len__(self):
+        return self.shape[0]
 
 
 class StyleRow(Row):
@@ -1046,6 +1210,7 @@ class StyleRow(Row):
         for ic in range(self.shape[0]):
             self._sr.iloc[ic][key] = value
 
+
 class StyleCol(Col):
     def set(self, key, value):
         """
@@ -1057,9 +1222,11 @@ class StyleCol(Col):
         for ir in range(self.shape[0]):
             self._sr.iloc[ir][key] = value
 
+
 class StyleTable(_ExcelIndexsLike_2DArray):
     _ROW_CLS = StyleRow
     _COL_CLS = StyleCol
+
     def set(self, key, value):
         """
         Set the style of each cell
@@ -1071,11 +1238,12 @@ class StyleTable(_ExcelIndexsLike_2DArray):
             for ic in range(self.shape[1]):
                 self._df.iloc[ir, ic][key] = value
 
+
 class Table(_ExcelIndexsLike_2DArray):
     # def __init__(self, _from=None, *, copy: bool = True):
-    def __init__(self, data=None, styles=None, merges:list=None, *, copy: bool = True):
+    def __init__(self, data=None, styles=None, merges: list = None, *, copy: bool = True):
         super().__init__(data, copy=copy)
-        self._styles = StyleTable() if styles is None else StyleTable(styles)
+        self._styles = StyleTable() if styles is None else (styles.copy() if isinstance(styles, StyleTable) else StyleTable(styles))
         self._merges = []
 
         self.__raw_merges = merges
@@ -1101,7 +1269,7 @@ class Table(_ExcelIndexsLike_2DArray):
     def merges(self):
         return self._merges
 
-    def merge(self, key:U[int, str, slice, None], key1:U[int, str, slice, None]=EMPTY_INDEX):
+    def merge(self, key: U[int, str, slice, None], key1: U[int, str, slice, None] = EMPTY_INDEX, *, border: Border = None):
         if key1 is not EMPTY_INDEX:
             key = key, key1
 
@@ -1139,6 +1307,9 @@ class Table(_ExcelIndexsLike_2DArray):
 
         self._merges.append((lt, rb))
 
+        if border is not None:
+            self._styles[key].set(TYPE_BORDER, border)
+
     def _reconstruct(self, *args, **kwargs):
         """
         用于缩小或扩大表格时自动同步调整styles
@@ -1251,6 +1422,7 @@ class Table(_ExcelIndexsLike_2DArray):
 
 
 def __1d_test(_print=True):
+
     d = [1, 2, 3, 4, 5]
 
     r = Row(d)
@@ -1281,6 +1453,16 @@ def __1d_test(_print=True):
     if _print: print(f"删除测试：\n{r}")
 
 
+def _1d_unit_test(_print=True):
+    tc = TimeRecorder()
+    __1d_test(_print)
+    warnings.filterwarnings('ignore')
+    for i in range(999):
+        __1d_test(_print)
+    warnings.filterwarnings('default')
+    print(f"测试结束，耗时: {tc.dms(1000)} ms / 测试")
+
+
 def __2d_test(_print=True):
     import colorama
     r0 = Col([1, 2, 3, 4, 5])
@@ -1352,4 +1534,4 @@ if __name__ == '__main__':
     # print(f"Finish Test. Cost:{round((time.time() - _a) * 1000, 2)} ms")
     # exit(0)
 
-    __2d_test()
+    _1d_unit_test(False)

{tpltable-0.3.2 → tpltable-0.3.4}/tpltable.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tpltable
-Version: 0.3.2
+Version: 0.3.4
 Summary: define "Excel" "Table|StyleTable" "Row|Col|StyleRow|StyleCol". Can dynamic modify excel data & styles. Support multiple kinds of indexes. (70%)
 Author-email: 2229066748@qq.com
 Maintainer: Eagle'sBaby

tpltable-0.3.2/tpltable/core.py

@@ -1 +0,0 @@
-from tpltable.basic import *