byzh-core 0.0.1__py3-none-any.whl

byzh_core/Barchive/__init__.py

@@ -0,0 +1,3 @@
+from .archive import b_archive_zip
+
+__all__ = ['b_archive_zip']

byzh_core/Barchive/archive.py

@@ -0,0 +1,67 @@
+import os
+import zipfile
+
+def b_archive_zip(
+    source_path,
+    output_path,
+    exclude_dirs:list[str]=None,
+    exclude_files:list[str]=None,
+    exclude_exts:list[str]=None,
+    while_list:list[str]=None,
+    contain_empty_folder:bool=True,
+):
+    '''
+    压缩文件夹，排除 指定文件夹and指定后缀文件
+    :param source_path:
+    :param output_path:
+    :param exclude_dirs: ['__pycache__', '.git', '.idea']
+    :param exclude_files: ['.gitignore', 'README.md']
+    :param exclude_exts: ['.csv', '.npy', '.pt', '.pth']
+    :return:
+    '''
+    if exclude_dirs is None:
+        exclude_dirs = []
+    if exclude_files is None:
+        exclude_files = []
+    if exclude_exts is None:
+        exclude_exts = []
+    if while_list is None:
+        while_list = []
+
+    with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        # 压缩文件:
+        if os.path.isfile(source_path):
+            arcname = os.path.basename(source_path)
+            zipf.write(source_path, arcname)
+            return
+
+        # 压缩文件夹:
+        if os.path.isdir(source_path):
+            for root, dirs, files in os.walk(source_path):
+                # 排除指定文件夹dirs
+                dirs[:] = [d for d in dirs if d in while_list or d not in exclude_dirs]
+                # 排除指定文件files
+                files = [f for f in files if f in while_list or f not in exclude_files]
+                # 排除指定后缀文件files
+                files = [f for f in files if f in while_list or not any(f.endswith(ext) for ext in exclude_exts)]
+
+
+                # 压缩文件:
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, source_path) # 相对于source_path的相对路径
+                    zipf.write(file_path, arcname)
+
+                # 若是空文件夹，则压缩文件夹:
+                if contain_empty_folder and (len(dirs) == 0 and len(files) == 0):
+                    arcname = os.path.relpath(root, source_path)
+                    folder_path = root
+                    zipf.write(folder_path, arcname)
+
+if __name__ == '__main__':
+    b_archive_zip(
+        source_path=r'E:\byzh_workingplace\byzh-rc-to-pypi\awa',
+        output_path=r'E:\byzh_workingplace\byzh-rc-to-pypi\awaqwq.zip',
+        exclude_dirs=['__pycache__', 'com'],
+        exclude_exts=['.ppt']
+    )

byzh_core/Bbasic/__init__.py

@@ -0,0 +1,3 @@
+from .text_style import B_Color, B_Appearance, B_Background
+
+__all__ = ['B_Color', 'B_Appearance', 'B_Background']

byzh_core/Bbasic/text_style.py

@@ -0,0 +1,76 @@
+# 字体颜色
+class B_Color:
+    RESET = "\033[0m"
+
+    BLACK = "\033[30m"      # 黑
+    RED = "\033[31m"        # 红
+    GREEN = "\033[32m"      # 绿
+    YELLOW = "\033[33m"     # 黄
+    BLUE = "\033[34m"       # 蓝
+    PURPLE = "\033[35m"     # 紫/粉
+    CYAN = "\033[36m"       # 青/蓝绿
+    SILVER = "\033[37m"      # 灰/银
+
+# 背景颜色
+class B_Background:
+    RESET = "\033[0m"
+
+    BLACK = "\033[40m"      # 黑
+    RED = "\033[41m"        # 红
+    GREEN = "\033[42m"      # 绿
+    YELLOW = "\033[43m"     # 黄
+    BLUE = "\033[44m"       # 蓝
+    PURPLE = "\033[45m"     # 紫/粉
+    CYAN = "\033[46m"       # 青/蓝绿
+    SILVER = "\033[47m"      # 灰/银
+
+# 效果
+class B_Appearance:
+    RESET = "\033[0m"
+
+    HIGHLIGHT = "\033[1m"  # 高亮
+    LOWLIGHT = "\033[2m"   # 低亮
+    UNDERLINE = "\033[4m"  # 下划线
+    REVERSE = "\033[7m"    # 反显(白底黑字)
+
+
+if __name__ == '__main__':
+    print("以下是测试文字：")
+
+    print("\033[0m默认文字\033[0m")
+    print("\033[1m高亮文字\033[0m")
+    print("\033[2m低亮文字\033[0m")
+    # print("\033[3m无效文字\033[0m")
+    print("\033[4m下划线文字\033[0m")
+    print("\033[5m闪烁文字(无效)\033[0m")
+    # print("\033[6m无效文字\033[0m")
+    print("\033[7m反显文字\033[0m")
+    print("\033[8m消隐文字(无效)\033[0m")
+
+    print("\n\033[31;1m字体颜色\033[0m测试文字")
+    print("\033[30m低亮黑色文字\033[0m\t\033[30;1m高亮黑色文字\033[0m")
+    print("\033[31m低亮红色文字\033[0m\t\033[31;1m高亮红色文字\033[0m")
+    print("\033[32m低亮绿色文字\033[0m\t\033[32;1m高亮绿色文字\033[0m")
+    print("\033[33m低亮黄色文字\033[0m\t\033[33;1m高亮黄色文字\033[0m")
+    print("\033[34m低亮蓝色文字\033[0m\t\033[34;1m高亮蓝色文字\033[0m")
+    print("\033[35m低亮紫色文字\033[0m\t\033[35;1m高亮紫色文字\033[0m")
+    print("\033[36m低亮青色文字\033[0m\t\033[36;1m高亮青色文字\033[0m")
+    print("\033[37m低亮灰色文字\033[0m\t\033[37;1m高亮灰色文字\033[0m")
+    # print("\033[38m测试文字\033[0m")
+    # print("\033[39m测试文字\033[0m")
+
+    print("\n\033[31;1m背景颜色\033[0m测试文字")
+    print("\033[40m低亮文字黑色背景\033[0m\t\033[40;1m高亮文字黑色背景\033[0m")
+    print("\033[41m低亮文字红色背景\033[0m\t\033[41;1m高亮文字红色背景\033[0m")
+    print("\033[42m低亮文字绿色背景\033[0m\t\033[42;1m高亮文字绿色背景\033[0m")
+    print("\033[43m低亮文字黄色背景\033[0m\t\033[43;1m高亮文字黄色背景\033[0m")
+    print("\033[44m低亮文字蓝色背景\033[0m\t\033[44;1m高亮文字蓝色背景\033[0m")
+    print("\033[45m低亮文字紫色背景\033[0m\t\033[45;1m高亮文字紫色背景\033[0m")
+    print("\033[46m低亮文字青色背景\033[0m\t\033[46;1m高亮文字青色背景\033[0m")
+    print("\033[47m低亮文字灰色背景\033[0m\t\033[47;1m高亮文字灰色背景\033[0m")
+    # print("\033[48m测试文字\033[0m")
+    # print("\033[49m测试文字\033[0m")
+
+
+
+

byzh_core/Bconfig/__init__.py

@@ -0,0 +1,3 @@
+from .config import B_Config
+
+__all__ = ['B_Config']

byzh_core/Bconfig/config.py

@@ -0,0 +1,328 @@
+from ..Bbasic import B_Color
+
+
+class B_Config:
+    def __init__(self):
+        super().__init__()
+        self.group_lst = []
+        self.dict_lst = []
+
+    # set-方法
+    def set(self, group, key, value):
+        '''
+        添加元素
+        '''
+        if not isinstance(group, str):
+            raise Exception(f"{B_Color.YELLOW}group({str(group)}) must be str{B_Color.RESET}")
+        if not isinstance(key, str):
+            raise Exception(f"{B_Color.YELLOW}key({str(key)}) must be str{B_Color.RESET}")
+
+        if group not in self.group_lst:
+            self.group_lst.append(group)
+            self.dict_lst.append(dict())
+
+        index = self._get_index(group)
+        self.dict_lst[index][key] = value
+
+    def set_copygroup(self, dst_group, src_group):
+        '''
+        通过复制group来快速添加组
+        '''
+        if not isinstance(dst_group, str):
+            raise Exception(f"{B_Color.YELLOW}group({str(dst_group)}) must be str{B_Color.RESET}")
+        if not isinstance(src_group, str):
+            raise Exception(f"{B_Color.YELLOW}group({str(src_group)}) must be str{B_Color.RESET}")
+        if dst_group in self.group_lst:
+            raise Exception(f"{B_Color.YELLOW}group({str(dst_group)}) already exist{B_Color.RESET}")
+
+        import copy
+        self.group_lst.append(dst_group)
+        self.dict_lst.append(copy.deepcopy(self.dict_lst[self._get_index(src_group)]))
+
+    def set_dictgroup(self, group, dict):
+        '''
+        通过dict来快速添加组
+        '''
+        if group in self.group_lst:
+            raise Exception(f"{B_Color.YELLOW}group({str(group)}) already exist{B_Color.RESET}")
+        self.group_lst.append(group)
+        # 把dict的键值对都化为字符串
+        self.dict_lst.append({str(key): str(value) for key, value in dict.items()})
+
+    # show-方法
+    def show_all(self):
+        '''
+        打印config
+        '''
+        print(f"group_cnt({len(self.group_lst)}) | {self.group_lst} \ndict_cnt:{len(self.dict_lst)}")
+        print()
+        for group, dict in zip(self.group_lst, self.dict_lst):
+            print(f"{group}:\n\t{dict}")
+
+    def show_group(self, group):
+        '''
+        打印某个group
+        '''
+        result = self._get_group_str(group)
+        print(group + ":\n" + result)
+
+    # get-方法
+    def get_str(self, group, key):
+        '''
+        获取某个group的某个key的值
+        '''
+        self._check(group, key)
+        index = self._get_index(group)
+        return str(self.dict_lst[index][key])
+
+    def get_int(self, group, key):
+        '''
+        获取某个group的某个key的值
+        '''
+        self._check(group, key)
+        index = self._get_index(group)
+        return int(self.dict_lst[index][key])
+
+    def get_float(self, group, key):
+        '''
+        获取某个group的某个key的值
+        '''
+        self._check(group, key)
+        index = self._get_index(group)
+        return float(self.dict_lst[index][key])
+
+    def get_bool(self, group, key):
+        '''
+        获取某个group的某个key的值\n
+        只有value为["False", "0", "None"]时，返回False
+        '''
+        self._check(group, key)
+
+        if self.get_str(group, key) in ["False", "0", "None"]:
+            return False
+        elif self.get_str(group, key) in ["True", "1"]:
+            return True
+        else:
+            raise Exception(f"{B_Color.YELLOW}value({str(key)}) cannot change to bool{B_Color.RESET}")
+
+    # save-方法
+    def to_pickle(self, path):
+        '''
+        保存为pickle文件(最稳定的方式)
+        '''
+        import pickle
+        with open(path, 'wb') as f:
+            pickle.dump([self.group_lst, self.dict_lst], f)
+
+    def from_pickle(self, path):
+        '''
+        从pickle文件中读取
+        '''
+        import pickle
+        with open(path, 'rb') as f:
+            [self.group_lst, self.dict_lst] = pickle.load(f)
+
+    def to_json(self, path):
+        '''
+        保存为json文件
+        '''
+        import json
+        with open(path, 'w') as f:
+            for group, group_dict in zip(self.group_lst, self.dict_lst):
+                entry = {"group": group, "dict": group_dict}
+                json.dump(entry, f)
+                f.write("\n")
+
+    def from_json(self, path):
+        '''
+        从json文件中读取
+        '''
+        import json
+        with open(path, 'r') as f:
+            self.group_lst = []
+            self.dict_lst = []
+            for line in f:
+                entry = json.loads(line.strip())
+                self.group_lst.append(entry["group"])
+                self.dict_lst.append(entry["dict"])
+
+    def to_yaml(self, path):
+        '''
+        保存为yaml文件
+        '''
+        import yaml
+        with open(path, 'w') as f:
+            yaml.dump([self.group_lst, self.dict_lst], f)
+
+    def from_yaml(self, path):
+        '''
+        从yaml文件中读取
+        '''
+        import yaml
+        with open(path, 'r') as f:
+            [self.group_lst, self.dict_lst] = yaml.load(f, Loader=yaml.FullLoader)
+
+    def to_ini(self, path):
+        '''
+        保存为ini文件
+        '''
+        with open(path, 'w') as f:
+            for group, dict in zip(self.group_lst, self.dict_lst):
+                f.write(f"[{group}]\n")
+                for key, value in dict.items():
+                    f.write(f"{key} = {value}\n")
+                f.write("\n")
+
+    def from_ini(self, path):
+        '''
+        从ini文件中读取
+        '''
+        self.group_lst = []
+        self.dict_lst = []
+        with open(path, 'r') as f:
+            lines = f.readlines()
+            dictionary = dict()
+            for line in lines:
+                line = line.strip()
+                if line.startswith('[') and line.endswith(']'):
+                    # 如果字典非空不是dict()
+                    if dictionary != dict():
+                        self.dict_lst.append(dictionary.copy())
+                        dictionary.clear()
+                    group = line[1:-1]
+                    self.group_lst.append(group)
+                elif line == '':
+                    continue
+                else:
+                    if '=' in line:
+                        key, value = line.split('=', 1)
+                        # key和value去除前后空格
+                        key = key.strip()
+                        value = value.strip()
+                        dictionary[key] = value
+                    else:
+                        dictionary[line] = ''
+            if dictionary != dict():
+                self.dict_lst.append(dictionary.copy())
+
+    def to_csv(self, path):
+        '''
+        保存为csv文件
+        '''
+        import csv
+        with open(path, 'w', newline='') as f:
+            writer = csv.writer(f)
+
+            # Write header: the first row is group names
+            header = ['key'] + self.group_lst
+            writer.writerow(header)
+
+            # Find all unique keys across all groups
+            all_keys = set()
+            for group_dict in self.dict_lst:
+                all_keys.update(group_dict.keys())
+
+            # Write rows for each key
+            for key in all_keys:
+                row = [key]
+                for group_dict in self.dict_lst:
+                    row.append(group_dict.get(key, ''))  # Add value or empty if key is not present
+                writer.writerow(row)
+
+    def from_csv(self, path):
+        '''
+        从csv文件中读取
+        '''
+        import csv
+        with open(path, 'r') as f:
+            reader = csv.reader(f)
+
+            # Read header: the first row is group names
+            header = next(reader)
+            group_lst = header[1:]  # The first column is 'key', rest are groups
+            self.group_lst = group_lst
+            self.dict_lst = [{} for _ in range(len(group_lst))]  # Initialize dicts for each group
+
+            # Read the key-value pairs
+            for row in reader:
+                key = row[0]
+                for i, value in enumerate(row[1:], start=0):
+                    if value:  # Only add value if it's not empty
+                        self.dict_lst[i][key] = value
+
+    def to_table(self, path):
+        from ..Btable import B_AutoTable
+        my_table = B_AutoTable()
+        for index, group in enumerate(self.group_lst):
+            for key, value in self.dict_lst[index].items():
+                my_table[group][key] = value
+
+        my_table.to_txt(path)
+
+    # 工具-方法
+    def __str__(self):
+        result = ""
+        for group in self.group_lst:
+            result += group + ":\n"
+            result += self._get_group_str(group) + "\n"
+        # 去掉最后一个\n
+        result = result[:-1]
+        return result
+    def __getitem__(self, item):
+        return self.dict_lst[item]
+
+    def __setitem__(self, key, value):
+        self.set_dictgroup(key, value)
+
+    def _get_index(self, group):
+        return self.group_lst.index(group)
+
+    def _get_group_str(self, group):
+        self._check(group)
+        index = self._get_index(group)
+        result = "\n".join([f"\t({key} -> {value})" for key, value in self.dict_lst[index].items()])
+        return result
+
+    def _check(self, group, key=None):
+        # 检查group是否是字符串
+        if not isinstance(group, str):
+            raise Exception(f"{B_Color.YELLOW}group({str(group)}) must be str{B_Color.RESET}")
+        # 检查group是否在group_list中
+        if group not in self.group_lst:
+            raise Exception(f"{B_Color.YELLOW}group({str(group)}) not found{B_Color.RESET}")
+
+        if key is not None:
+            # 检查key是否是字符串
+            if not isinstance(key, str):
+                raise Exception(f"{B_Color.YELLOW}key({str(key)}) must be str{B_Color.RESET}")
+            # 检查key是否在dict中
+            index = self._get_index(group)
+            if key not in self.dict_lst[index]:
+                raise Exception(f"{B_Color.YELLOW}key({str(key)}) not found{B_Color.RESET}")
+
+
+if __name__ == '__main__':
+    a = B_Config()
+
+    a.set('awa', 'a', 'None')
+    a.set('awa', 'b', '123')
+    a.set('awa', '345', '33333')
+
+    a.set('awa', 'a532', 'No32ne')
+    a.set('awa', 'b13', '123412')
+    a.set('awa', '321345', '33342333')
+
+    a.set_copygroup('default', 'qwq')
+    a.set('qwq', '345', 'aaaaaa')
+
+    a.to_csv('config.csv')
+    a.from_csv('config.csv')
+    # a.to_yaml('config.yaml')
+    # a.from_yaml('config.yaml')
+    # a.to_pickle('config.pkl')
+    # a.from_pickle('config.pkl')
+    # a.to_json('config.json')
+    # a.from_json('config.json')
+
+    print(a.get_str('awa', 'b13'))
+    print(a)

byzh_core/Bmath/__init__.py

@@ -0,0 +1,4 @@
+from .divides import b_divides
+from .get_norm import b_get_norm
+
+__all__ = ['b_divides', 'b_get_norm']

byzh_core/Bmath/divides.py

@@ -0,0 +1,41 @@
+from typing import Union, List, Set, Tuple
+
+my_type1 = Union[int, float, str]
+def get_num(num: my_type1):
+    if isinstance(num, str):
+        return float(num)
+    return num
+
+my_type2 = Union[my_type1, List[my_type1], Set[my_type1], Tuple[my_type1]]
+def b_divides(iterUp: my_type2, iterDown: my_type2):
+    """
+    支持list, tuple, set, 单个数\n
+    iterUp as 分子\n
+    iterDown as 分母
+    """
+    up = 1
+    down = 1
+
+    if not isinstance(iterUp, list) and not isinstance(iterUp, tuple) and not isinstance(iterUp, set):
+        up *= get_num(iterUp)
+    else:
+        for x in iterUp:
+            up *= get_num(x)
+
+    if not isinstance(iterDown, list) and not isinstance(iterDown, tuple) and not isinstance(iterDown, set):
+        down *= get_num(iterDown)
+    else:
+        for x in iterDown:
+            down *= get_num(x)
+
+    return up / down
+
+if __name__ == '__main__':
+    result = b_divides([1, 2, 3], [4, 5])
+    print(result)
+
+    result = b_divides(6.63e-34, (9.11e-31, 3e8))
+    print(result)
+
+    result = b_divides('6.63e-34', ['9.11e-31', 3e8])
+    print(result)

byzh_core/Bmath/get_norm.py

@@ -0,0 +1,21 @@
+from typing import Literal
+def b_get_norm(
+    lst: list,
+    mode: Literal['min-max'] = 'min-max',
+    ndigits: int | None = None
+) -> tuple[list, float, float]:
+
+    if mode =='min-max':
+        minimum = min(lst)
+        maximum = max(lst)
+        if ndigits is None:
+            result = [(x-minimum)/(maximum-minimum) for x in lst]
+        else:
+            result = [round((x-minimum)/(maximum-minimum), ndigits) for x in lst]
+        return (result, minimum, maximum)
+
+
+if __name__ == '__main__':
+    lst = [1, 2, 3, 4, 5]
+    result = b_get_norm(lst)
+    print(result)

byzh_core/Btable/__init__.py

@@ -0,0 +1,6 @@
+from .row_table import B_RowTable
+from .xy_table import B_XYTable
+from .auto_table import B_AutoTable
+
+
+__all__ = ['B_RowTable', 'B_XYTable', 'B_AutoTable']