tpltable 0.3.3__tar.gz → 0.3.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tpltable
-Version: 0.3.3
+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.3 → tpltable-0.3.4}/setup.py

@@ -5,7 +5,7 @@ from setuptools import find_packages, setup
 
 setup(
     name='tpltable',
-    version='0.3.3',
+    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.3 → tpltable-0.3.4}/tpltable/basic.py

@@ -73,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
@@ -143,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)
@@ -154,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.3 → tpltable-0.3.4}/tpltable/table.py

@@ -7,10 +7,96 @@ from tpltable.core import *
 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,65 +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()
-        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):
+        if 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)
+                _from = np.array(_from)
             except Exception as e:
                 raise ValueError(f"Failed to convert list to 1D array. {e}")
-        else:
-            raise ValueError(f"Unsupported type: {type(_from)}")
-
-        self._reindex()
 
-    @staticmethod
-    def _retype_to_unitcell(_from):
-        if isinstance(_from, pd.Series):
-            if len(_from) and not isinstance(_from.iloc[0]):
-                ...
-            self._sr = _from
-            if copy:
-                self._sr = self._sr.copy()
+        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})")
-            if _from.shape[0] != 0:
-                ...
-
-        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}")
+            self._sr = pd.Series(_from)
+        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)}")
 
-    def _reindex(self):
+        self._reindexself()
+
+    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)
 
@@ -111,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:
@@ -125,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'中的一个
@@ -152,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):
         """
@@ -206,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}")
 
@@ -241,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
@@ -254,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):
         """
@@ -292,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):
         """
@@ -318,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)
@@ -328,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)
 
@@ -347,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):
@@ -393,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())
@@ -462,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}']"
@@ -813,7 +940,6 @@ class _ExcelIndexsLike_2DArray:
         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:
@@ -978,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
@@ -995,7 +1120,6 @@ class _ExcelIndexsLike_2DArray:
                 row.extend(values)
         self._reconstruct(_construct, *self._other_raws, copy=False)
 
-
     def clear(self):
         """
         Clear the table
@@ -1051,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
@@ -1076,7 +1199,6 @@ class _ExcelIndexsLike_2DArray:
         return self.shape[0]
 
 
-
 class StyleRow(Row):
     def set(self, key, value):
         """
@@ -1088,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):
         """
@@ -1099,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
@@ -1113,9 +1238,10 @@ 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 (styles.copy() if isinstance(styles, StyleTable) else StyleTable(styles))
         self._merges = []
@@ -1143,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, *, border:Border=None):
+    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
 
@@ -1296,6 +1422,7 @@ class Table(_ExcelIndexsLike_2DArray):
 
 
 def __1d_test(_print=True):
+
     d = [1, 2, 3, 4, 5]
 
     r = Row(d)
@@ -1326,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])
@@ -1397,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.3 → tpltable-0.3.4}/tpltable.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tpltable
-Version: 0.3.3
+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