byzh-core 0.0.2.3__tar.gz → 0.0.2.4__tar.gz

{byzh_core-0.0.2.3 → byzh_core-0.0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: byzh_core
-Version: 0.0.2.3
+Version: 0.0.2.4
 Summary: byzh_core是byzh系列的核心库，包含了一些常用的工具函数和类。
 Author: byzh_rc
 License: MIT

{byzh_core-0.0.2.3 → byzh_core-0.0.2.4}/byzh_core/B_os.py

@@ -58,3 +58,29 @@ def rm(path):
     if os.path.isfile(path):
         os.remove(path)
 
+def get_dirpaths_in_dir(root_dir_path, unwanted_dirname=['__pycache__']):
+    result = []
+    for root, dirs, files in os.walk(root_dir_path):
+        path = Path(root)
+        if path.name in unwanted_dirname:
+            continue
+        result.append(path)
+
+    result = result[1:]
+
+    return result
+
+def get_filepaths_in_dir(root_dir_path, unwanted_name=[], unwanted_suffix=['.pyc']):
+    file_paths = []
+    for root, dirs, files in os.walk(root_dir_path):
+        for file in files:
+            file_path = os.path.join(root, file)
+            file_path = Path(file_path)
+            if file_path.name in unwanted_name or file_path.suffix in unwanted_suffix:
+                continue
+            file_paths.append(file_path)
+    return file_paths
+
+if __name__ == '__main__':
+    print(get_dirpaths_in_dir(r'E:\byzh_workingplace\byzh-rc-to-pypi\uploadToPypi_core\byzh_core'))
+    print(get_filepaths_in_dir(r'E:\byzh_workingplace\byzh-rc-to-pypi\uploadToPypi_core\byzh_core'))

byzh_core-0.0.2.4/byzh_core/Btable/__init__.py

@@ -0,0 +1,4 @@
+from .auto_table import B_Table2d
+
+
+__all__ = ['B_Table2d']

byzh_core-0.0.2.4/byzh_core/Btable/auto_table.py

@@ -0,0 +1,398 @@
+import copy
+import math
+import os
+from pathlib import Path
+from typing import List, Tuple, Union
+Seq = Union[List, Tuple]
+try:
+    from wcwidth import wcswidth
+except ImportError:
+    raise ImportError("[table] 请先安装wcwidth库: pip install wcwidth")
+
+def get_width(string):
+    return wcswidth(string)
+
+def get_maxwidth_2d(matrix):
+    widths = [0 for _ in range(len(matrix[0]))]
+    for row in matrix:
+        for i, element in enumerate(row):
+            if element is None:
+                element = ' '
+            widths[i] = max(widths[i], get_width(element))
+
+    diff_matrix = [[0 for _ in range(len(matrix[0]))] for _ in range(len(matrix))]
+    for i in range(len(matrix)):
+        for j in range(len(matrix[0])):
+            element = matrix[i][j]
+            if element is None:
+                element = ' '
+            diff_matrix[i][j] = widths[j] - get_width(element)
+
+    return widths, diff_matrix
+
+def get_T_matrix(matrix):
+    new_matrix = [[matrix[j][i] for j in range(len(matrix))] for i in range(len(matrix[0]))]
+    return new_matrix
+
+def strs2matrix(str_lst):
+    str_lst = [x.strip() for x in str_lst if len(x.strip()) > 0]
+    str_lst.pop(-1)
+    str_lst.pop(2)
+    dividing_line = str_lst.pop(0)
+    indexes = [i for i, c in enumerate(dividing_line) if c == '+']
+    row_cnt = len(str_lst)
+    col_cnt = len(indexes) - 1
+
+
+    matrix = []
+    for i in range(row_cnt):
+        row = []
+        for j in range(col_cnt):
+            start = indexes[j] + 1
+            end = indexes[j+1]
+            row.append(str_lst[i][start:end].strip())
+        matrix.append(row)
+
+    row_name, col_name = matrix[0][0].split(' \\ ')
+
+    return matrix, row_name, col_name
+
+
+class Matrix2d:
+    def __init__(self, row_name='x', col_name='y'):
+        self.row_name = row_name
+        self.col_name = col_name
+        self.matrix = [[row_name + ' | ' + col_name]]
+
+    def get_rows(self): # 包含left_upper
+        if self.matrix == [[]]:
+            return []
+        return [x[0] for x in self.matrix]
+    def get_cols(self): # 包含left_upper
+        return self.matrix[0]
+    def set_by_str(self, row, col, value):
+        row, col, value = str(row), str(col), str(value)
+
+        rows = self.get_rows()
+        cols = self.get_cols()
+
+        if row in rows:
+            row_index = rows.index(row)
+        else:
+            row_index = len(rows)
+        if col in cols:
+            col_index = cols.index(col)
+        else:
+            col_index = len(cols)
+
+        self.set_by_index(row_index, col_index, row, col, value)
+
+    def set_by_index(self, row_index, col_index, row, col, value):
+        row, col, value = str(row), str(col), str(value)
+
+        rows = self.get_rows()
+        cols = self.get_cols()
+
+        if row_index < len(rows):
+            pass
+        elif row_index == len(rows):
+            self.matrix.append([row] + [None] * (len(cols) - 1))
+
+        if col_index < len(cols):
+            pass
+        elif col_index == len(cols):
+            self.matrix[0].append(col)
+            for i in range(1, len(self.matrix)):
+                self.matrix[i].append(None)
+
+        self.matrix[row_index][col_index] = value
+
+    def get_by_str(self, row, col):
+        row, col = str(row), str(col)
+
+        rows = self.get_rows()
+        cols = self.get_cols()
+        if row in rows and col in cols:
+            row_index = rows.index(row)
+            col_index = cols.index(col)
+            return self.get_by_index(row_index, col_index)
+        else:
+            raise ValueError(f"row {row} or col {col} not found in table")
+
+    def get_by_index(self, row_index, col_index):
+        rows = self.get_rows()
+        cols = self.get_cols()
+        if row_index < len(rows) and col_index < len(cols):
+            return self.matrix[row_index][col_index]
+        else:
+            raise ValueError(f"row_index {row_index} or col_index {col_index} out of range")
+
+    def T(self):
+        new_matrix = get_T_matrix(self.matrix)
+        new_left_upper = self.col_name + ' \\ ' + self.row_name
+        new_matrix[0][0] = new_left_upper
+
+        self.row_name, self.col_name = self.col_name, self.row_name
+
+        self.matrix = new_matrix
+
+        return self
+    def __str__(self):
+        result = ''
+        for x in self.matrix:
+            result += str(x) + '\n'
+        return result
+
+
+class Dict1d:
+    def __init__(self, dictionary=None):
+        self.dict = {}
+        if dictionary:
+            for key, value in dictionary.items():
+                self[key] = value
+
+    def __getitem__(self, key):
+        key = str(key)
+        return self.dict[key]
+    def __setitem__(self, key, value): # 用于最底层赋值
+        key, value = str(key), str(value)
+        self.dict[key] = value
+    def set(self, key, value): # 用于非底层赋值（防止把子dict变为str）
+        key = str(key)
+        self.dict[key] = value
+
+
+    def keys(self):
+        return self.dict.keys()
+
+    def values(self):
+        return self.dict.values()
+
+    def items(self):
+        return self.dict.items()
+
+    def copy(self):
+        return copy.deepcopy(self)
+
+    def __str__(self):
+        return str(self.dict)
+
+    def __repr__(self):
+        return str(self.dict)
+
+class Dict2d:
+    def __init__(self):
+        self.dict = Dict1d()
+
+    # 先实现setitem，再实现getitem
+    def __getitem__(self, key):
+        key = str(key)
+        if key not in self.dict.keys():
+            self[key] = Dict1d()
+        return self.dict[key]
+    def __setitem__(self, key, new_dict: Dict1d | dict):
+        key = str(key)
+        self.dict.set(key, Dict1d(new_dict))
+    def __str__(self):
+        return str(self.dict)
+
+class B_Table2d:
+    def __init__(self, row_name='x', col_name='y', auto_adaptive=False, narrow_better=True):
+        '''
+
+        :param row_name:
+        :param col_name:
+        :param auto_adaptive: 是否采取自动翻转的策略，来提升显示效果
+        :param narrow_better: 在auto_adaptive=True的情况下，是否优先选择横向窄的表格，避免换行显示
+        '''
+        self.row_name = row_name
+        self.col_name = col_name
+        self.auto_adaptive = auto_adaptive
+        self.narrow_better = narrow_better
+
+        self.matrix2d = Matrix2d(row_name, col_name) # 用于输出
+        self.dict2d = Dict2d() # 用于输入
+
+        # 判断是否改变
+        self.is_changed = False
+
+    def __getitem__(self, row):
+        self.is_changed = True
+
+        row = str(row)
+        return self.dict2d[row]
+
+    def __setitem__(self, row, new_dict):
+        self.is_changed = True
+
+        row = str(row)
+        self.dict2d[row] = new_dict
+
+    def from_txt(self, txt_path, use_txt_name:bool=False):
+        '''
+
+        :param txt_path:
+        :param use_txt_name: 默认使用init时的row_name和col_name
+        :return:
+        '''
+        with open(txt_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        matrix, row_name, col_name = strs2matrix(lines)
+        if {self.row_name, self.col_name} != {row_name, col_name}:
+            raise ValueError(f"行头列头正反均不对应，请检查: [{self.row_name}, {self.col_name}] ❌ [{row_name}, {col_name}]")
+
+        if use_txt_name:
+            self.row_name = row_name
+            self.col_name = col_name
+            self.matrix2d = Matrix2d(self.row_name, self.col_name)
+            self.matrix2d.matrix = matrix
+        else:
+            left_upper = self.row_name + ' \\ ' + self.col_name
+            matrix[0][0] = left_upper
+            if self.row_name == row_name and self.col_name == col_name:
+                self.matrix2d = Matrix2d(self.row_name, self.col_name)
+                self.matrix2d.matrix = matrix
+            elif self.row_name == col_name and self.col_name == row_name:
+                self.matrix2d = Matrix2d(self.col_name, self.row_name)
+                self.matrix2d.matrix = get_T_matrix(matrix)
+
+        self.__matrix2dict()
+
+    def to_txt(self, txt_path):
+        with open(txt_path, 'w', encoding='utf-8') as f:
+            f.write(str(self))
+
+    def to_strs(self):
+        if self.is_changed:
+            self.__dict2matrix()
+        if self.__if_need_T():
+            self.T()
+
+        result = []
+
+        # 计算宽度
+        widths, diff_matrix = get_maxwidth_2d(self.matrix2d.matrix)
+
+        for i in range(len(self.matrix2d.matrix)):
+            elements = []
+            for j in range(len(self.matrix2d.matrix[i])):
+                element = self.matrix2d.matrix[i][j]
+                if element is None:
+                    element = ' '
+                diff = diff_matrix[i][j]
+                diff_left = diff // 2
+                diff_right = diff - diff_left
+                element = ' '*diff_left + str(element) + ' '*diff_right
+                elements.append(element)
+            row = ' | '.join(elements)
+            row = '| ' + row + ' |'
+            result.append(row)
+
+        # 添加三行分隔线
+        dividing_line = '+' + '+'.join(['-' * (widths[i] + 2) for i in range(len(widths))]) + '+'
+        result.append(dividing_line)
+        result.insert(1, dividing_line)
+        result.insert(0, dividing_line)
+
+        return result
+
+    def to_str(self):
+        return '\n'.join(self.to_strs())
+
+    def __str__(self):
+        return self.to_str()
+
+    def __repr__(self):
+        if self.is_changed:
+            self.__dict2matrix()
+
+        result = ''
+        for x in self.matrix2d.matrix:
+            result += str(x) + '\n'
+        return result
+
+    def T(self):
+        if self.is_changed:
+            self.__dict2matrix()
+        self.matrix2d.T()
+        self.row_name, self.col_name = self.col_name, self.row_name
+        self.__matrix2dict()
+
+        return self
+
+    def __matrix2dict(self): # __
+        keys1 = self.matrix2d.get_rows()[1:]
+        keys2 = self.matrix2d.get_cols()[1:]
+        self.dict2d = Dict2d()
+        for i, key1 in enumerate(keys1):
+            for j, key2 in enumerate(keys2):
+                value = self.matrix2d.get_by_index(i+1, j+1)
+                self.dict2d[key1][key2] = value
+
+        self.is_changed = False
+
+    def __dict2matrix(self): # __
+        left_upper = self.row_name + ' \\ ' + self.col_name
+        # 处理keys1和keys2
+        keys1 = [left_upper] + list(self.dict2d.dict.keys())
+        keys2 = [left_upper]
+
+        temp = []
+        for key1 in self.dict2d.dict.keys():
+            for key2 in self.dict2d.dict[key1].keys():
+                if key2 not in temp:
+                    temp.append(key2)
+
+        keys2.extend(temp)
+
+        # 处理matrix框架
+        matrix = [keys2]
+        for x in keys1[1:]:
+            matrix.append([x] + [None] * (len(keys2) - 1))
+
+        # 构建matrix2d
+        self.matrix2d = Matrix2d(self.row_name, self.col_name)
+        self.matrix2d.matrix = matrix
+        for row in self.dict2d.dict.keys():
+            for col in self.dict2d.dict[row].keys():
+                value = self.dict2d.dict[row][col]
+                self.matrix2d.set_by_str(row, col, value)
+
+        self.is_changed = False
+    def __if_need_T(self):
+        '''
+        尽管T，但只是出来的str是T过的，并没有改变原来的矩阵，
+        所以赋值还是原来的字符索引
+        :return:
+        '''
+        if not self.auto_adaptive:
+            return False
+
+        now_matrix2d = self.matrix2d
+        T_matrix2d = copy.deepcopy(now_matrix2d).T()
+
+        now_widths, _ = get_maxwidth_2d(now_matrix2d.matrix)
+        T_widths, _ = get_maxwidth_2d(T_matrix2d.matrix)
+
+        now_width = sum(now_widths)
+        T_width = sum(T_widths)
+
+        if T_width < now_width and self.narrow_better:
+            return True
+        elif T_width > now_width and not self.narrow_better:
+            return True
+        else:
+            return False
+
+
+if __name__ == '__main__':
+    a = B_Table2d(row_name='data', col_name='score', auto_adaptive=False)
+    # a[0][1] = 'a3'
+    # a[11][22] = '123'
+    # a[11][1] = 'dawd'
+    a.from_txt('./a.txt')
+    print(a)
+    # a.T()
+    # print(a)
+
+

{byzh_core-0.0.2.3 → byzh_core-0.0.2.4}/byzh_core/__init__.py

@@ -2,4 +2,4 @@
 # class      以"B_"开头
 # function   以"b_"开头
 
-__version__ = '0.0.2.3'
+__version__ = '0.0.2.4'

{byzh_core-0.0.2.3 → byzh_core-0.0.2.4}/byzh_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: byzh_core
-Version: 0.0.2.3
+Version: 0.0.2.4
 Summary: byzh_core是byzh系列的核心库，包含了一些常用的工具函数和类。
 Author: byzh_rc
 License: MIT

{byzh_core-0.0.2.3 → byzh_core-0.0.2.4}/byzh_core.egg-info/SOURCES.txt

@@ -23,10 +23,10 @@ byzh_core/Bos/make.py
 byzh_core/Bos/remove.py
 byzh_core/Btable/__init__.py
 byzh_core/Btable/auto_table.py
-byzh_core/Btable/row_table.py
-byzh_core/Btable/xy_table.py
 byzh_core/Btable/obsolete/__init__.py
-byzh_core/Btable/obsolete/b_auto_table.py
+byzh_core/Btable/obsolete/auto_table.py
+byzh_core/Btable/obsolete/row_table.py
+byzh_core/Btable/obsolete/xy_table.py
 byzh_core/Bterminal/__init__.py
 byzh_core/Bterminal/cmd.py
 byzh_core/Btqdm/__init__.py

byzh_core-0.0.2.3/byzh_core/Btable/obsolete/b_auto_table.py

@@ -1,321 +0,0 @@
-import copy
-import math
-import os
-from pathlib import Path
-from typing import List, Tuple, Union
-Seq = Union[List, Tuple]
-try:
-    from wcwidth import wcswidth
-except ImportError:
-    raise ImportError("[table] 请先安装wcwidth库: pip install wcwidth")
-
-class MyDict:
-    def __init__(self, init_dict = None):
-        self.dict = dict()
-        if type(init_dict) is dict:
-            self.dict = init_dict.copy()
-        if type(init_dict) is MyDict:
-            self.dict = init_dict.dict.copy()
-
-
-    def update(self, other_dict):
-        self.dict.update(other_dict)
-
-    def items(self):
-        return self.dict.items()
-    def keys(self):
-        return self.dict.keys()
-    def values(self):
-        return self.dict.values()
-    def copy(self):
-        return MyDict(self.dict.copy())
-    def __getitem__(self, item):
-        return self.dict[str(item)]
-
-    def __setitem__(self, key, value):
-        key, value = str(key), str(value)
-
-        if key not in self.dict.keys():
-            self.dict.update({key: ''})
-
-        self.dict[key] = value
-
-class BAutoTable:
-    def __init__(self, x_name='x', y_name='y'):
-        self.x_sidebars = []
-        self.y_sidebars = []
-        self.x_name = x_name
-        self.y_name = y_name
-        self.dict = dict()
-        self._widths = dict()
-
-    def set(self, x_sidebar, y_sidebar, content):
-        x_sidebar, y_sidebar, content = str(x_sidebar), str(y_sidebar), str(content)
-        self[x_sidebar][y_sidebar] = str(content)
-
-    def get_str(self, x_sidebar, y_sidebar):
-        return self[x_sidebar][y_sidebar]
-    def get_int(self, x_sidebar, y_sidebar):
-        return int(self[x_sidebar][y_sidebar])
-    def get_float(self, x_sidebar, y_sidebar):
-        return float(self[x_sidebar][y_sidebar])
-    def get_bool(self, x_sidebar, y_sidebar):
-        temp = self[x_sidebar][y_sidebar]
-        if temp == "True" or temp == "1":
-            return True
-        else:
-            return False
-    def items(self):
-        '''
-        (key1, key2, value)
-        '''
-        result = [(x, y, self.dict[x][y]) for x in self.x_sidebars for y in self.y_sidebars]
-        return result
-    def copy_row(self, old_row:str, new_row:str):
-        old_row, new_row = str(old_row), str(new_row)
-        self[new_row] = self[old_row]
-    def read_txt(self, path):
-        with open(path, 'r') as f:
-            lines = f.readlines()
-            lines = [x.strip() for x in lines if x.startswith('|')]
-
-        temp = []
-        for string in lines:
-            elements = string.split('|')[1:-1]
-            elements = [x.strip() for x in elements]
-            temp.append(elements)
-
-        x_name, y_name = temp[0][0].split(' \\ ') if ('\\' in temp[0][0]) else ("x", "y")
-        x_keys = [var[0] for var in temp[1:]]
-        y_keys = temp[0][1:]
-
-        self.x_sidebars = []
-        self.y_sidebars = []
-        self.x_name = x_name
-        self.y_name = y_name
-        self.dict = dict()
-        self._widths = dict()
-
-        for i, x_element in enumerate(x_keys):
-            y_dict = MyDict()
-            for j, y_element in enumerate(y_keys):
-                y_dict.update({y_element: temp[i+1][j+1]})
-            self.dict.update({x_element: y_dict})
-        self._update_sidebars()
-
-    def to_txt(self, path):
-        '''
-        将表格内容写入文件
-        :param path:
-        :return:
-        '''
-        dir = Path(path).resolve().parent
-        os.makedirs(dir, exist_ok=True)
-        with open(path, 'w') as f:
-            f.write(self.get_table_by_str())
-
-    def update_txt(self, path):
-        '''
-        更新表格内容\n
-        如果文件不存在，则创建文件
-        :param path:
-        :return:
-        '''
-        # 是否存在该文件
-        if not os.path.exists(path):
-            self.to_txt(path)
-        else:
-            new_dict = self.dict
-            self.read_txt(path)
-            origin_dict = self.dict
-            self.dict = self._merge_2d_dicts(origin_dict, new_dict)
-            self._update_sidebars()
-
-            self.to_txt(path)
-
-
-
-    def get_table_by_strs(self) -> List[str]:
-        results = self._create_prefix()
-
-        self._update_widths()
-
-        str_dash = ''
-        str_head = ''
-        for y in self.y_sidebars:
-            pre_space, suf_space = self._get_prefix_suffix(y, self._widths[y], ' ')
-            pre_dash, suf_dash = self._get_prefix_suffix('-', self._widths[y], '-')
-            str_head += ' ' + pre_space + y + suf_space + ' |'
-            str_dash += '-' + pre_dash + '-' + suf_dash + '-+'
-        results[0] += str_dash
-        results[1] += str_head
-        results[2] += str_dash
-
-        offset = 3
-        for index, y_dicts in enumerate(self.dict.values()):
-            for key in self.y_sidebars:
-                value = y_dicts[key] if key in y_dicts.keys() else ''
-                pre_space, suf_space = self._get_prefix_suffix(value, self._widths[key], ' ')
-                str_content = ' ' + pre_space + value + suf_space + ' |'
-                results[index+offset] += str_content
-
-        results[-1] += str_dash
-
-        return results
-
-    def get_table_by_str(self) -> str:
-        result = ""
-        strs = self.get_table_by_strs()
-        for x in strs[:-1]:
-            result += x + '\n'
-        result += strs[-1]
-
-        return result
-    def print_table(self):
-        print(self.get_table_by_str())
-
-    def _merge_2d_dicts(self, origin_dict, new_dict):
-        """
-        合并两个二维字典。
-        如果两个字典的相同键存在重叠的子键，则 new_dict 的值覆盖 origin_dict。
-        """
-        merged_dict = {key: value.copy() for key, value in origin_dict.items()}  # 复制 origin_dict 避免修改原数据
-        for key, sub_dict in new_dict.items():
-            if key in merged_dict.keys():
-                merged_dict[key].update(sub_dict)  # 合并子字典
-            else:
-                merged_dict[key] = sub_dict  # 直接添加新键
-
-        return merged_dict
-    def _update_sidebars(self):
-        self.x_sidebars = list(self.dict.keys())
-
-        temp = []
-        for dict_y in self.dict.values():
-            for key in dict_y.keys():
-                if key not in temp:
-                    temp.append(key)
-        self.y_sidebars = temp
-
-    def _create_prefix(self):
-        '''
-        得到
-        +-------+
-        | x \ y |
-        +-------+
-        |   1   |
-        |   2   |
-        |   3   |
-        +-------+
-        '''
-        results = []
-
-        title = self.x_name + " \ " + self.y_name
-        self._update_sidebars()
-        n = self._get_maxlength_from_list(self.x_sidebars)
-        length = max(n, self._get_width(title))
-
-        pre_dash, suf_dash = self._get_prefix_suffix("-", length, '-')
-        str_dash = "+-" + pre_dash + "-" + suf_dash + "-+"
-        results.append(str_dash)
-
-        pre_space, suf_space = self._get_prefix_suffix(title, length, ' ')
-        str_index = "| " + pre_space + title + suf_space + " |"
-        results.append(str_index)
-        results.append(str_dash)
-
-        for x in self.x_sidebars:
-            pre_space, suf_space = self._get_prefix_suffix(x, length, ' ')
-            str_number = "| " + pre_space + x + suf_space + " |"
-            results.append(str_number)
-        results.append(str_dash)
-
-        return results
-
-    def _get_prefix_suffix(self, string, length, charactor=' '):
-        prefix = ''
-        suffix = ''
-        str_len = self._get_width(string)
-
-        delta = length - str_len
-        if delta < 0:
-            assert "string的宽度比length宽"
-        elif delta == 0:
-            pass
-        else:
-            prefix = charactor * math.floor(delta / 2)
-            suffix = charactor * math.ceil(delta / 2)
-
-        return prefix, suffix
-
-    def _get_maxlength_from_list(self, lst: List[str]) -> int:
-        temp = [self._get_width(x) for x in lst]
-        if len(temp) == 0:
-            return 0
-        else:
-            return max(temp)
-
-    def _update_widths(self):
-        temp = {key: self._get_width(key) for key in self.y_sidebars}
-
-        # for dict_y in self.dict.values():
-        #     for key, value in dict_y.items():
-        #         width = self._get_width(value)
-        #         if width > temp[key]:
-        #             temp[key] = width
-
-        matrix = self._get_width_matrix()
-        for i in range(len(matrix)):
-            for j in range(len(matrix[0])):
-                if matrix[i][j] > temp[self.y_sidebars[j]]:
-                    temp[self.y_sidebars[j]] = matrix[i][j]
-
-        self._widths = temp
-    def _get_width_matrix(self):
-        results = [[0 for _ in self.y_sidebars] for _ in self.x_sidebars]
-        for x, dict_y in self.dict.items():
-            for y, value in dict_y.items():
-                results[self.x_sidebars.index(x)][self.y_sidebars.index(y)] = self._get_width(value)
-        return results
-
-    def __repr__(self):
-        print(self._widths)
-    def _get_width(self, string):
-        return wcswidth(string)
-
-    def __len__(self):
-        return len(self.x_sidebars) * len(self.y_sidebars)
-    def __contains__(self, item):
-        for x in self.x_sidebars:
-            for y in self.y_sidebars:
-                if str(item) == self.dict[x][y]:
-                    return True
-        return False
-    def __str__(self):
-        return self.get_table_by_str()
-
-    def __getitem__(self, index):
-        index = str(index)
-
-        if index not in self.dict.keys():
-            self.dict.update({index: MyDict()})
-            self._update_sidebars()
-            return self.dict[index]
-
-        return self.dict[index]
-    def __setitem__(self, index, value:MyDict|dict):
-        index, value = str(index), MyDict(value)
-        self.dict.update({index: value})
-
-if __name__ == '__main__':
-    my_table = BAutoTable("x", "y")
-
-    my_table[1][3] = 123
-    my_table[2][2] = 123
-    my_table["awa"]["12133"] = 123
-    my_table.copy_row('awa', 'qwq')
-    my_table['qwq'][12133] = 333
-
-    # my_table.read_txt(r'E:\byzh_workingplace\byzh-rc-to-pypi\awa.txt')
-    print(my_table)
-    repr(my_table)