def loadFullValue(self, seq, scope_attrs): """ Evaluate full value for async Console variables in a separate thread and send results to IDE side :param seq: id of command :param scope_attrs: a sequence of variables with their attributes separated by NEXT_VALUE_SEPARATOR (i.e.: obj\tattr1\tattr2NEXT_VALUE_SEPARATORobj2\attr1\tattr2) :return: """ try: frame_variables = self.get_namespace() var_objects = [] # vars = scope_attrs.split(NEXT_VALUE_SEPARATOR) vars = scope_attrs for var_attrs in vars: if '\t' in var_attrs: name, attrs = var_attrs.split('\t', 1) else: name = var_attrs attrs = None if name in frame_variables.keys(): var_object = pydevd_vars.resolve_var_object(frame_variables[name], attrs) var_objects.append((var_object, name)) else: var_object = pydevd_vars.eval_in_context(name, frame_variables, frame_variables) var_objects.append((var_object, name)) from _pydev_bundle.pydev_console_commands import ThriftGetValueAsyncThreadConsole t = ThriftGetValueAsyncThreadConsole(self.get_server(), seq, var_objects) t.start() except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())
def getVariable(self, attributes): try: namespace = self.get_namespace() debug_values = [] val_dict = pydevd_vars.resolve_compound_var_object_fields( namespace, attributes, self.user_type_renderers) if val_dict is None: val_dict = {} keys = val_dict.keys() for k in keys: val = val_dict[k] evaluate_full_value = pydevd_thrift.should_evaluate_full_value( val) debug_values.append( pydevd_thrift.var_to_struct( val, k, evaluate_full_value=evaluate_full_value, user_type_renderers=self.user_type_renderers)) return debug_values except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())
def getFrame(self): try: hidden_ns = self.get_ipython_hidden_vars_dict() return pydevd_thrift.frame_vars_to_struct(self.get_namespace(), hidden_ns) except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())
def execDataViewerAction(self, varName, action, args): try: tmp_var = pydevd_vars.eval_in_context(varName, self.get_namespace(), self.get_namespace()) return InternalDataViewerAction.act(tmp_var, action, args.split("\t")) except Exception as e: raise PythonUnhandledException(type(e).__name__ + "\n" + traceback.format_exc())
def evaluate(self, expression, do_trunc): # returns `DebugValue` of evaluated expression try: result = pydevd_vars.eval_in_context(expression, self.get_namespace(), self.get_namespace()) return [pydevd_thrift.var_to_struct(result, expression, do_trim=do_trunc)] except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())
def getArray(self, attr, roffset, coffset, rows, cols, format): try: name = attr.split("\t")[-1] array = pydevd_vars.eval_in_context(name, self.get_namespace(), self.get_namespace()) return pydevd_thrift.table_like_struct_to_thrift_struct(array, name, roffset, coffset, rows, cols, format) except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())
def setUserTypeRenderers(self, message): try: renderers = parse_set_type_renderers_message(message) self.user_type_renderers = renderers return True except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())
def execLine(self, line): try: if not self.banner_shown: line = self.build_banner() + line self.banner_shown = True return self.do_exec_code(line, True) except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())
def changeVariable(self, attr, value): try: def do_change_variable(): Exec('%s=%s' % (attr, value), self.get_namespace(), self.get_namespace()) # Important: it has to be really enabled in the main thread, so, schedule # it to run in the main thread. self.exec_queue.put(do_change_variable) except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())
def execTableCommand(self, command, command_type): try: success, res = exec_table_command(command, command_type, self.get_namespace(), self.get_namespace()) if success: return res except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc()) if not success: raise PythonTableException(str(res))
def execMultipleLines(self, lines): try: if not self.banner_shown: lines = self.build_banner() + lines self.banner_shown = True if IS_JYTHON: for line in lines.split('\n'): self.do_exec_code(line, True) else: return self.do_exec_code(lines, False) except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())
def getCompletions(self, text, act_tok): try: words = self.do_get_completions(text, act_tok) return [_to_completion_option(word) for word in words] except: raise PythonUnhandledException(traceback.format_exc())
def connectToDebugger(self, debuggerPort, debugger_host=None, debugger_options=None, extra_envs=None): ''' Used to show console with variables connection. Mainly, monkey-patches things in the debugger structure so that the debugger protocol works. ''' try: if debugger_options is None: debugger_options = {} for (env_name, value) in dict_iter_items(extra_envs): existing_value = os.environ.get(env_name, None) if existing_value: os.environ[env_name] = "%s%c%s" % (existing_value, os.path.pathsep, value) else: os.environ[env_name] = value if env_name == "PYTHONPATH": sys.path.append(value) def do_connect_to_debugger(): try: # Try to import the packages needed to attach the debugger import pydevd from _pydev_imps._pydev_saved_modules import threading except: # This happens on Jython embedded in host eclipse traceback.print_exc() sys.stderr.write('pydevd is not available, cannot connect\n', ) from _pydevd_bundle.pydevd_constants import set_thread_id from _pydev_bundle import pydev_localhost set_thread_id(threading.currentThread(), "console_main") self.orig_find_frame = pydevd_vars.find_frame pydevd_vars.find_frame = self._findFrame self.debugger = pydevd.PyDB() try: pydevd.apply_debugger_options(debugger_options) if debugger_host is None or pydev_localhost.is_localhost(debugger_host): host = pydev_localhost.get_localhost() else: host = debugger_host self.debugger.connect(host, debuggerPort) self.debugger.prepare_to_run() self.debugger.disable_tracing() except: traceback.print_exc() sys.stderr.write('Failed to connect to target debugger.\n') # Register to process commands when idle self.debugrunning = False try: import pydevconsole pydevconsole.set_debug_hook(self.debugger.process_internal_commands) except: traceback.print_exc() sys.stderr.write('Version of Python does not support debuggable Interactive Console.\n') # Important: it has to be really enabled in the main thread, so, schedule # it to run in the main thread. self.exec_queue.put(do_connect_to_debugger) return ('connect complete',) except: traceback.print_exc() raise PythonUnhandledException(traceback.format_exc())