From 7f9518aac69c18f713f8ccf17fcd86849abeb3aa Mon Sep 17 00:00:00 2001 From: PhillipRambo Date: Mon, 14 Jul 2025 11:44:14 +0200 Subject: [PATCH] remove external folder and add to .gitignore --- modules/module_0_foundations/gmid | 1 - .../pydevd_frame_evaluator.pyx | 747 ------------------ 2 files changed, 748 deletions(-) delete mode 160000 modules/module_0_foundations/gmid delete mode 100644 modules/module_0_foundations/gmid_env/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_evaluator.pyx diff --git a/modules/module_0_foundations/gmid b/modules/module_0_foundations/gmid deleted file mode 160000 index 2ed3ccb0..00000000 --- a/modules/module_0_foundations/gmid +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 2ed3ccb01a8170dab3bdb181f1bea9b8d5044f94 diff --git a/modules/module_0_foundations/gmid_env/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_evaluator.pyx b/modules/module_0_foundations/gmid_env/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_evaluator.pyx deleted file mode 100644 index 8e7b9965..00000000 --- a/modules/module_0_foundations/gmid_env/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_evaluator.pyx +++ /dev/null @@ -1,747 +0,0 @@ -from __future__ import print_function -from _pydev_bundle._pydev_saved_modules import threading, thread -from _pydevd_bundle.pydevd_constants import GlobalDebuggerHolder -import dis -import sys -from _pydevd_frame_eval.pydevd_frame_tracing import update_globals_dict, dummy_tracing_holder -from _pydevd_frame_eval.pydevd_modify_bytecode import DebugHelper, insert_pydevd_breaks -from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER -from _pydevd_bundle.pydevd_trace_dispatch import fix_top_level_trace_and_get_trace_func - -from _pydevd_bundle.pydevd_additional_thread_info import _set_additional_thread_info_lock -from _pydevd_bundle.pydevd_cython cimport PyDBAdditionalThreadInfo -from pydevd_tracing import SetTrace - -_get_ident = threading.get_ident # Note this is py3 only, if py2 needed to be supported, _get_ident would be needed. -_thread_local_info = threading.local() -_thread_active = threading._active - -def clear_thread_local_info(): - global _thread_local_info - _thread_local_info = threading.local() - - -cdef class ThreadInfo: - - cdef public PyDBAdditionalThreadInfo additional_info - cdef public bint is_pydevd_thread - cdef public int inside_frame_eval - cdef public bint fully_initialized - cdef public object thread_trace_func - cdef bint _can_create_dummy_thread - - # Note: whenever get_func_code_info is called, this value is reset (we're using - # it as a thread-local value info). - # If True the debugger should not go into trace mode even if the new - # code for a function is None and there are breakpoints. - cdef public bint force_stay_in_untraced_mode - - cdef initialize(self, PyFrameObject * frame_obj): - # Places that create a ThreadInfo should verify that - # a current Python frame is being executed! - assert frame_obj != NULL - - self.additional_info = None - self.is_pydevd_thread = False - self.inside_frame_eval = 0 - self.fully_initialized = False - self.thread_trace_func = None - - # Get the root (if it's not a Thread initialized from the threading - # module, create the dummy thread entry so that we can debug it -- - # otherwise, we have to wait for the threading module itself to - # create the Thread entry). - while frame_obj.f_back != NULL: - frame_obj = frame_obj.f_back - - basename = frame_obj.f_code.co_filename - i = basename.rfind('/') - j = basename.rfind('\\') - if j > i: - i = j - if i >= 0: - basename = basename[i + 1:] - # remove ext - i = basename.rfind('.') - if i >= 0: - basename = basename[:i] - - co_name = frame_obj.f_code.co_name - - # In these cases we cannot create a dummy thread (an actual - # thread will be created later or tracing will already be set). - if basename == 'threading' and co_name in ('__bootstrap', '_bootstrap', '__bootstrap_inner', '_bootstrap_inner'): - self._can_create_dummy_thread = False - elif basename == 'pydev_monkey' and co_name == '__call__': - self._can_create_dummy_thread = False - elif basename == 'pydevd' and co_name in ('run', 'main', '_exec'): - self._can_create_dummy_thread = False - elif basename == 'pydevd_tracing': - self._can_create_dummy_thread = False - else: - self._can_create_dummy_thread = True - - # print('Can create dummy thread for thread started in: %s %s' % (basename, co_name)) - - cdef initialize_if_possible(self): - # Don't call threading.currentThread because if we're too early in the process - # we may create a dummy thread. - self.inside_frame_eval += 1 - - try: - thread_ident = _get_ident() - t = _thread_active.get(thread_ident) - if t is None: - if self._can_create_dummy_thread: - # Initialize the dummy thread and set the tracing (both are needed to - # actually stop on breakpoints). - t = threading.current_thread() - SetTrace(dummy_trace_dispatch) - else: - return # Cannot initialize until thread becomes active. - - if getattr(t, 'is_pydev_daemon_thread', False): - self.is_pydevd_thread = True - self.fully_initialized = True - else: - try: - additional_info = t.additional_info - if additional_info is None: - raise AttributeError() - except: - with _set_additional_thread_info_lock: - # If it's not there, set it within a lock to avoid any racing - # conditions. - additional_info = getattr(thread, 'additional_info', None) - if additional_info is None: - additional_info = PyDBAdditionalThreadInfo() - t.additional_info = additional_info - self.additional_info = additional_info - self.fully_initialized = True - finally: - self.inside_frame_eval -= 1 - - -cdef class FuncCodeInfo: - - cdef public str co_filename - cdef public str co_name - cdef public str canonical_normalized_filename - cdef bint always_skip_code - cdef public bint breakpoint_found - cdef public object new_code - - # When breakpoints_mtime != PyDb.mtime the validity of breakpoints have - # to be re-evaluated (if invalid a new FuncCodeInfo must be created and - # tracing can't be disabled for the related frames). - cdef public int breakpoints_mtime - - def __init__(self): - self.co_filename = '' - self.canonical_normalized_filename = '' - self.always_skip_code = False - - # If breakpoints are found but new_code is None, - # this means we weren't able to actually add the code - # where needed, so, fallback to tracing. - self.breakpoint_found = False - self.new_code = None - self.breakpoints_mtime = -1 - - -def dummy_trace_dispatch(frame, str event, arg): - if event == 'call': - if frame.f_trace is not None: - return frame.f_trace(frame, event, arg) - return None - - -def get_thread_info_py() -> ThreadInfo: - return get_thread_info(PyEval_GetFrame()) - - -cdef ThreadInfo get_thread_info(PyFrameObject * frame_obj): - ''' - Provides thread-related info. - - May return None if the thread is still not active. - ''' - cdef ThreadInfo thread_info - try: - # Note: changing to a `dict[thread.ident] = thread_info` had almost no - # effect in the performance. - thread_info = _thread_local_info.thread_info - except: - if frame_obj == NULL: - return None - thread_info = ThreadInfo() - thread_info.initialize(frame_obj) - thread_info.inside_frame_eval += 1 - try: - _thread_local_info.thread_info = thread_info - - # Note: _code_extra_index is not actually thread-related, - # but this is a good point to initialize it. - global _code_extra_index - if _code_extra_index == -1: - _code_extra_index = _PyEval_RequestCodeExtraIndex(release_co_extra) - - thread_info.initialize_if_possible() - finally: - thread_info.inside_frame_eval -= 1 - - return thread_info - - -def decref_py(obj): - ''' - Helper to be called from Python. - ''' - Py_DECREF(obj) - - -def get_func_code_info_py(thread_info, frame, code_obj) -> FuncCodeInfo: - ''' - Helper to be called from Python. - ''' - return get_func_code_info( thread_info, frame, code_obj) - - -cdef int _code_extra_index = -1 - -cdef FuncCodeInfo get_func_code_info(ThreadInfo thread_info, PyFrameObject * frame_obj, PyCodeObject * code_obj): - ''' - Provides code-object related info. - - Stores the gathered info in a cache in the code object itself. Note that - multiple threads can get the same info. - - get_thread_info() *must* be called at least once before get_func_code_info() - to initialize _code_extra_index. - - ''' - # f_code = code_obj - # DEBUG = f_code.co_filename.endswith('_debugger_case_multiprocessing.py') - # if DEBUG: - # print('get_func_code_info', f_code.co_name, f_code.co_filename) - - cdef object main_debugger = GlobalDebuggerHolder.global_dbg - thread_info.force_stay_in_untraced_mode = False # This is an output value of the function. - - cdef PyObject * extra - _PyCode_GetExtra( code_obj, _code_extra_index, & extra) - if extra is not NULL: - extra_obj = extra - if extra_obj is not NULL: - func_code_info_obj = extra_obj - if func_code_info_obj.breakpoints_mtime == main_debugger.mtime: - # if DEBUG: - # print('get_func_code_info: matched mtime', f_code.co_name, f_code.co_filename) - - return func_code_info_obj - - cdef str co_filename = code_obj.co_filename - cdef str co_name = code_obj.co_name - cdef dict cache_file_type - cdef tuple cache_file_type_key - - func_code_info = FuncCodeInfo() - func_code_info.breakpoints_mtime = main_debugger.mtime - - func_code_info.co_filename = co_filename - func_code_info.co_name = co_name - - if not func_code_info.always_skip_code: - try: - abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[co_filename] - except: - abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(frame_obj) - - func_code_info.canonical_normalized_filename = abs_path_real_path_and_base[1] - - cache_file_type = main_debugger.get_cache_file_type() - # Note: this cache key must be the same from PyDB.get_file_type() -- see it for comments - # on the cache. - cache_file_type_key = (frame_obj.f_code.co_firstlineno, abs_path_real_path_and_base[0], frame_obj.f_code) - try: - file_type = cache_file_type[cache_file_type_key] # Make it faster - except: - file_type = main_debugger.get_file_type(frame_obj, abs_path_real_path_and_base) # we don't want to debug anything related to pydevd - - if file_type is not None: - func_code_info.always_skip_code = True - - if not func_code_info.always_skip_code: - if main_debugger is not None: - - breakpoints: dict = main_debugger.breakpoints.get(func_code_info.canonical_normalized_filename) - function_breakpoint: object = main_debugger.function_breakpoint_name_to_breakpoint.get(func_code_info.co_name) - # print('\n---') - # print(main_debugger.breakpoints) - # print(func_code_info.canonical_normalized_filename) - # print(main_debugger.breakpoints.get(func_code_info.canonical_normalized_filename)) - code_obj_py: object = code_obj - cached_code_obj_info: object = _cache.get(code_obj_py) - if cached_code_obj_info: - # The cache is for new code objects, so, in this case it's already - # using the new code and we can't change it as this is a generator! - # There's still a catch though: even though we don't replace the code, - # we may not want to go into tracing mode (as would usually happen - # when the new_code is None). - func_code_info.new_code = None - breakpoint_found, thread_info.force_stay_in_untraced_mode = \ - cached_code_obj_info.compute_force_stay_in_untraced_mode(breakpoints) - func_code_info.breakpoint_found = breakpoint_found - - elif function_breakpoint: - # Go directly into tracing mode - func_code_info.breakpoint_found = True - func_code_info.new_code = None - - elif breakpoints: - # if DEBUG: - # print('found breakpoints', code_obj_py.co_name, breakpoints) - - # Note: new_code can be None if unable to generate. - # It should automatically put the new code object in the cache. - breakpoint_found, func_code_info.new_code = generate_code_with_breakpoints(code_obj_py, breakpoints) - func_code_info.breakpoint_found = breakpoint_found - - Py_INCREF(func_code_info) - _PyCode_SetExtra( code_obj, _code_extra_index, func_code_info) - - return func_code_info - - -cdef class _CodeLineInfo: - - cdef public dict line_to_offset - cdef public int first_line - cdef public int last_line - - def __init__(self, dict line_to_offset, int first_line, int last_line): - self.line_to_offset = line_to_offset - self.first_line = first_line - self.last_line = last_line - - -# Note: this method has a version in pure-python too. -def _get_code_line_info(code_obj): - line_to_offset: dict = {} - first_line: int = None - last_line: int = None - - cdef int offset - cdef int line - - for offset, line in dis.findlinestarts(code_obj): - line_to_offset[line] = offset - - if line_to_offset: - first_line = min(line_to_offset) - last_line = max(line_to_offset) - return _CodeLineInfo(line_to_offset, first_line, last_line) - - -# Note: this is a cache where the key is the code objects we create ourselves so that -# we always return the same code object for generators. -# (so, we don't have a cache from the old code to the new info -- that's actually -# handled by the cython side in `FuncCodeInfo get_func_code_info` by providing the -# same code info if the debugger mtime is still the same). -_cache: dict = {} - -def get_cached_code_obj_info_py(code_obj_py): - ''' - :return _CacheValue: - :note: on cython use _cache.get(code_obj_py) directly. - ''' - return _cache.get(code_obj_py) - - -cdef class _CacheValue(object): - - cdef public object code_obj_py - cdef public _CodeLineInfo code_line_info - cdef public set breakpoints_hit_at_lines - cdef public set code_lines_as_set - - def __init__(self, object code_obj_py, _CodeLineInfo code_line_info, set breakpoints_hit_at_lines): - ''' - :param code_obj_py: - :param _CodeLineInfo code_line_info: - :param set[int] breakpoints_hit_at_lines: - ''' - self.code_obj_py = code_obj_py - self.code_line_info = code_line_info - self.breakpoints_hit_at_lines = breakpoints_hit_at_lines - self.code_lines_as_set = set(code_line_info.line_to_offset) - - cpdef compute_force_stay_in_untraced_mode(self, breakpoints): - ''' - :param breakpoints: - set(breakpoint_lines) or dict(breakpoint_line->breakpoint info) - :return tuple(breakpoint_found, force_stay_in_untraced_mode) - ''' - cdef bint force_stay_in_untraced_mode - cdef bint breakpoint_found - cdef set target_breakpoints - - force_stay_in_untraced_mode = False - - target_breakpoints = self.code_lines_as_set.intersection(breakpoints) - breakpoint_found = bool(target_breakpoints) - - if not breakpoint_found: - force_stay_in_untraced_mode = True - else: - force_stay_in_untraced_mode = self.breakpoints_hit_at_lines.issuperset(set(breakpoints)) - - return breakpoint_found, force_stay_in_untraced_mode - -def generate_code_with_breakpoints_py(object code_obj_py, dict breakpoints): - return generate_code_with_breakpoints(code_obj_py, breakpoints) - -# DEBUG = True -# debug_helper = DebugHelper() - -cdef generate_code_with_breakpoints(object code_obj_py, dict breakpoints): - ''' - :param breakpoints: - dict where the keys are the breakpoint lines. - :return tuple(breakpoint_found, new_code) - ''' - # The cache is needed for generator functions, because after each yield a new frame - # is created but the former code object is used (so, check if code_to_modify is - # already there and if not cache based on the new code generated). - - cdef bint success - cdef int breakpoint_line - cdef bint breakpoint_found - cdef _CacheValue cache_value - cdef set breakpoints_hit_at_lines - cdef dict line_to_offset - - assert code_obj_py not in _cache, 'If a code object is cached, that same code object must be reused.' - -# if DEBUG: -# initial_code_obj_py = code_obj_py - - code_line_info = _get_code_line_info(code_obj_py) - - success = True - - breakpoints_hit_at_lines = set() - line_to_offset = code_line_info.line_to_offset - - for breakpoint_line in breakpoints: - if breakpoint_line in line_to_offset: - breakpoints_hit_at_lines.add(breakpoint_line) - - if breakpoints_hit_at_lines: - success, new_code = insert_pydevd_breaks( - code_obj_py, - breakpoints_hit_at_lines, - code_line_info - ) - - if not success: - code_obj_py = None - else: - code_obj_py = new_code - - breakpoint_found = bool(breakpoints_hit_at_lines) - if breakpoint_found and success: -# if DEBUG: -# op_number = debug_helper.write_dis( -# 'inserting code, breaks at: %s' % (list(breakpoints),), -# initial_code_obj_py -# ) -# -# debug_helper.write_dis( -# 'after inserting code, breaks at: %s' % (list(breakpoints,)), -# code_obj_py, -# op_number=op_number, -# ) - - cache_value = _CacheValue(code_obj_py, code_line_info, breakpoints_hit_at_lines) - _cache[code_obj_py] = cache_value - - return breakpoint_found, code_obj_py - -import sys - -cdef bint IS_PY_39_OWNARDS = sys.version_info[:2] >= (3, 9) - -def frame_eval_func(): - cdef PyThreadState *state = PyThreadState_Get() - if IS_PY_39_OWNARDS: - state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_39 - else: - state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_38 - dummy_tracing_holder.set_trace_func(dummy_trace_dispatch) - - -def stop_frame_eval(): - cdef PyThreadState *state = PyThreadState_Get() - state.interp.eval_frame = _PyEval_EvalFrameDefault - -# During the build we'll generate 2 versions of the code below so that we're compatible with -# Python 3.9, which receives a "PyThreadState* tstate" as the first parameter and Python 3.6-3.8 -# which doesn't. -### WARNING: GENERATED CODE, DO NOT EDIT! -### WARNING: GENERATED CODE, DO NOT EDIT! -### WARNING: GENERATED CODE, DO NOT EDIT! -cdef PyObject * get_bytecode_while_frame_eval_38(PyFrameObject * frame_obj, int exc): - ''' - This function makes the actual evaluation and changes the bytecode to a version - where programmatic breakpoints are added. - ''' - if GlobalDebuggerHolder is None or _thread_local_info is None or exc: - # Sometimes during process shutdown these global variables become None - return CALL_EvalFrameDefault_38(frame_obj, exc) - - # co_filename: str = frame_obj.f_code.co_filename - # if co_filename.endswith('threading.py'): - # return CALL_EvalFrameDefault_38(frame_obj, exc) - - cdef ThreadInfo thread_info - cdef int STATE_SUSPEND = 2 - cdef int CMD_STEP_INTO = 107 - cdef int CMD_STEP_OVER = 108 - cdef int CMD_STEP_OVER_MY_CODE = 159 - cdef int CMD_STEP_INTO_MY_CODE = 144 - cdef int CMD_STEP_INTO_COROUTINE = 206 - cdef int CMD_SMART_STEP_INTO = 128 - cdef bint can_skip = True - try: - thread_info = _thread_local_info.thread_info - except: - thread_info = get_thread_info(frame_obj) - if thread_info is None: - return CALL_EvalFrameDefault_38(frame_obj, exc) - - if thread_info.inside_frame_eval: - return CALL_EvalFrameDefault_38(frame_obj, exc) - - if not thread_info.fully_initialized: - thread_info.initialize_if_possible() - if not thread_info.fully_initialized: - return CALL_EvalFrameDefault_38(frame_obj, exc) - - # Can only get additional_info when fully initialized. - cdef PyDBAdditionalThreadInfo additional_info = thread_info.additional_info - if thread_info.is_pydevd_thread or additional_info.is_tracing: - # Make sure that we don't trace pydevd threads or inside our own calls. - return CALL_EvalFrameDefault_38(frame_obj, exc) - - # frame = frame_obj - # DEBUG = frame.f_code.co_filename.endswith('_debugger_case_tracing.py') - # if DEBUG: - # print('get_bytecode_while_frame_eval', frame.f_lineno, frame.f_code.co_name, frame.f_code.co_filename) - - thread_info.inside_frame_eval += 1 - additional_info.is_tracing = True - try: - main_debugger: object = GlobalDebuggerHolder.global_dbg - if main_debugger is None: - return CALL_EvalFrameDefault_38(frame_obj, exc) - frame = frame_obj - - if thread_info.thread_trace_func is None: - trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) - if apply_to_global: - thread_info.thread_trace_func = trace_func - - if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ - main_debugger.break_on_caught_exceptions or \ - main_debugger.break_on_user_uncaught_exceptions or \ - main_debugger.has_plugin_exception_breaks or \ - main_debugger.signature_factory or \ - additional_info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE) and main_debugger.show_return_values and frame.f_back is additional_info.pydev_step_stop: - - # if DEBUG: - # print('get_bytecode_while_frame_eval enabled trace') - if thread_info.thread_trace_func is not None: - frame.f_trace = thread_info.thread_trace_func - else: - frame.f_trace = main_debugger.trace_dispatch - else: - func_code_info: FuncCodeInfo = get_func_code_info(thread_info, frame_obj, frame_obj.f_code) - # if DEBUG: - # print('get_bytecode_while_frame_eval always skip', func_code_info.always_skip_code) - if not func_code_info.always_skip_code: - - if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: - can_skip = main_debugger.plugin.can_skip(main_debugger, frame_obj) - - if not can_skip: - # if DEBUG: - # print('get_bytecode_while_frame_eval not can_skip') - if thread_info.thread_trace_func is not None: - frame.f_trace = thread_info.thread_trace_func - else: - frame.f_trace = main_debugger.trace_dispatch - - if can_skip and func_code_info.breakpoint_found: - # if DEBUG: - # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) - if not thread_info.force_stay_in_untraced_mode: - # If breakpoints are found but new_code is None, - # this means we weren't able to actually add the code - # where needed, so, fallback to tracing. - if func_code_info.new_code is None: - if thread_info.thread_trace_func is not None: - frame.f_trace = thread_info.thread_trace_func - else: - frame.f_trace = main_debugger.trace_dispatch - else: - # print('Using frame eval break for', frame_obj.f_code.co_name) - update_globals_dict( frame_obj.f_globals) - Py_INCREF(func_code_info.new_code) - old = frame_obj.f_code - frame_obj.f_code = func_code_info.new_code - Py_DECREF(old) - else: - # When we're forcing to stay in traced mode we need to - # update the globals dict (because this means that we're reusing - # a previous code which had breakpoints added in a new frame). - update_globals_dict( frame_obj.f_globals) - - finally: - thread_info.inside_frame_eval -= 1 - additional_info.is_tracing = False - - return CALL_EvalFrameDefault_38(frame_obj, exc) -### WARNING: GENERATED CODE, DO NOT EDIT! -### WARNING: GENERATED CODE, DO NOT EDIT! -### WARNING: GENERATED CODE, DO NOT EDIT! - - -### WARNING: GENERATED CODE, DO NOT EDIT! -### WARNING: GENERATED CODE, DO NOT EDIT! -### WARNING: GENERATED CODE, DO NOT EDIT! -cdef PyObject * get_bytecode_while_frame_eval_39(PyThreadState* tstate, PyFrameObject * frame_obj, int exc): - ''' - This function makes the actual evaluation and changes the bytecode to a version - where programmatic breakpoints are added. - ''' - if GlobalDebuggerHolder is None or _thread_local_info is None or exc: - # Sometimes during process shutdown these global variables become None - return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) - - # co_filename: str = frame_obj.f_code.co_filename - # if co_filename.endswith('threading.py'): - # return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) - - cdef ThreadInfo thread_info - cdef int STATE_SUSPEND = 2 - cdef int CMD_STEP_INTO = 107 - cdef int CMD_STEP_OVER = 108 - cdef int CMD_STEP_OVER_MY_CODE = 159 - cdef int CMD_STEP_INTO_MY_CODE = 144 - cdef int CMD_STEP_INTO_COROUTINE = 206 - cdef int CMD_SMART_STEP_INTO = 128 - cdef bint can_skip = True - try: - thread_info = _thread_local_info.thread_info - except: - thread_info = get_thread_info(frame_obj) - if thread_info is None: - return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) - - if thread_info.inside_frame_eval: - return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) - - if not thread_info.fully_initialized: - thread_info.initialize_if_possible() - if not thread_info.fully_initialized: - return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) - - # Can only get additional_info when fully initialized. - cdef PyDBAdditionalThreadInfo additional_info = thread_info.additional_info - if thread_info.is_pydevd_thread or additional_info.is_tracing: - # Make sure that we don't trace pydevd threads or inside our own calls. - return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) - - # frame = frame_obj - # DEBUG = frame.f_code.co_filename.endswith('_debugger_case_tracing.py') - # if DEBUG: - # print('get_bytecode_while_frame_eval', frame.f_lineno, frame.f_code.co_name, frame.f_code.co_filename) - - thread_info.inside_frame_eval += 1 - additional_info.is_tracing = True - try: - main_debugger: object = GlobalDebuggerHolder.global_dbg - if main_debugger is None: - return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) - frame = frame_obj - - if thread_info.thread_trace_func is None: - trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) - if apply_to_global: - thread_info.thread_trace_func = trace_func - - if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ - main_debugger.break_on_caught_exceptions or \ - main_debugger.break_on_user_uncaught_exceptions or \ - main_debugger.has_plugin_exception_breaks or \ - main_debugger.signature_factory or \ - additional_info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE) and main_debugger.show_return_values and frame.f_back is additional_info.pydev_step_stop: - - # if DEBUG: - # print('get_bytecode_while_frame_eval enabled trace') - if thread_info.thread_trace_func is not None: - frame.f_trace = thread_info.thread_trace_func - else: - frame.f_trace = main_debugger.trace_dispatch - else: - func_code_info: FuncCodeInfo = get_func_code_info(thread_info, frame_obj, frame_obj.f_code) - # if DEBUG: - # print('get_bytecode_while_frame_eval always skip', func_code_info.always_skip_code) - if not func_code_info.always_skip_code: - - if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: - can_skip = main_debugger.plugin.can_skip(main_debugger, frame_obj) - - if not can_skip: - # if DEBUG: - # print('get_bytecode_while_frame_eval not can_skip') - if thread_info.thread_trace_func is not None: - frame.f_trace = thread_info.thread_trace_func - else: - frame.f_trace = main_debugger.trace_dispatch - - if can_skip and func_code_info.breakpoint_found: - # if DEBUG: - # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) - if not thread_info.force_stay_in_untraced_mode: - # If breakpoints are found but new_code is None, - # this means we weren't able to actually add the code - # where needed, so, fallback to tracing. - if func_code_info.new_code is None: - if thread_info.thread_trace_func is not None: - frame.f_trace = thread_info.thread_trace_func - else: - frame.f_trace = main_debugger.trace_dispatch - else: - # print('Using frame eval break for', frame_obj.f_code.co_name) - update_globals_dict( frame_obj.f_globals) - Py_INCREF(func_code_info.new_code) - old = frame_obj.f_code - frame_obj.f_code = func_code_info.new_code - Py_DECREF(old) - else: - # When we're forcing to stay in traced mode we need to - # update the globals dict (because this means that we're reusing - # a previous code which had breakpoints added in a new frame). - update_globals_dict( frame_obj.f_globals) - - finally: - thread_info.inside_frame_eval -= 1 - additional_info.is_tracing = False - - return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) -### WARNING: GENERATED CODE, DO NOT EDIT! -### WARNING: GENERATED CODE, DO NOT EDIT! -### WARNING: GENERATED CODE, DO NOT EDIT! -