mindstudio-probe 8.3.2__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/infer/utils/check/checker.py

@@ -0,0 +1,227 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+from functools import wraps
+from typing import Callable, Union, List
+from enum import Enum
+
+
+class EnumInstance(Enum):
+    NO_INSTANCE = 0
+
+
+class CheckResult:
+    def __init__(self, passed=True, msg="") -> None:
+        self.passed = bool(passed)
+        self.msg = msg
+
+    def __bool__(self):
+        return self.passed
+
+    def __str__(self) -> str:
+        return self.get_msg()
+
+    def __repr__(self) -> str:
+        return f"{self.passed}:{self.msg}"
+
+    def get_msg(self):
+        return "pass" if self.passed else self.msg
+
+
+class WaitingRule:
+    def __init__(self, func, args, kwargs, err_msg=None) -> None:
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.err_msg = f"{self.name} check failed." if err_msg is None else err_msg
+
+    @property
+    def name(self):
+        return self.func.__name__
+
+    def check(self, instence: "CheckerInstence"):
+        passed = self.func(instence, *self.args, **self.kwargs)
+        if isinstance(passed, CheckResult):
+            return passed
+        elif isinstance(passed, tuple) and len(passed) == 2:
+            return CheckResult(passed[0], passed[1])
+        else:
+            return CheckResult(bool(passed), self.err_msg)
+
+
+class Recorder:
+    def __init__(self) -> None:
+        self.record_set = set()
+
+    def add_record(self, *names) -> None:
+        self.record_set.update(names)
+
+    def in_records(self, name) -> bool:
+        return name in self.record_set
+
+    def union(self, recorder: "Recorder"):
+        self.record_set.update(recorder.record_set)
+
+
+class RuleRunner:
+    def __init__(self) -> None:
+        self.waiting_rules: List[WaitingRule] = []
+        self.default_rules: List[WaitingRule] = []
+        self.running_default = False
+        self.instence = None
+        self.recorder = Recorder()
+
+    def add_rule(self, waiting_rule):
+        self.waiting_rules.append(waiting_rule)
+
+    def set_recorder(self, recorder: Recorder):
+        self.recorder = recorder
+
+    def get_recorder(self) -> Recorder:
+        return self.recorder
+
+    def run_rule(self, waiting_rule: WaitingRule):
+        if self.running_default and self.recorder.in_records(waiting_rule.name):
+            return CheckResult()
+        self.recorder.add_record(waiting_rule.name)
+        return waiting_rule.check(self.instence)
+
+    def implement_check(self, instence: "CheckerInstence"):
+        self.instence = instence
+        self.running_default = False
+
+        for waiting_rule in self.waiting_rules:
+            passed = self.run_rule(waiting_rule)
+            if not passed:
+                return passed
+
+        self.running_default = True
+        for waiting_rule in self.default_rules:
+            passed = self.run_rule(waiting_rule)
+            if not passed:
+                return passed
+        return CheckResult()
+
+    def is_running(self):
+        return self.instence is not None
+
+    def as_default(self):
+        self.default_rules = self.waiting_rules
+        self.waiting_rules = []
+        return self
+
+
+class CheckerInstence:
+    def __init__(self, instance=EnumInstance.NO_INSTANCE, converter=None):
+        self.instance = instance
+        self.converter = converter
+
+    def has_instance(self):
+        return self.instance != EnumInstance.NO_INSTANCE
+
+    def get_instance(self):
+        return self.instance
+
+    def get_value(self):
+        # for args type
+        return self.instance
+
+    def convert_instance(self):
+        if self.converter is None:
+            return CheckResult()
+
+        self.instance, passed, err_msg = self.converter(self.instance)
+        return CheckResult(passed, err_msg)
+
+
+def rule(err_msg=None) -> Callable:
+    if not isinstance(err_msg, (type(None), str)):
+        raise TypeError("err_msg must be a string")
+
+    def make_rule_wrapper(func: Callable) -> Callable:
+        if not callable(func):
+            raise ValueError("The @rule decorator can only be applied to functions")
+
+        @wraps(func)
+        def wrapper(checker: "Checker", *args, **kwargs) -> Union["Checker", CheckResult]:
+            waiting_rule = WaitingRule(func, args, kwargs, err_msg)
+            if checker.is_running():
+                return checker.run_rule(waiting_rule)
+            else:
+                checker.add_rule(waiting_rule)
+
+            if checker.has_instance():
+                return checker.check(checker.get_instance())
+
+            return checker
+
+        return wrapper
+
+    return make_rule_wrapper
+
+
+class Checker(RuleRunner, CheckerInstence):
+    def __init__(self, instance=EnumInstance.NO_INSTANCE, converter=None) -> None:
+        RuleRunner.__init__(self)
+        CheckerInstence.__init__(self, instance, converter)
+
+    def check(self, value, will_raise=False) -> CheckResult:
+        self.instance = value
+        passed = self.convert_instance() and self.implement_check(self)
+        if not passed and will_raise:
+            raise ValueError(passed)
+        return passed
+
+    @rule(err_msg="value is None")
+    def not_none(self) -> Union["Checker", CheckResult]:
+        return self.instance is not None
+
+    @rule(err_msg="value is not None")
+    def is_none(self) -> Union["Checker", CheckResult]:
+        return self.instance is None
+
+    @rule()
+    def not_eq(self, cmp_value) -> Union["Checker", CheckResult]:
+        return self.instance != cmp_value, f"equal {cmp_value}"
+
+    @rule()
+    def eq(self, cmp_value) -> Union["Checker", CheckResult]:
+        return self.instance == cmp_value, f"not equal {cmp_value}?"
+
+    @rule()
+    def is_type(self, *types) -> Union["Checker", CheckResult]:
+        return self.not_none() and isinstance(self.instance, types), f"is not {types}"
+
+    @rule()
+    def any(self, *rules: "Checker") -> Union["Checker", CheckResult]:
+        passed = CheckResult()
+        for running_rule in rules:
+            if self.running_default:
+                running_rule.set_recorder(self.recorder)
+            passed = running_rule.check(self.instance)
+            if passed:
+                if not self.running_default:
+                    self.recorder.union(running_rule.get_recorder())
+                return passed
+
+        return passed
+
+    @rule()
+    def anti(self, anti_rule: "Checker") -> Union["Checker", CheckResult]:
+        anti_rule.set_recorder(self.recorder)
+        passed = anti_rule.check(self.instance)
+
+        return not passed, f"not {str(passed)}"

msprobe/infer/utils/check/dict_checker.py

@@ -0,0 +1,78 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+from typing import Union
+from msprobe.infer.utils.check.checker import Checker, CheckResult, rule
+
+
+class DictChecker(Checker):
+
+    @rule()
+    def is_dict(self) -> Union["DictChecker", CheckResult]:
+        return isinstance(self.instance, dict), "Input object is not a dict."
+
+    @rule()
+    def is_dict_not_empty(self) -> Union["DictChecker", CheckResult]:
+        is_pass = self.is_dict()
+        if not is_pass:
+            return is_pass
+        return bool(self.instance), "Dict is empty."
+
+    @rule()
+    def is_key_exists_in_dict(self, key) -> Union["DictChecker", CheckResult]:
+        is_pass = self.is_dict()
+        if not is_pass:
+            return is_pass
+        res = self._find_key_in_dict(self.instance, key)
+        return res, f"Key='{key}' is not in the dict."
+
+    @rule()
+    def is_values_valid(self, default_value=None, **value_rules: Checker) -> Union["DictChecker", CheckResult]:
+        is_pass = self.is_dict().passed
+        if not is_pass:
+            return is_pass, "Input object is not a dict."
+        err_msgs = []
+        for key, value_rule in value_rules.items():
+            value = self.instance.get(key, default_value)
+            rule_is_pass = value_rule.check(value)
+            if not rule_is_pass:
+                is_pass = False
+                err_msgs.append(f"{key} is invalid. {str(rule_is_pass)}")
+
+        return is_pass, "\n".join(err_msgs)
+
+    @rule()
+    def is_key_type_valid(self, exp_type) -> Union["DictChecker", CheckResult]:
+        is_pass = self.is_dict().passed
+        if not is_pass:
+            return is_pass
+        err_msg = []
+        for key in self.instance.keys():
+            if not isinstance(key, exp_type):
+                is_pass = False
+                err_msg.append(f'The type of {key} is not {exp_type.__name__}')
+        return is_pass, "\n".join(err_msg)
+
+    def _find_key_in_dict(self, my_dict, my_key):
+        if not isinstance(my_dict, dict):
+            return False
+        if my_key in my_dict:
+            return True
+        for dict_val in my_dict.values():
+            if isinstance(dict_val, dict):
+                if self._find_key_in_dict(dict_val, my_key):
+                    return True
+        return False

msprobe/infer/utils/check/func_wrapper.py

@@ -0,0 +1,96 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+import inspect
+from typing import Callable
+from functools import wraps
+
+
+class FuncWrapper:
+    def __init__(self, check_rules: dict) -> None:
+        self.check_rules = check_rules
+        self.args_names = []
+        self.args_name_set = set()
+        self.var_keyword_rule = None
+
+    def is_function_param_valid(self, to_raise, *args, **kwargs) -> bool:
+        if kwargs is not None:
+            for args_name, arg_value in kwargs.items():
+                check_rule = self.check_rules.get(args_name)
+                if check_rule is None and args_name not in self.args_name_set and self.var_keyword_rule is not None:
+                    check_rule = self.var_keyword_rule
+                if check_rule is None:
+                    continue
+
+                is_pass = check_rule.check(arg_value, will_raise=to_raise)
+                if not is_pass:
+                    return bool(is_pass), f"{args_name} is invalid. {str(is_pass)}"
+
+        if args is not None and len(self.args_names) > 0:
+            for index, arg_value in enumerate(args):
+
+                if len(self.args_names) > index:
+                    args_name = self.args_names[index]
+                else:
+                    args_name = self.args_names[-1]
+
+                check_rule = self.check_rules.get(args_name)
+                if check_rule is None:
+                    continue
+
+                is_pass = check_rule.check(arg_value, will_raise=to_raise)
+                if not is_pass:
+                    return bool(is_pass), f"{args_name} is invalid. {str(is_pass)}"
+        return True
+
+    def parse_function(self, func):
+        parameters = inspect.signature(func).parameters
+
+        for param in parameters.values():
+            if param.kind == inspect.Parameter.VAR_KEYWORD:
+                self.var_keyword_rule = self.check_rules.get(param.name)
+            else:
+                self.args_names.append(param.name)
+                if param.kind in [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY]:
+                    self.args_name_set.add(param.name)
+
+    def create_wrapper(self, ret_value, to_raise, logger=None) -> Callable:
+        def decorator(func) -> Callable:
+            self.parse_function(func)
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                is_pass = self.is_function_param_valid(to_raise, *args, **kwargs)
+                if isinstance(is_pass, bool) and is_pass:
+                    return func(*args, **kwargs)
+                else:
+                    if logger is not None and hasattr(logger, "error"):
+                        logger.error(str(is_pass))
+                    return ret_value
+
+            return wrapper
+
+        return decorator
+
+    def to_return(self, ret_value, logger=None) -> Callable:
+        return self.create_wrapper(ret_value, False, logger)
+
+    def to_raise(self) -> Callable:
+        return self.create_wrapper(None, True, None)
+
+
+def validate_params(**check_rules) -> FuncWrapper:
+    return FuncWrapper(check_rules)

msprobe/infer/utils/check/list_checker.py

@@ -0,0 +1,56 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+from typing import Union
+
+from msprobe.infer.utils.check.checker import Checker, CheckResult, rule
+
+
+class ListChecker(Checker):
+
+    @rule()
+    def is_list(self) -> Union["ListChecker", CheckResult]:
+        return isinstance(self.instance, list), "Input object is not a list."
+
+    @rule()
+    def is_list_not_empty(self) -> Union["ListChecker", CheckResult]:
+        return bool(self.instance), "List is empty."
+
+    @rule()
+    def is_element_valid(self, check_rule) -> Union["ListChecker", CheckResult]:
+        is_pass = self.is_list().passed
+        if not is_pass:
+            return is_pass, "Input object is not a list."
+        err_msgs = []
+        for element in self.instance:
+            rule_is_pass = check_rule.check(element)
+            if not rule_is_pass:
+                is_pass = False
+                err_msgs.append(f"{element}: {str(rule_is_pass)}")
+        return is_pass, "\n".join(err_msgs)
+
+    @rule()
+    def is_length_valid(self, min_length=None, max_length=None) -> Union["ListChecker", CheckResult]:
+        length = len(self.instance)
+        length_valid = True
+        err_msg = []
+        if min_length is not None and length < min_length:
+            length_valid = False
+            err_msg.append(f"List is shorter than the minimum length of {min_length}.")
+        if max_length is not None and length > max_length:
+            length_valid = False
+            err_msg.append(f"List is longer than the maximum length of {max_length}.")
+        return length_valid, "\n".join(err_msg)

msprobe/infer/utils/check/number_checker.py

@@ -0,0 +1,64 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+from typing import Union
+from msprobe.infer.utils.check.checker import Checker, CheckResult, rule
+
+
+class NumberChecker(Checker):
+
+    @rule()
+    def is_number(self) -> Union["NumberChecker", CheckResult]:
+        return CheckResult(isinstance(self.instance, (int, float)), "not number")
+
+    @rule()
+    def is_int(self) -> Union["NumberChecker", CheckResult]:
+        return CheckResult(isinstance(self.instance, int) and not isinstance(self.instance, bool), "not integer")
+
+    @rule()
+    def is_float(self) -> Union["NumberChecker", CheckResult]:
+        return CheckResult(isinstance(self.instance, float), "not float")
+
+    @rule()
+    def is_zero(self) -> Union["NumberChecker", CheckResult]:
+        return CheckResult(self.instance == 0, "not zero")
+
+    @rule()
+    def is_divisible_by(self, target) -> Union["NumberChecker", CheckResult]:
+        if self.instance != 0:
+            return CheckResult(target % self.instance == 0, f"not divisible by {target}")
+        else:
+            raise ValueError(f"Failed to check division, since {self.instance} is 0.")
+
+    @rule()
+    def in_range(self, min_value, max_value) -> Union["NumberChecker", CheckResult]:
+        return self.greater_equal(min_value) and self.less_equal(max_value)
+
+    @rule()
+    def greater_equal(self, value) -> Union["NumberChecker", CheckResult]:
+        return CheckResult(value <= self.instance, f"not greater equal to {value}")
+
+    @rule()
+    def less_equal(self, value) -> Union["NumberChecker", CheckResult]:
+        return CheckResult(self.instance <= value, f"not less equal to {value}")
+
+    @rule()
+    def less_than(self, value) -> Union["NumberChecker", CheckResult]:
+        return CheckResult(value > self.instance, f"not less than {value}")
+
+    @rule()
+    def greater_than(self, value) -> Union["NumberChecker", CheckResult]:
+        return CheckResult(self.instance > value, f"not greater than {value}")

msprobe/infer/utils/check/obj_checker.py

@@ -0,0 +1,41 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+from typing import Union
+from msprobe.infer.utils.check.checker import Checker, CheckResult, rule
+
+
+class ObjectChecker(Checker):
+    @rule()
+    def is_attr_valid(self, key, check_rule: Checker, default_value=None) -> Union["ObjectChecker", CheckResult]:
+        value = getattr(self.instance, key, default_value)
+        return check_rule.check(value)
+    
+    @rule()
+    def is_attrs_valid(self, default_value=None, **attr_rules: Checker) -> Union["ObjectChecker", CheckResult]:
+        is_pass = self.not_none()
+        if not is_pass:
+            return is_pass
+        
+        err_msgs = []
+        for attr_name, attr_rule in attr_rules.items():
+            attr_value = getattr(self.instance, attr_name, default_value)
+            rule_is_pass = attr_rule.check(attr_value)
+            if not rule_is_pass:
+                is_pass = False 
+                err_msgs.append(f"{attr_name} is invalid. {str(rule_is_pass)}")
+        
+        return is_pass, "\n".join(err_msgs)