kevin-toolbox-dev 1.0.2__tar.gz → 1.0.11__tar.gz

kevin-toolbox-dev-1.0.11/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.0.11
+Summary: 一个常用的工具代码包集合
+Home-page: https://github.com/cantbeblank96/kevin_toolbox
+Download-URL: https://github.com/username/your-package/archive/refs/tags/v1.0.0.tar.gz
+Author: kevin hsu
+Author-email: xukaiming1996@163.com
+License: MIT
+Keywords: mathematics,pytorch,numpy,machine-learning,algorithm
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Provides-Extra: plot
+Provides-Extra: rest
+
+# kevin_toolbox
+
+一个通用的工具代码包集合
+
+
+
+环境要求
+
+```shell
+numpy>=1.19
+pytorch>=1.2
+```
+
+安装方法：
+
+```shell
+pip install kevin-toolbox  --no-dependencies
+```
+
+
+
+[项目地址 Repo](https://github.com/cantbeblank96/kevin_toolbox)
+
+[使用指南 User_Guide](./notes/User_Guide.md)
+
+[免责声明 Disclaimer](./notes/Disclaimer.md)
+
+[版本更新记录](./notes/Release_Record.md)：
+
+- v 1.0.11（2023-6-11）
+  - kevin_toolbox.data_flow.file
+    - 让 kevin_notation 中的 column_dict 方式支持单行写入
+  - 将原来 computer_science.algorithm.utils 下的 for_dict 和 for_seq 移动到 computer_science.algorithm 下。
+  - computer_science.algorithm.for_nested_dict_list
+    - 将原来 utils 下面向 嵌套字典列表 类型数据的算法移动至到 utils.for_nested_dict_list 下，包括：get_hash()、get_value_by_name()、set_value_by_name()、traverse()
+    - 改进 set_value_by_name()，增加强制赋值模式，相应参数为 b_force
+    - 改进 traverse() 增加了 b_use_name_as_idx 参数以控制传入 match_cond/converter 中 idx 参数的类型（传入整体的 name 还是父节点的 index 或 key）
+    - add count_leaf_node_nums()，用于获取嵌套字典列表 var 中所有叶节点的数量。
+    - add get_leaf_nodes()，用于获取嵌套字典列表 var 中所有叶节点。该函数基于新版的 traverse()  来实现。
+    - 添加了单元测试
+
+
+

kevin-toolbox-dev-1.0.11/README.md

@@ -0,0 +1,43 @@
+# kevin_toolbox
+
+一个通用的工具代码包集合
+
+
+
+环境要求
+
+```shell
+numpy>=1.19
+pytorch>=1.2
+```
+
+安装方法：
+
+```shell
+pip install kevin-toolbox  --no-dependencies
+```
+
+
+
+[项目地址 Repo](https://github.com/cantbeblank96/kevin_toolbox)
+
+[使用指南 User_Guide](./notes/User_Guide.md)
+
+[免责声明 Disclaimer](./notes/Disclaimer.md)
+
+[版本更新记录](./notes/Release_Record.md)：
+
+- v 1.0.11（2023-6-11）
+  - kevin_toolbox.data_flow.file
+    - 让 kevin_notation 中的 column_dict 方式支持单行写入
+  - 将原来 computer_science.algorithm.utils 下的 for_dict 和 for_seq 移动到 computer_science.algorithm 下。
+  - computer_science.algorithm.for_nested_dict_list
+    - 将原来 utils 下面向 嵌套字典列表 类型数据的算法移动至到 utils.for_nested_dict_list 下，包括：get_hash()、get_value_by_name()、set_value_by_name()、traverse()
+    - 改进 set_value_by_name()，增加强制赋值模式，相应参数为 b_force
+    - 改进 traverse() 增加了 b_use_name_as_idx 参数以控制传入 match_cond/converter 中 idx 参数的类型（传入整体的 name 还是父节点的 index 或 key）
+    - add count_leaf_node_nums()，用于获取嵌套字典列表 var 中所有叶节点的数量。
+    - add get_leaf_nodes()，用于获取嵌套字典列表 var 中所有叶节点。该函数基于新版的 traverse()  来实现。
+    - 添加了单元测试
+
+
+

{kevin-toolbox-dev-1.0.2 → kevin-toolbox-dev-1.0.11}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.0.2"
+__version__ = "1.0.11"
 
 
 import os
@@ -12,5 +12,5 @@ os.system(
 os.system(
     f'python {os.path.split(__file__)[0]}/env_info/check_validity_and_uninstall.py '
     f'--package_name kevin-toolbox-dev '
-    f'--expiration_timestamp 1696683467 --verbose 0'
+    f'--expiration_timestamp 1702102643 --verbose 0'
 )

{kevin-toolbox-dev-1.0.2 → kevin-toolbox-dev-1.0.11}/kevin_toolbox/computer_science/algorithm/combinatorial_optimization/test/test_get_subset_with_largest_product.py

@@ -2,7 +2,7 @@ import pytest
 import numpy as np
 from kevin_toolbox.patches.for_test import check_consistency
 from kevin_toolbox.computer_science.algorithm.combinatorial_optimization import get_subset_with_largest_product
-from kevin_toolbox.computer_science.algorithm.utils.for_seq import get_subsets
+from kevin_toolbox.computer_science.algorithm.for_seq import get_subsets
 
 
 def test_get_subset_with_largest_product():

{kevin-toolbox-dev-1.0.2 → kevin-toolbox-dev-1.0.11}/kevin_toolbox/computer_science/algorithm/combinatorial_optimization/test/test_zero_one_knapsack_problem.py

@@ -2,7 +2,7 @@ import pytest
 import numpy as np
 from kevin_toolbox.patches.for_test import check_consistency
 from kevin_toolbox.computer_science.algorithm.combinatorial_optimization import zero_one_knapsack_problem
-from kevin_toolbox.computer_science.algorithm.utils.for_seq import get_subsets
+from kevin_toolbox.computer_science.algorithm.for_seq import get_subsets
 
 
 def test_zero_one_knapsack_problem():

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/__init__.py

@@ -0,0 +1,6 @@
+from .get_hash import get_hash
+from .traverse import traverse
+from .get_value_by_name import get_value_by_name
+from .set_value_by_name import set_value_by_name
+from .count_leaf_node_nums import count_leaf_node_nums
+from .get_leaf_nodes import get_leaf_nodes

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/count_leaf_node_nums.py

@@ -0,0 +1,21 @@
+from kevin_toolbox.computer_science.algorithm.for_nested_dict_list import traverse
+
+
+def count_leaf_node_nums(var):
+    """
+        获取嵌套字典列表 var 中所有叶节点的数量
+
+        参数：
+            var:                待处理数据
+                                    当 var 不是 dict 或者 list 时，直接将 var 视为根节点，叶节点数量视为 0
+    """
+    nums = 0
+
+    def count(_, __, v):
+        nonlocal nums
+        if not isinstance(v, (list, dict,)):
+            nums += 1
+        return False
+
+    traverse(var=var, match_cond=count, action_mode="skip", b_use_name_as_idx=False)
+    return nums

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/get_hash.py

@@ -0,0 +1,38 @@
+import hashlib
+import json
+import warnings
+
+
+def get_hash(item, length=None, mode="md5"):
+    """
+        将输入 item 序列化，再计算出 hash 值
+            本函数对于无序的字典能够提供唯一的 hash 值
+
+        参数:
+            item:
+            length:         <int> 返回 hash 字符串的前多少位
+                                默认为 None，返回所有结果
+            mode:           <str> 支持 hashlib 中提供的 hash 方法
+                                当设置为 None 时候表示不使用 hash 处理而直接返回序列化后的字符串
+    """
+    assert mode is None or mode in hashlib.__all__
+
+    try:
+        hash_ = json.dumps(item, sort_keys=True).encode('utf-8')
+    except:
+        warnings.warn(
+            f"the item {type(item)} unable to be serialized by json, reproducibility is no longer guaranteed!",
+            UserWarning
+        )
+        hash_ = f"{item}".encode('utf-8')
+    if mode is not None:
+        worker = eval(f'hashlib.{mode}()')
+        worker.update(hash_)
+        hash_ = worker.hexdigest()
+    hash_ = hash_ if length is None else hash_[:length]
+    return hash_
+
+
+if __name__ == '__main__':
+    print(get_hash(item={2, 4}, mode="sha512"))
+    print(get_hash(item=[2, 4], mode="sha512"))

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/get_leaf_nodes.py

@@ -0,0 +1,22 @@
+from kevin_toolbox.computer_science.algorithm.for_nested_dict_list import traverse
+
+
+def get_leaf_nodes(var):
+    """
+        获取嵌套字典列表 var 中所有叶节点
+            以列表 [(name,value), ...] 形式返回，其中名字 name 的解释方式参考 get_value_by_name() 介绍
+
+        参数：
+            var:                待处理数据
+                                    当 var 不是 dict 或者 list 时，返回空列表
+    """
+    res = []
+
+    def func(_, idx, v):
+        nonlocal res
+        if not isinstance(v, (list, dict,)):
+            res.append((idx, v))
+        return False
+
+    traverse(var=var, match_cond=func, action_mode="skip", b_use_name_as_idx=True)
+    return res

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/get_value_by_name.py

@@ -0,0 +1,44 @@
+import re
+
+
+def get_value_by_name(var, name):
+    """
+        通过解释名字得到取值方式，然后到 var 中获取对应部分的值。
+
+        参数：
+            var:            任意支持索引取值的变量
+            name:           <string> 取值方式。
+                                由多组 "<解释方式><键>" 组成。
+                                解释方式支持以下几种:
+                                    "@"     使用 eval() 读取键
+                                    ":"     使用 str() 读取键
+                                    "|"     依次尝试 str() 和 eval() 两种方式
+                                示例:
+                                    "@100"      表示读取 var[eval("100")]
+                                    ":epoch"    表示读取 var["epoch"]
+                                    "|1+1"    表示首先尝试读取 var["1+1"]，若不成功则尝试读取 var[eval("1+1")]
+                                假设 var=dict(acc=[0.66,0.78,0.99])，如果你想读取 var["acc"][1] => 0.78，那么可以将 name 写成：
+                                    ":acc@1" 或者 "|acc|1" 等。
+                                注意，在 name 的开头也可以添加任意非解释方式的字符，本函数将直接忽略它们，比如下面的:
+                                    "var:acc@1" 和 "xxxx|acc|1" 也能正常读取。
+    """
+    assert isinstance(name, (str,))
+
+    key_ls = re.split('[:@|]', name)
+    # assert len(key_ls) > 0
+    flag_idx = len(key_ls[0])
+    for key in key_ls[1:]:
+        flag = name[flag_idx]
+        flag_idx += len(key) + 1
+        #
+        if flag == "@":
+            var = var[eval(key)]
+        elif flag == "|":
+            try:
+                var = var[key]
+            except:
+                var = var[eval(key)]
+        else:  # ":"
+            var = var[key]
+
+    return var

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/set_value_by_name.py

@@ -0,0 +1,55 @@
+from kevin_toolbox.computer_science.algorithm.for_nested_dict_list import get_value_by_name
+
+
+def set_value_by_name(var, name, value, b_force=False):
+    """
+        通过解释名字得到取值方式，然后到 var 中将对应部分的值修改为 value。
+
+        参数：
+            var:            任意支持索引赋值的变量
+            name:           <string> 取值方式
+                                由多组 "<解释方式><键>" 组成。
+                                解释方式支持以下几种:
+                                    "@"     使用 eval() 读取键
+                                    ":"     使用 str() 读取键
+                                    "|"     依次尝试 str() 和 eval() 两种方式
+                                示例:
+                                    "@100"      表示指向 var[eval("100")]
+                                    ":epoch"    表示指向 var["epoch"]
+                                    "|1+1"    表示首先尝试指向 var["1+1"]，若不成功则尝试指向 var[eval("1+1")]
+                                假设 var=dict(acc=[0.66,0.78,0.99])，如果你想将 var["acc"][1] 设置为 100，那么可以将 name 写成：
+                                    ":acc@1" 或者 "|acc|1" 等。
+                                注意，在 name 的开头也可以添加任意非解释方式的字符，本函数将直接忽略它们，比如下面的:
+                                    "var:acc@1" 和 "xxxx|acc|1" 也能正常写入。
+            value:          待赋给的值
+            b_force:        <boolean> 当无法设置时，是否尝试创建或者修改节点
+                                默认为 False，
+                                当设置为 True，可能会对 var 的结构产生不可逆的改变，请谨慎使用。新创建或者修改的节点的类型是 dict。
+    """
+    assert isinstance(name, (str,))
+    key = name
+    for char in ":@|":
+        key = key.rsplit(char, 1)[-1]
+    assert len(key) < len(name), f'invalid name: {name}'
+
+    try:
+        item = get_value_by_name(var=var, name=name[:-1 - len(key)])
+
+        flag = name[-1 - len(key)]
+        key_t = key
+        if flag == "@":
+            key_t = eval(key)
+        elif flag == "|":
+            try:
+                _ = item[key]
+            except:
+                key_t = eval(key)
+
+        item[key_t] = value
+    except:
+        if not b_force:
+            raise ValueError(f'The location pointed to by name {name} does not exist in var')
+        else:
+            var = set_value_by_name(var=var, name=name[:-1 - len(key)], value={key: value}, b_force=b_force)
+
+    return var

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/traverse.py

@@ -0,0 +1,56 @@
+def traverse(var, match_cond, action_mode="remove", converter=None, b_use_name_as_idx=False):
+    """
+        遍历 var 找到符合 match_cond 的元素，将其按照 action_mode 指定的操作进行处理
+
+        参数：
+            var:                待处理数据
+                                    当 var 不是 dict 或者 list 时，将直接返回 var 而不做处理
+            match_cond:         <func> 元素的匹配条件
+                                    函数类型为 def(parent_type, idx, value): xxxx
+                                    其中：
+                                        parent_type     该元素源自哪种结构体，有两个可能传入的值： list，dict
+                                        idx             该元素在结构体中的位置
+                                                            当 b_use_name_as_idx=False 时，
+                                                                对于列表是 index，对于字典是 key
+                                                            当为 True 时，传入的是元素在整体结构中的 name 位置，name的格式和含义参考
+                                                                get_value_by_name() 中的介绍
+                                        value           元素的值
+            action_mode:        <str> 如何对匹配上的元素进行处理
+                                    目前支持：
+                                        "remove"        将该元素移除
+                                        "replace"       将该元素替换为 converter() 处理后的结果
+                                        "skip":          不进行任何操作
+            converter:          <func> 参见 action_mode 中的 "replace" 模式
+                                    函数类型为 def(idx, value): xxxx
+                                    其中 idx 和 value 的含义参见参数 match_cond 介绍
+            b_use_name_as_idx     <boolean> 对于 match_cond/converter 中的 idx 参数，是传入整体的 name 还是父节点的 index 或 key。
+                                    默认为 False
+    """
+    assert callable(match_cond)
+    assert action_mode in {"replace", "remove", "skip"}
+    if action_mode == "replace":
+        assert callable(converter)
+
+    return recursive_(var, match_cond, action_mode, converter, b_use_name_as_idx, "")
+
+
+def recursive_(var, match_cond, action_mode, converter, b_use_name_as_idx, pre_name):
+    if isinstance(var, (list, dict)):
+        items = reversed(list(enumerate(var))) if isinstance(var, list) else list(var.items())
+        for k, v in items:
+            if b_use_name_as_idx:
+                idx = f'{pre_name}@{k}' if isinstance(var, list) else f'{pre_name}:{k}'
+            else:
+                idx = k
+            if match_cond(type(var), idx, v):
+                if action_mode == "remove":
+                    var.pop(k)
+                elif action_mode == "replace":
+                    var[k] = converter(idx, v)
+                else:
+                    pass
+            else:
+                var[k] = recursive_(v, match_cond, action_mode, converter, b_use_name_as_idx, idx)
+    else:
+        pass
+    return var

{kevin-toolbox-dev-1.0.2/kevin_toolbox/computer_science/algorithm/utils → kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm}/for_seq/flatten_list.py

@@ -22,7 +22,7 @@ def _recursion(ls, depth):
         res = []
         for i in ls:
             if isinstance(i, (list, tuple,)):
-                res.extend(_recursion(i, depth=depth - 1))
+                res.extend(_recursion(i, depth=depth if depth is None else depth - 1))
             else:
                 res.append(i)
     return res
@@ -30,4 +30,4 @@ def _recursion(ls, depth):
 
 if __name__ == '__main__':
     a = [[1, 2, (3, 4)], [(5,)], 6]
-    print(flatten_list(ls=a, depth=5))
+    print(flatten_list(ls=a, depth=None))

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/locks/__init__.py

@@ -0,0 +1 @@
+from .mutex_lock import Mutex_Lock

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/locks/mutex_lock.py

@@ -0,0 +1,74 @@
+import fcntl
+import os
+import time
+from kevin_toolbox.patches import for_os
+
+
+class Mutex_Lock:
+    """
+        互斥锁
+            基于非阻塞锁实现，可以避免死锁
+    """
+
+    def __init__(self, **kwargs):
+        """
+            参数：
+                lock_name:              <str> string or file_path
+                                            当为单纯的字符串时，将在当前文件夹下创建锁文件
+                wait_interval:          <int/float> 处于阻塞状态时，获取锁的每次尝试之间的时间间隔，单位为 second。
+                                            默认为 1e-1
+
+        """
+        # 默认参数
+        paras = {
+            # 必要参数
+            "lock_name": ".233",
+            "wait_interval": 1e-1,
+        }
+
+        # 获取参数
+        paras.update(kwargs)
+
+        # 校验参数
+        self.paras = paras
+
+        if os.path.dirname(self.paras["lock_name"]):
+            os.makedirs(os.path.dirname(self.paras["lock_name"]), exist_ok=True)
+        self.fd = open(self.paras["lock_name"], 'a')
+        self.state = dict(acquired=False)
+
+    def acquire(self, b_block_if_fail=True, time_out=None):
+        start_time = time.time()
+        while True:
+            try:
+                # 尝试获取文件锁
+                fcntl.flock(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                self.state["acquired"] = True
+                break
+            except IOError:
+                # 获取锁失败
+                if not b_block_if_fail or (time_out is not None and time.time() - start_time > time_out):
+                    # 超时或者设置了不阻塞
+                    self.state["acquired"] = False
+                    break
+                else:
+                    # 未超时，等待一段时间后重试
+                    time.sleep(self.paras["wait_interval"])
+        return self.state["acquired"]
+
+    def release(self, b_cool_down=True):
+        assert self.state["acquired"], \
+            f'Please use acquire() to acquire the lock before calling release()'
+        fcntl.flock(self.fd, fcntl.LOCK_UN)
+        if b_cool_down:
+            time.sleep(self.paras["wait_interval"] * 2)  # 冷却当前锁，让其他排队中的锁有机会获取资源，避免当前锁对资源的长期占用
+
+    @property
+    def acquired(self):
+        return self.state["acquired"]
+
+    def __del__(self):
+        try:
+            self.fd.close()
+        except:
+            pass

kevin-toolbox-dev-1.0.11/kevin_toolbox/computer_science/algorithm/scheduler/__init__.py

@@ -0,0 +1,2 @@
+from .strategy_manager import Strategy_Manager
+from .trigger import Trigger