movoid-debug 1.2.0__tar.gz → 1.2.2__tar.gz

{movoid_debug-1.2.0 → movoid_debug-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: movoid_debug
-Version: 1.2.0
+Version: 1.2.2
 Home-page: 
 Author: movoid
 Author-email: bobrobotsun@163.com

{movoid_debug-1.2.0 → movoid_debug-1.2.2}/movoid_debug/__init__.py

@@ -8,3 +8,4 @@
 """
 from .simple_debug import DEBUG, SimpleDebug
 from .simple_hot_pause import HOT_PAUSE, SimpleHotPause
+from .flow import FLOW, Flow, FlowFunction, debug_function, debug_class_include, debug_class_exclude

{movoid_debug-1.2.0 → movoid_debug-1.2.2}/movoid_debug/flow/__init__.py

@@ -6,6 +6,4 @@
 # Time          : 2024/6/2 21:50
 # Description   : 
 """
-
-if __name__ == '__main__':
-    pass
+from .flow import FLOW, Flow, FlowFunction, debug_function, debug_class_include, debug_class_exclude

{movoid_debug-1.2.0 → movoid_debug-1.2.2}/movoid_debug/flow/flow.py

@@ -9,9 +9,9 @@
 import sys
 import traceback
 
-from movoid_function import Function, wraps
+from movoid_function import Function, wraps, analyse_args_value_from_function
 
-from ..simple_ui import MainApp
+from ..simple_ui import MainApp, MainWindow
 
 
 class Flow:
@@ -22,11 +22,12 @@ class Flow:
         self.raise_error = 0
         self.error_type = 0
         self.check_error_type()
+        self.app = None
 
     def check_error_type(self):
         for i in sys.argv:
-            if i.startswith('_debug='):
-                temp = i[7:]
+            if i.startswith('__debug='):
+                temp = i[8:]
                 if temp == '1':
                     self.error_type = 1
 
@@ -53,8 +54,10 @@ class Flow:
         self.test = False
 
     def when_error_debug(self):
-        debug_app = MainApp(self)
-        debug_app.exec()
+        if self.app is None:
+            self.app = MainApp()
+        self.app.main = MainWindow(self)
+        self.app.exec()
 
     def when_error_cmd(self):
         print('错误发生：')
@@ -85,6 +88,21 @@ class BasicFunction:
         self.error = None
         self.traceback = ''
         self.error_mode = {}
+        self.end = False
+        self.has_return = False
+        self.re_value = None
+
+    def result(self, simple=False, tostring=False):
+        if self.has_return:
+            re_value = str(self.re_value) if tostring else self.re_value
+        elif self.traceback:
+            if simple:
+                re_value = f'{type(self.error).__name__}:{self.error}' if tostring else self.error
+            else:
+                re_value = self.traceback
+        else:
+            re_value = 'not done yet'
+        return re_value
 
     def add_son(self, son, son_type='function'):
         """
@@ -156,12 +174,10 @@ class FlowFunction(BasicFunction):
             self.include_error = include
         self.args = []
         self.kwargs = {}
-        self.has_return = False
-        self.re_value = None
+        self.kwarg_value = {}
         self.flow = flow
         self.parent = flow.current_function
         self.raise_error = False
-        self.end = False
         self.debug_mode = {
             0: True,
             1: True
@@ -169,13 +185,13 @@ class FlowFunction(BasicFunction):
 
     def __call__(self, *args, **kwargs):
         if self.flow.test:
-            test = TestFunction(self.func, self.flow)
-            self.son.append([test, 'function'])
+            test = TestFunction(self.func, self.flow, self)
             test(*args, **kwargs)
         else:
             try:
                 self.args = args
                 self.kwargs = kwargs
+                self.kwarg_value = analyse_args_value_from_function(self.func, *args, **kwargs)
                 self.flow.set_current_function(self)
                 re_value = self.func(*self.args, **self.kwargs)
             except self.exclude_error as err:
@@ -206,6 +222,7 @@ class FlowFunction(BasicFunction):
                 self.re_value = re_value
                 return self.re_value
             finally:
+                self.end = True
                 self.flow.current_function_end()
 
     def self_text(self, indent=0):
@@ -224,34 +241,38 @@ class FlowFunction(BasicFunction):
 class TestFunction(BasicFunction):
     func_type = 'test'
 
-    def __init__(self, func, flow):
+    def __init__(self, func, flow, ori):
         super().__init__()
         self.func = func
         self.flow = flow
+        self.ori = ori
         self.parent = self.flow.current_function
-        self.has_return = False
-        self.re_value = None
-        self.end = False
 
     def __call__(self, *args, **kwargs):
-        try:
-            self.args = args
-            self.kwargs = kwargs
-            re_value = self.func(*args, **kwargs)
-        except TestError as err:
-            if isinstance(self.parent, TestFunction):
-                raise err
-        except Exception as err:
-            self.err = err
-            self.traceback = traceback.format_exc()
-            if isinstance(self.parent, TestFunction):
-                raise TestError
+        if self.end:
+            self.ori(*args, **kwargs)
         else:
-            self.has_return = True
-            self.re_value = re_value
-            return self.re_value
-        finally:
-            self.end = True
+            try:
+                self.args = args
+                self.kwargs = kwargs
+                self.kwarg_value = analyse_args_value_from_function(self.func, *args, **kwargs)
+                self.flow.set_current_function(self)
+                re_value = self.func(*args, **kwargs)
+            except TestError as err:
+                if isinstance(self.parent, TestFunction):
+                    raise err
+            except Exception as err:
+                self.error = err
+                self.traceback = traceback.format_exc()
+                if isinstance(self.parent, TestFunction):
+                    raise TestError
+            else:
+                self.has_return = True
+                self.re_value = re_value
+                return self.re_value
+            finally:
+                self.end = True
+                self.flow.current_function_end()
 
     def self_text(self, indent=0):
         indent_str = '\t' * indent
@@ -274,3 +295,47 @@ class TestError(Exception):
 
 
 FLOW = Flow()
+
+
+def debug_function(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        temp = FlowFunction(func, FLOW)
+        temp(*args, **kwargs)
+
+    return wrapper
+
+
+def debug_class_include(name_list):
+    """
+    作为装饰器使用，传入一个列表，列表内所有函数的名称均会被增加debug
+    """
+
+    def dec(cls):
+        for name in name_list:
+            if hasattr(cls, name):
+                func = getattr(cls, name)
+                if callable(func):
+                    setattr(cls, name, debug_function(func))
+        return cls
+
+    return dec
+
+
+def debug_class_exclude(name_list=None):
+    """
+    作为装饰器使用，传入一个列表，除了__开头和列表里的名称，所有的函数均会被增加debug
+    不输入的情况下，会包含所有的函数
+    """
+
+    name_list = [] if name_list is None else list(name_list)
+
+    def dec(cls):
+        for name in dir(cls):
+            if not name.startswith('__') and name not in name_list:
+                func = getattr(cls, name)
+                if callable(func):
+                    setattr(cls, name, debug_function(func))
+        return cls
+
+    return dec

{movoid_debug-1.2.0 → movoid_debug-1.2.2}/movoid_debug/simple_ui/__init__.py

@@ -12,10 +12,11 @@ from .main_window import MainWindow
 
 
 class MainApp:
-    def __init__(self, flow):
+    def __init__(self):
         self.app = QApplication()
-        self.main = MainWindow(flow)
 
     def exec(self):
         return self.app.exec()
 
+    def quit(self):
+        return self.app.quit()

movoid_debug-1.2.2/movoid_debug/simple_ui/main_window.py

@@ -0,0 +1,246 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# File          : main_window
+# Author        : Sun YiFan-Movoid
+# Time          : 2024/6/2 21:48
+# Description   : 
+"""
+from PySide6.QtWidgets import QMainWindow, QApplication, QWidget, QGridLayout, QTreeWidget, QTextEdit, QHBoxLayout, QVBoxLayout, QPushButton, QTreeWidgetItem
+from .value_set_window import ValueSetWindow
+
+
+class MainWindow(QMainWindow):
+    def __init__(self, flow):
+        super().__init__()
+        self.flow = flow
+        self.init_ui()
+        self.show()
+        self.refresh_ui()
+
+    def init_ui(self):
+        screen_rect = QApplication.primaryScreen().geometry()
+        self.setGeometry(int(screen_rect.width() * 0.2), int(screen_rect.height() * 0.2), int(screen_rect.width() * 0.6), int(screen_rect.height() * 0.6))
+        main_table = QWidget(self)
+        self.setCentralWidget(main_table)
+        main_gird = QGridLayout(main_table)
+        main_table.setLayout(main_gird)
+        main_gird.setColumnStretch(0, 4)
+        main_gird.setColumnStretch(1, 2)
+        main_gird.setColumnStretch(2, 3)
+        main_gird.setColumnStretch(3, 1)
+        main_gird.setRowStretch(0, 1)
+        main_gird.setRowStretch(1, 2)
+
+        flow_tree = QTreeWidget(main_table)
+        flow_tree.setObjectName('flow_tree')
+        main_gird.addWidget(flow_tree, 0, 0, 2, 1)
+        flow_tree.setHeaderLabels(['type', 'func', 'args', 'kwargs', 'status'])
+        flow_tree.itemClicked.connect(self.click_flow_refresh_ui)
+
+        print_text = QTextEdit(main_table)
+        print_text.setObjectName('print_text')
+        main_gird.addWidget(print_text, 0, 1)
+
+        current_text = QTextEdit(main_table)
+        current_text.setObjectName('current_text')
+        main_gird.addWidget(current_text, 1, 1, 2, 1)
+
+        arg_tree = QTreeWidget(main_table)
+        arg_tree.setObjectName('arg_tree')
+        main_gird.addWidget(arg_tree, 0, 2, 1, 1)
+        arg_tree.setHeaderLabels(['arg', 'name', 'type', 'value'])
+        arg_tree.itemDoubleClicked.connect(lambda: self.change_arg_tree_value())
+
+        global_tree = QTreeWidget(main_table)
+        global_tree.setObjectName('global_tree')
+        main_gird.addWidget(global_tree, 1, 2, 2, 1)
+        global_tree.setHeaderLabels(['key', 'type', 'value'])
+        global_tree.itemExpanded.connect(self.expand_global_tree_to_show_dir)
+
+        run_widget = QWidget(main_table)
+        end_widget = QWidget(main_table)
+        main_gird.addWidget(run_widget, 0, 3)
+        main_gird.addWidget(end_widget, 4, 0, 1, 3)
+        run_grid = QVBoxLayout(run_widget)
+        run_widget.setLayout(run_grid)
+        end_grid = QHBoxLayout(end_widget)
+        end_widget.setLayout(end_grid)
+
+        run_test_button = QPushButton('测试', main_table)
+        run_test_button.setObjectName('run_test_button')
+        run_grid.addWidget(run_test_button)
+        run_test_button.clicked.connect(self.run_test)
+        run_grid.addStretch(1)
+
+        run_continue_button = QPushButton('忽略错误并continue', main_table)
+        run_continue_button.setObjectName('run_continue_button')
+        run_grid.addWidget(run_continue_button)
+        run_continue_button.clicked.connect(self.run_continue)
+        run_grid.addStretch(1)
+
+        run_raise_button = QPushButton('忽略错误并raise error', main_table)
+        run_raise_button.setObjectName('run_raise_button')
+        run_grid.addWidget(run_raise_button)
+        run_raise_button.clicked.connect(self.run_raise)
+
+        run_grid.addStretch(10)
+
+    def refresh_ui(self):
+        self.refresh_flow_tree()
+        self.refresh_global_tree()
+
+    def refresh_flow_tree(self):
+        flow_tree: QTreeWidget = self.findChild(QTreeWidget, 'flow_tree')
+        print_text: QTextEdit = self.findChild(QTextEdit, 'print_text')
+        flow_tree.clear()
+        self.refresh_flow_tree_item(flow_tree, self.flow.main)
+        current_function = self.flow.current_function
+        print_text.setText(str(current_function.result(tostring=True)))
+        flow_tree.expandAll()
+
+    def refresh_flow_tree_item(self, top_item, flow):
+        arg_tree: QTreeWidget = self.findChild(QTreeWidget, 'arg_tree')
+        select_flow = getattr(arg_tree, 'flow', None)
+        for i in flow.son:
+            if i[1] == 'function':
+                child = QTreeWidgetItem(top_item)
+                child.setText(0, i[0].func_type)
+                child.setText(1, i[0].func.__name__)
+                child.setText(2, str(i[0].args))
+                child.setText(3, str(i[0].kwargs))
+                child.setText(4, str(i[0].result(True, tostring=True)))
+                setattr(child, '__flow', i[0])
+                self.refresh_flow_tree_item(child, i[0])
+                if i[0] == select_flow:
+                    self.findChild(QTreeWidget, 'flow_tree').setCurrentItem(child)
+            else:
+                child = QTreeWidgetItem(top_item)
+                child.setText(0, 'log')
+                child.setText(1, str(i[0]))
+
+    def click_flow_refresh_ui(self, q):
+        flow_tree: QTreeWidget = self.findChild(QTreeWidget, 'flow_tree')
+        current_text: QTextEdit = self.findChild(QTextEdit, 'current_text')
+        arg_tree: QTreeWidget = self.findChild(QTreeWidget, 'arg_tree')
+        arg_tree.clear()
+        current_item = flow_tree.currentItem()
+        current_flow = getattr(current_item, '__flow')
+        current_text.setText(str(current_flow.result(tostring=True)))
+        self.refresh_arg_tree(current_flow)
+
+    def refresh_arg_tree(self, flow, kwarg_value=None):
+        kwarg_value = flow.kwarg_value if kwarg_value is None else kwarg_value
+        arg_tree: QTreeWidget = self.findChild(QTreeWidget, 'arg_tree')
+        setattr(arg_tree, 'flow', flow)
+        setattr(arg_tree, 'kwarg_value', kwarg_value)
+        arg_tree.clear()
+        for k, v in kwarg_value['arg'].items():
+            temp = QTreeWidgetItem(arg_tree)
+            temp.setText(0, 'arg')
+            temp.setText(1, str(k))
+            temp.setText(2, type(v).__name__)
+            temp.setText(3, str(v))
+            setattr(temp, 'kwarg_value', ['arg', k, v])
+            temp.setExpanded(True)
+        if 'args' in kwarg_value:
+            args_name = list(kwarg_value['args'].keys())[0]
+            args_list = kwarg_value['args'][args_name]
+            for k, v in enumerate(args_list):
+                temp = QTreeWidgetItem(arg_tree)
+                temp.setText(0, 'args')
+                temp.setText(1, f'{args_name}[{k}]')
+                temp.setText(2, type(v).__name__)
+                temp.setText(3, str(v))
+                setattr(temp, 'kwarg_value', ['args', args_name, k, v])
+        for k, v in kwarg_value['kwarg'].items():
+            temp = QTreeWidgetItem(arg_tree)
+            temp.setText(0, 'kwarg')
+            temp.setText(1, str(k))
+            temp.setText(2, type(v).__name__)
+            temp.setText(3, str(v))
+            setattr(temp, 'kwarg_value', ['kwarg', k, v])
+        if 'kwargs' in kwarg_value:
+            kwargs_name = list(kwarg_value['kwargs'].keys())[0]
+            kwargs_dict = kwarg_value['kwargs'][kwargs_name]
+            for k, v in kwargs_dict.items():
+                temp = QTreeWidgetItem(arg_tree)
+                temp.setText(0, 'kwargs')
+                temp.setText(1, f'{kwargs_name}[{k}]')
+                temp.setText(2, type(v).__name__)
+                temp.setText(3, str(v))
+                setattr(temp, 'kwarg_value', ['kwargs', kwargs_name, k, v])
+
+    def refresh_global_tree(self):
+        global_value = globals()
+        global_tree: QTreeWidget = self.findChild(QTreeWidget, 'global_tree')
+        for k, v in global_value.items():
+            if not k.startswith('__'):
+                temp = QTreeWidgetItem(global_tree)
+                temp.setText(0, k)
+                temp.setText(1, type(v).__name__)
+                temp.setText(2, str(v))
+                setattr(temp, '__value', v)
+                self.empty_tree_item_child(temp)
+
+    def run_test(self, q):
+        arg_tree: QTreeWidget = self.findChild(QTreeWidget, 'arg_tree')
+        if hasattr(arg_tree, 'flow'):
+            flow = getattr(arg_tree, 'flow')
+            kwarg_value = getattr(arg_tree, 'kwarg_value')
+            args = [_v for _k, _v in kwarg_value['arg'].items()]
+            if 'args' in kwarg_value:
+                args += [*list(kwarg_value['args'].values())[0]]
+            kwargs = {_k: _v for _k, _v in kwarg_value['kwarg'].items()}
+            if 'kwargs' in kwarg_value:
+                for k, v in list(kwarg_value['kwargs'].values())[0].items():
+                    kwargs[k] = v
+            flow(*args, **kwargs)
+            self.refresh_ui()
+
+    def run_continue(self, q):
+        self.close()
+
+    def run_raise(self, q):
+        self.flow.raise_error = -1
+        self.close()
+
+    def change_arg_tree_value(self):
+        arg_tree: QTreeWidget = self.findChild(QTreeWidget, 'arg_tree')
+        flow = getattr(arg_tree, 'flow')
+        kwarg_value = getattr(arg_tree, 'kwarg_value')
+        current_item = arg_tree.currentItem()
+        current_value = getattr(current_item, 'kwarg_value')
+        new_value = ValueSetWindow.get_value(current_value[-1])
+        if new_value != current_value[-1]:
+            temp = kwarg_value
+            for i in current_value[:-2]:
+                temp = temp[i]
+            temp[current_value[-2]] = new_value
+            self.refresh_arg_tree(flow, kwarg_value)
+
+    def empty_tree_item_child(self, item):
+        value = getattr(item, '__value')
+        if type(value) in (int, float, bool, str, list, dict) or value is None:
+            setattr(item, '__expand', False)
+        else:
+            temp = QTreeWidgetItem(item)
+            setattr(temp, '__delete', True)
+
+    def expand_global_tree_to_show_dir(self, item: QTreeWidgetItem):
+        if getattr(item, '__expand', True):
+            for i in range(item.childCount() - 1, -1, -1):
+                tar_item = item.child(i)
+                if getattr(tar_item, '__delete', False):
+                    item.removeChild(tar_item)
+            value = getattr(item, '__value')
+            for k in dir(value):
+                if not k.startswith('__'):
+                    v = getattr(value, k)
+                    if not callable(v):
+                        temp = QTreeWidgetItem(item)
+                        temp.setText(0, k)
+                        temp.setText(1, type(v).__name__)
+                        temp.setText(2, str(v))
+                        setattr(temp, '__value', v)
+                        self.empty_tree_item_child(temp)

movoid_debug-1.2.2/movoid_debug/simple_ui/value_set_window.py

@@ -0,0 +1,292 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# File          : value_set_window
+# Author        : Sun YiFan-Movoid
+# Time          : 2024/6/9 23:13
+# Description   : 
+"""
+import inspect
+import traceback
+
+from PySide6.QtWidgets import QWidget, QGridLayout, QApplication, QRadioButton, QErrorMessage, QVBoxLayout, QTextEdit, QTreeWidget, QHBoxLayout, QPushButton, QMessageBox, QDialog, QTreeWidgetItem
+
+
+class ValueSetWindow(QDialog):
+    def __init__(self, ori_value):
+        super().__init__()
+        self.ori_value = ori_value
+        self.get_value = lambda: ''
+        self.re_value = self.ori_value
+        self.args = []
+        self.init_ui()
+        self.init_ori_value()
+
+    def init_ui(self):
+        screen_rect = QApplication.primaryScreen().geometry()
+        self.setGeometry(int(screen_rect.width() * 0.3), int(screen_rect.height() * 0.3), int(screen_rect.width() * 0.4), int(screen_rect.height() * 0.4))
+        main_grid = QGridLayout(self)
+        main_grid.setObjectName('main_grid')
+        self.setLayout(main_grid)
+        main_grid.setColumnStretch(0, 1)
+        main_grid.setColumnStretch(1, 4)
+        main_grid.setRowStretch(0, 4)
+        main_grid.setRowStretch(1, 1)
+
+        input_widget = QWidget(self)
+        main_grid.addWidget(input_widget, 0, 1)
+        input_grid = QGridLayout(input_widget)
+        input_widget.setLayout(input_grid)
+        input_text = QTextEdit(input_widget)
+        input_text.setObjectName('input_text')
+        input_grid.addWidget(input_text, 0, 0)
+        arg_tree = QTreeWidget(input_widget)
+        arg_tree.setObjectName('arg_tree')
+        arg_tree.setHeaderLabels(['from', 'name', 'type', 'value'])
+        input_grid.addWidget(arg_tree, 0, 1)
+        arg_tree.itemExpanded.connect(self.expand_object_to_show_dir)
+
+        type_widget = QWidget(self)
+        main_grid.addWidget(type_widget, 0, 0)
+        type_grid = QVBoxLayout(type_widget)
+        type_widget.setLayout(type_grid)
+
+        int_radio = QRadioButton(type_widget)
+        int_radio.setObjectName('int_radio')
+        type_grid.addWidget(int_radio, 0)
+        int_radio.setText('int')
+        int_radio.clicked.connect(lambda: self.radio_choose_int())
+
+        float_radio = QRadioButton(type_widget)
+        float_radio.setObjectName('float_radio')
+        type_grid.addWidget(float_radio, 1)
+        float_radio.setText('float')
+        float_radio.clicked.connect(lambda: self.radio_choose_float())
+
+        str_radio = QRadioButton(type_widget)
+        str_radio.setObjectName('str_radio')
+        type_grid.addWidget(str_radio, 0)
+        str_radio.setText('str')
+        str_radio.clicked.connect(lambda: self.radio_choose_str())
+
+        list_radio = QRadioButton(type_widget)
+        list_radio.setObjectName('list_radio')
+        type_grid.addWidget(list_radio, 0)
+        list_radio.setText('list')
+        list_radio.clicked.connect(lambda: self.radio_choose_list())
+
+        dict_radio = QRadioButton(type_widget)
+        dict_radio.setObjectName('dict_radio')
+        type_grid.addWidget(dict_radio, 0)
+        dict_radio.setText('dict')
+        dict_radio.clicked.connect(lambda: self.radio_choose_dict())
+
+        none_radio = QRadioButton(type_widget)
+        none_radio.setObjectName('none_radio')
+        type_grid.addWidget(none_radio, 0)
+        none_radio.setText('None')
+        none_radio.clicked.connect(lambda: self.radio_choose_none())
+
+        object_radio = QRadioButton(type_widget)
+        object_radio.setObjectName('object_radio')
+        type_grid.addWidget(object_radio, 0)
+        object_radio.setText('object')
+        object_radio.clicked.connect(lambda: self.radio_choose_object())
+
+        type_grid.addStretch(1)
+
+        end_widget = QWidget(self)
+        main_grid.addWidget(end_widget, 1, 0, 1, 2)
+        end_grid = QHBoxLayout(end_widget)
+        end_widget.setLayout(end_grid)
+
+        end_grid.addStretch(4)
+        end_ok = QPushButton(self)
+        end_ok.setText('OK')
+        end_grid.addWidget(end_ok)
+        end_ok.clicked.connect(lambda: self.end_ok())
+
+        end_grid.addStretch(1)
+        end_cancel = QPushButton(self)
+        end_cancel.setText('Cancel')
+        end_grid.addWidget(end_cancel)
+        end_cancel.clicked.connect(lambda: self.end_cancel())
+
+    def init_ori_value(self):
+        ori_type = type(self.ori_value)
+        if ori_type is int:
+            self.radio_choose_int(self.ori_value)
+        elif ori_type is float:
+            self.radio_choose_float(self.ori_value)
+        elif ori_type is str:
+            self.radio_choose_str(self.ori_value)
+        elif ori_type in (list, tuple, set):
+            self.radio_choose_list(self.ori_value)
+        elif ori_type is dict:
+            self.radio_choose_dict(self.ori_value)
+        elif self.ori_value is None:
+            self.radio_choose_none()
+        else:
+            self.args.append(self.ori_value)
+            self.radio_choose_object()
+
+    def radio_choose_int(self, init_text=None):
+        self.get_value = self._get_int
+        self.input_text_show(init_text=init_text)
+        radio: QRadioButton = self.findChild(QRadioButton, 'int_radio')
+        radio.setChecked(True)
+
+    def radio_choose_float(self, init_text=None):
+        self.get_value = self._get_float
+        self.input_text_show(init_text=init_text)
+        radio: QRadioButton = self.findChild(QRadioButton, 'float_radio')
+        radio.setChecked(True)
+
+    def radio_choose_str(self, init_text=None):
+        self.get_value = self._get_str
+        self.input_text_show(init_text=init_text)
+        radio: QRadioButton = self.findChild(QRadioButton, 'str_radio')
+        radio.setChecked(True)
+
+    def radio_choose_list(self, init_text=None):
+        self.get_value = self._get_list
+        self.input_text_show(init_text=init_text)
+        radio: QRadioButton = self.findChild(QRadioButton, 'list_radio')
+        radio.setChecked(True)
+
+    def radio_choose_dict(self, init_text=None):
+        self.get_value = self._get_dict
+        self.input_text_show(init_text=init_text)
+        radio: QRadioButton = self.findChild(QRadioButton, 'dict_radio')
+        radio.setChecked(True)
+
+    def radio_choose_none(self):
+        self.get_value = self._get_none
+        self.input_text_show('')
+        radio: QRadioButton = self.findChild(QRadioButton, 'none_radio')
+        radio.setChecked(True)
+
+    def radio_choose_object(self):
+        self.get_value = self._get_object
+        self.input_text_show('arg_tree')
+        radio: QRadioButton = self.findChild(QRadioButton, 'object_radio')
+        radio.setChecked(True)
+
+    def input_text_show(self, object_name='input_text', init_text=None):
+        arg_tree: QTreeWidget = self.findChild(QTreeWidget, 'arg_tree')
+        arg_tree.setVisible(False)
+        input_text: QTextEdit = self.findChild(QTextEdit, 'input_text')
+        input_text.setVisible(False)
+        if object_name == 'input_text':
+            input_text.setVisible(True)
+            input_text.clear()
+            if init_text:
+                input_text.setText(str(init_text))
+        elif object_name == 'arg_tree':
+            arg_tree.setVisible(True)
+            self.refresh_arg_tree()
+
+    def refresh_arg_tree(self):
+        arg_tree: QTreeWidget = self.findChild(QTreeWidget, 'arg_tree')
+        arg_tree.clear()
+        global_value = globals()
+        for i in self.args:
+            temp = QTreeWidgetItem(arg_tree)
+            temp.setText(0, 'ori')
+            temp.setText(2, type(i).__name__)
+            temp.setText(3, str(i))
+            setattr(temp, '__value', i)
+            arg_tree.setCurrentItem(temp)
+            self.empty_tree_item_child(temp)
+        for k, v in global_value.items():
+            if not k.startswith('__'):
+                temp = QTreeWidgetItem(arg_tree)
+                temp.setText(1, str(k))
+                temp.setText(2, type(v).__name__)
+                temp.setText(3, str(v))
+                setattr(temp, '__value', v)
+                self.empty_tree_item_child(temp)
+
+    def end_ok(self):
+        try:
+            self.re_value = self.get_value()
+        except Exception:
+            QMessageBox.critical(self, '获取值错误!', traceback.format_exc())
+        else:
+            self.done(0)
+
+    def end_cancel(self):
+        self.re_value = self.ori_value
+        self.done(1)
+
+    def _get_int(self):
+        input_text: QTextEdit = self.findChild(QTextEdit, 'input_text')
+        re_value = int(input_text.toPlainText())
+        return re_value
+
+    def _get_float(self):
+        input_text: QTextEdit = self.findChild(QTextEdit, 'input_text')
+        re_value = float(input_text.toPlainText())
+        return re_value
+
+    def _get_str(self):
+        input_text: QTextEdit = self.findChild(QTextEdit, 'input_text')
+        re_value = str(input_text.toPlainText())
+        return re_value
+
+    def _get_list(self):
+        input_text: QTextEdit = self.findChild(QTextEdit, 'input_text')
+        re_value = list(eval(input_text.toPlainText()))
+        return re_value
+
+    def _get_dict(self):
+        input_text: QTextEdit = self.findChild(QTextEdit, 'input_text')
+        re_value = dict(eval(input_text.toPlainText()))
+        return re_value
+
+    def _get_none(self):
+        return None
+
+    def _get_object(self):
+        arg_tree: QTreeWidget = self.findChild(QTreeWidget, 'arg_tree')
+        tar_arg = arg_tree.currentItem()
+        return getattr(tar_arg, '__value')
+
+    def get_re_value(self):
+        print('func', self, self.re_value)
+        return self.re_value
+
+    @classmethod
+    def get_value(cls, ori_value):
+        temp = ValueSetWindow(ori_value)
+        temp.show()
+        temp.exec()
+        return temp.re_value
+
+    def empty_tree_item_child(self, item):
+        value = getattr(item, '__value')
+        if type(value) in (int, float, bool, str, list, dict) or value is None:
+            setattr(item, '__expand', False)
+        else:
+            temp = QTreeWidgetItem(item)
+            setattr(temp, '__delete', True)
+            temp = QTreeWidgetItem(item)
+            setattr(temp, '__delete', True)
+
+    def expand_object_to_show_dir(self, item: QTreeWidgetItem):
+        if getattr(item, '__expand', True):
+            for i in range(item.childCount() - 1, -1, -1):
+                tar_item = item.child(i)
+                if getattr(tar_item, '__delete'):
+                    item.removeChild(tar_item)
+            value = getattr(item, '__value')
+            for k in dir(value):
+                if not k.startswith('__'):
+                    v = getattr(value, k)
+                    if not callable(v):
+                        temp = QTreeWidgetItem(item)
+                        temp.setText(1, k)
+                        temp.setText(2, type(v).__name__)
+                        temp.setText(3, str(v))
+                        setattr(temp, '__value', v)
+                        self.empty_tree_item_child(temp)

{movoid_debug-1.2.0 → movoid_debug-1.2.2}/movoid_debug.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: movoid_debug
-Version: 1.2.0
+Version: 1.2.2
 Home-page: 
 Author: movoid
 Author-email: bobrobotsun@163.com

{movoid_debug-1.2.0 → movoid_debug-1.2.2}/movoid_debug.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ movoid_debug.egg-info/top_level.txt
 movoid_debug/flow/__init__.py
 movoid_debug/flow/flow.py
 movoid_debug/simple_ui/__init__.py
-movoid_debug/simple_ui/main_window.py
+movoid_debug/simple_ui/main_window.py
+movoid_debug/simple_ui/value_set_window.py

{movoid_debug-1.2.0 → movoid_debug-1.2.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding='utf-8') as fh:
 
 setup(
     name='movoid_debug',
-    version='1.2.0',
+    version='1.2.2',
     packages=find_packages(),
     url='',
     license='',

movoid_debug-1.2.0/movoid_debug/simple_ui/main_window.py

@@ -1,163 +0,0 @@
-#! /usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-# File          : main_window
-# Author        : Sun YiFan-Movoid
-# Time          : 2024/6/2 21:48
-# Description   : 
-"""
-from PySide6.QtWidgets import QMainWindow, QApplication, QWidget, QGridLayout, QTreeWidget, QTextEdit, QHBoxLayout, QVBoxLayout, QPushButton, QTreeWidgetItem
-
-
-class MainWindow(QMainWindow):
-    def __init__(self, flow):
-        super().__init__()
-        self.flow = flow
-        self.init_ui()
-        self.show()
-        self.refresh_ui()
-
-    def init_ui(self):
-        screen_rect = QApplication.primaryScreen().geometry()
-        self.setGeometry(int(screen_rect.width() * 0.2), int(screen_rect.height() * 0.2), int(screen_rect.width() * 0.6), int(screen_rect.height() * 0.6))
-        main_table = QWidget(self)
-        self.setCentralWidget(main_table)
-        main_gird = QGridLayout(main_table)
-        main_table.setLayout(main_gird)
-        main_gird.setColumnStretch(0, 4)
-        main_gird.setColumnStretch(1, 2)
-        main_gird.setColumnStretch(2, 1)
-
-        flow_tree = QTreeWidget(main_table)
-        flow_tree.setObjectName('flow_tree')
-        main_gird.addWidget(flow_tree, 0, 0, 2, 1)
-        flow_tree.setHeaderLabels(['type', 'func', 'args', 'kwargs', 'status'])
-        flow_tree.itemClicked.connect(self.refresh_current_text)
-
-        print_text = QTextEdit(main_table)
-        print_text.setObjectName('print_text')
-        main_gird.addWidget(print_text, 0, 1)
-
-        current_text = QTextEdit(main_table)
-        current_text.setObjectName('current_text')
-        main_gird.addWidget(current_text, 1, 1)
-
-        run_widget = QWidget(main_table)
-        end_widget = QWidget(main_table)
-        main_gird.addWidget(run_widget, 0, 3)
-        main_gird.addWidget(end_widget, 4, 0, 1, 3)
-        run_grid = QVBoxLayout(run_widget)
-        run_widget.setLayout(run_grid)
-        end_grid = QHBoxLayout(end_widget)
-        end_widget.setLayout(end_grid)
-
-        run_test_button = QPushButton('测试', main_table)
-        run_test_button.setObjectName('run_test_button')
-        run_grid.addWidget(run_test_button)
-        run_test_button.clicked.connect(self.run_test)
-        run_grid.addStretch(1)
-
-        run_continue_button = QPushButton('忽略错误并continue', main_table)
-        run_continue_button.setObjectName('run_continue_button')
-        run_grid.addWidget(run_continue_button)
-        run_continue_button.clicked.connect(self.run_continue)
-        run_grid.addStretch(1)
-
-        run_raise_button = QPushButton('忽略错误并raise error', main_table)
-        run_raise_button.setObjectName('run_raise_button')
-        run_grid.addWidget(run_raise_button)
-        run_raise_button.clicked.connect(self.run_raise)
-
-        run_grid.addStretch(10)
-
-    def refresh_ui(self):
-        flow_tree: QTreeWidget = self.findChild(QTreeWidget, 'flow_tree')
-        print_text: QTextEdit = self.findChild(QTextEdit, 'print_text')
-        flow_tree.clear()
-        main = self.flow.main
-        for i in main.son:
-            if i[1] == 'function':
-                child = QTreeWidgetItem(flow_tree)
-                child.setText(0, 'function')
-                child.setText(1, i[0].func.__name__)
-                child.setText(2, str(i[0].args))
-                child.setText(3, str(i[0].kwargs))
-                if i[0].end:
-                    if i[0].has_return:
-                        child_4_str = str(i[0].re_value)
-                    else:
-                        child_4_str = str(i[0].err)
-                else:
-                    child_4_str = '未结束'
-                child.setText(4, child_4_str)
-                setattr(child, '__flow', i[0])
-                flow_tree.addTopLevelItem(child)
-                self.refresh_flow_tree(child, i[0])
-            else:
-                child = QTreeWidgetItem(flow_tree)
-                child.setText(0, 'log')
-                child.setText(1, str(i[0]))
-                flow_tree.addTopLevelItem(child)
-        current_function = self.flow.current_function
-        if current_function.end:
-            if current_function.has_return:
-                print_str = str(current_function.re_value)
-            else:
-                print_str = str(current_function.traceback)
-        else:
-            print_str = '未结束'
-        print_text.setText(print_str)
-        flow_tree.expandAll()
-
-    def refresh_flow_tree(self, top_item, flow):
-        for i in flow.son:
-            if i[1] == 'function':
-                child = QTreeWidgetItem(top_item)
-                child.setText(0, i[0].func_type)
-                child.setText(1, i[0].func.__name__)
-                child.setText(2, str(i[0].args))
-                child.setText(3, str(i[0].kwargs))
-                if i[0].end:
-                    if i[0].has_return:
-                        child_4_str = str(i[0].re_value)
-                    else:
-                        child_4_str = str(i[0].err)
-                else:
-                    child_4_str = '未结束'
-                child.setText(4, child_4_str)
-                setattr(child, '__flow', i[0])
-                top_item.addChild(child)
-                self.refresh_flow_tree(child, i[0])
-            else:
-                child = QTreeWidgetItem(top_item)
-                child.setText(0, 'log')
-                child.setText(1, str(i[0]))
-                top_item.addChild(child)
-
-    def refresh_current_text(self, q):
-        flow_tree: QTreeWidget = self.findChild(QTreeWidget, 'flow_tree')
-        current_text: QTextEdit = self.findChild(QTextEdit, 'current_text')
-        current_item = flow_tree.currentItem()
-        current_flow = getattr(current_item, '__flow')
-        if current_flow.end:
-            if current_flow.has_return:
-                current_str = str(current_flow.re_value)
-            else:
-                current_str = str(current_flow.traceback)
-        else:
-            current_str = '未结束'
-        current_text.setText(current_str)
-
-    def run_test(self, q):
-        flow_tree: QTreeWidget = self.findChild(QTreeWidget, 'flow_tree')
-        current_item = flow_tree.currentItem()
-        current_flow = getattr(current_item, '__flow')
-        current_flow(*current_flow.args, **current_flow.kwargs)
-        self.refresh_ui()
-
-    def run_continue(self, q):
-        self.close()
-
-    def run_raise(self, q):
-        self.flow.raise_error = -1
-        self.close()