From 5dabc5fa75e8197c94ef511f63bf3702791df481 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 5 Sep 2014 05:00:13 +0200 Subject: [PATCH] Remove unused code. --- python/helpers/pydev/django_debug.py | 124 ------------------------- python/helpers/pydev/django_frame.py | 132 --------------------------- python/helpers/pydev/pydevd.py | 4 +- python/helpers/pydev/pydevd_frame.py | 70 +------------- python/helpers/pydev/pydevd_vars.py | 9 +- 5 files changed, 9 insertions(+), 330 deletions(-) delete mode 100644 python/helpers/pydev/django_debug.py delete mode 100644 python/helpers/pydev/django_frame.py diff --git a/python/helpers/pydev/django_debug.py b/python/helpers/pydev/django_debug.py deleted file mode 100644 index 2b17864db47e..000000000000 --- a/python/helpers/pydev/django_debug.py +++ /dev/null @@ -1,124 +0,0 @@ -import inspect -from django_frame import DjangoTemplateFrame -from pydevd_comm import CMD_SET_BREAK -from pydevd_constants import DJANGO_SUSPEND, GetThreadId, DictContains -from pydevd_file_utils import NormFileToServer -from pydevd_breakpoints import LineBreakpoint -import pydevd_vars -import traceback - -class DjangoLineBreakpoint(LineBreakpoint): - - def __init__(self, file, line, condition, func_name, expression): - self.file = file - LineBreakpoint.__init__(self, line, condition, func_name, expression) - - def is_triggered(self, template_frame_file, template_frame_line): - return self.file == template_frame_file and self.line == template_frame_line - - def __str__(self): - return "DjangoLineBreakpoint: %s-%d" %(self.file, self.line) - - -def inherits(cls, *names): - if cls.__name__ in names: - return True - inherits_node = False - for base in inspect.getmro(cls): - if base.__name__ in names: - inherits_node = True - break - return inherits_node - - -def is_django_render_call(frame): - try: - name = frame.f_code.co_name - if name != 'render': - return False - - if not DictContains(frame.f_locals, 'self'): - return False - - cls = frame.f_locals['self'].__class__ - - inherits_node = inherits(cls, 'Node') - - if not inherits_node: - return False - - clsname = cls.__name__ - return clsname != 'TextNode' and clsname != 'NodeList' - except: - traceback.print_exc() - return False - - -def is_django_context_get_call(frame): - try: - if not DictContains(frame.f_locals, 'self'): - return False - - cls = frame.f_locals['self'].__class__ - - return inherits(cls, 'BaseContext') - except: - traceback.print_exc() - return False - - -def is_django_resolve_call(frame): - try: - name = frame.f_code.co_name - if name != '_resolve_lookup': - return False - - if not DictContains(frame.f_locals, 'self'): - return False - - cls = frame.f_locals['self'].__class__ - - clsname = cls.__name__ - return clsname == 'Variable' - except: - traceback.print_exc() - return False - - -def is_django_suspended(thread): - return thread.additionalInfo.suspend_type == DJANGO_SUSPEND - - -def suspend_django(py_db_frame, mainDebugger, thread, frame, cmd=CMD_SET_BREAK): - frame = DjangoTemplateFrame(frame) - - if frame.f_lineno is None: - return None - - #try: - # if thread.additionalInfo.filename == frame.f_code.co_filename and thread.additionalInfo.line == frame.f_lineno: - # return None # don't stay twice on the same line - #except AttributeError: - # pass - - pydevd_vars.addAdditionalFrameById(GetThreadId(thread), {id(frame): frame}) - - py_db_frame.setSuspend(thread, cmd) - thread.additionalInfo.suspend_type = DJANGO_SUSPEND - - thread.additionalInfo.filename = frame.f_code.co_filename - thread.additionalInfo.line = frame.f_lineno - - return frame - - -def find_django_render_frame(frame): - while frame is not None and not is_django_render_call(frame): - frame = frame.f_back - - return frame - - - - - diff --git a/python/helpers/pydev/django_frame.py b/python/helpers/pydev/django_frame.py deleted file mode 100644 index 4181572aed3c..000000000000 --- a/python/helpers/pydev/django_frame.py +++ /dev/null @@ -1,132 +0,0 @@ -from pydevd_file_utils import GetFileNameAndBaseFromFile -import pydev_log -import traceback -from pydevd_constants import DictContains - -def read_file(filename): - f = open(filename, "r") - try: - s = f.read() - finally: - f.close() - return s - - -def offset_to_line_number(text, offset): - curLine = 1 - curOffset = 0 - while curOffset < offset: - if curOffset == len(text): - return -1 - c = text[curOffset] - if c == '\n': - curLine += 1 - elif c == '\r': - curLine += 1 - if curOffset < len(text) and text[curOffset + 1] == '\n': - curOffset += 1 - - curOffset += 1 - - return curLine - - -def get_source(frame): - try: - node = frame.f_locals['self'] - if hasattr(node, 'source'): - return node.source - else: - pydev_log.error_once( - "WARNING: Template path is not available. Please set TEMPLATE_DEBUG=True " - "in your settings.py to make django template breakpoints working") - return None - - except: - pydev_log.debug(traceback.format_exc()) - return None - - -def get_template_file_name(frame): - try: - source = get_source(frame) - if source is None: - pydev_log.debug("Source is None\n") - return None - fname = source[0].name - - if fname == '': - pydev_log.debug("Source name is %s\n" % fname) - return None - else: - filename, base = GetFileNameAndBaseFromFile(fname) - return filename - except: - pydev_log.debug(traceback.format_exc()) - return None - - -def get_template_line(frame, template_frame_file): - source = get_source(frame) - try: - return offset_to_line_number(read_file(template_frame_file), source[1][0]) - except: - return None - - -class DjangoTemplateFrame: - def __init__( - self, - frame, - template_frame_file=None, - template_frame_line=None): - - if template_frame_file is None: - template_frame_file = get_template_file_name(frame) - - self.back_context = frame.f_locals['context'] - self.f_code = FCode('Django Template', template_frame_file) - - if template_frame_line is None: - template_frame_line = get_template_line(frame, template_frame_file) - self.f_lineno = template_frame_line - - self.f_back = frame - self.f_globals = {} - self.f_locals = self.collect_context() - self.f_trace = None - - def collect_context(self): - res = {} - try: - for d in self.back_context.dicts: - res.update(d) - except AttributeError: - pass - return res - - def changeVariable(self, name, value): - for d in self.back_context.dicts: - if DictContains(d, name): - d[name] = value - self.f_locals[name] = value - - -class FCode: - def __init__(self, name, filename): - self.co_name = name - self.co_filename = filename - - -def is_django_exception_break_context(frame): - try: - return frame.f_code.co_name in ['_resolve_lookup', 'find_template'] - except: - return False - - -def just_raised(trace): - if trace is None: - return False - return trace.tb_next is None - diff --git a/python/helpers/pydev/pydevd.py b/python/helpers/pydev/pydevd.py index c0a3d3723ba9..d4b2ef937ebc 100644 --- a/python/helpers/pydev/pydevd.py +++ b/python/helpers/pydev/pydevd.py @@ -119,7 +119,7 @@ DONT_TRACE = { '_pydev_threading':1, '_pydev_Queue':1, 'django_debug.py':1, - 'django_frame.py':1, + 'jinja2_debug.py':1, 'pydev_log.py':1, 'pydev_monkey.py':1 , 'pydevd.py':1 , @@ -304,7 +304,6 @@ class PyDB: self._cmd_queue = {} # the hash of Queues. Key is thread id, value is thread self.breakpoints = {} - #self.django_breakpoints = {} self.file_to_id_to_line_breakpoint = {} self.file_to_id_to_plugin_breakpoint = {} @@ -314,7 +313,6 @@ class PyDB: self.break_on_uncaught_exceptions = {} self.break_on_caught_exceptions = {} - self.django_exception_break = {} self.readyToRun = False self._main_lock = _pydev_thread.allocate_lock() self._lock_running_thread_ids = _pydev_thread.allocate_lock() diff --git a/python/helpers/pydev/pydevd_frame.py b/python/helpers/pydev/pydevd_frame.py index 704d77b3ca38..93b5cb2e1620 100644 --- a/python/helpers/pydev/pydevd_frame.py +++ b/python/helpers/pydev/pydevd_frame.py @@ -3,20 +3,14 @@ import os.path import re import traceback # @Reimport -from django_debug import find_django_render_frame -from django_debug import is_django_render_call, is_django_suspended, suspend_django, is_django_resolve_call, is_django_context_get_call -from django_frame import DjangoTemplateFrame -from django_frame import is_django_exception_break_context -from django_frame import just_raised, get_template_file_name, get_template_line import pydev_log from pydevd_breakpoints import get_exception_breakpoint, get_exception_name -from pydevd_comm import CMD_ADD_DJANGO_EXCEPTION_BREAK, \ - CMD_STEP_CAUGHT_EXCEPTION, CMD_STEP_RETURN, CMD_STEP_OVER, CMD_SET_BREAK, \ +from pydevd_comm import CMD_STEP_CAUGHT_EXCEPTION, CMD_STEP_RETURN, CMD_STEP_OVER, CMD_SET_BREAK, \ CMD_STEP_INTO, CMD_SMART_STEP_INTO, CMD_RUN_TO_LINE, CMD_SET_NEXT_STATEMENT from pydevd_constants import * # @UnusedWildImport from pydevd_file_utils import GetFilenameAndBase -from pydev_frame_utils import add_exception_to_frame +from pydevd_frame_utils import add_exception_to_frame try: from pydevd_signature import sendSignatureCallTrace except ImportError: @@ -57,7 +51,7 @@ class PyDBFrame: def doWaitSuspend(self, *args, **kwargs): self._args[0].doWaitSuspend(*args, **kwargs) - def _is_django_render_call(self, frame): + def _is_django_render_call(self, frame): # todo: cache in plugins the same way try: return self._cached_is_django_render_call except: @@ -387,8 +381,6 @@ class PyDBFrame: #step handling. We stop when we hit the right frame try: - stop_info['django_stop'] = False - should_skip = False if pydevd_dont_trace.should_trace_hook is not None: if not hasattr(self, 'should_skip'): @@ -511,58 +503,4 @@ class PyDBFrame: except ImportError: if hasattr(sys, 'exc_clear'): #jython does not have it sys.exc_clear() #don't keep the traceback - pass #ok, psyco not available - - def should_stop_on_django_breakpoint(self, frame, event, arg): - mainDebugger = self._args[0] - thread = self._args[3] - flag = False - template_frame_file = get_template_file_name(frame) - - #pydev_log.debug("Django is rendering a template: %s\n" % template_frame_file) - - django_breakpoints_for_file = mainDebugger.django_breakpoints.get(template_frame_file) - if django_breakpoints_for_file: - - #pydev_log.debug("Breakpoints for that file: %s\n" % django_breakpoints_for_file) - - template_frame_line = get_template_line(frame, template_frame_file) - - #pydev_log.debug("Tracing template line: %d\n" % template_frame_line) - - if DictContains(django_breakpoints_for_file, template_frame_line): - django_breakpoint = django_breakpoints_for_file[template_frame_line] - - if django_breakpoint.is_triggered(template_frame_file, template_frame_line): - - #pydev_log.debug("Breakpoint is triggered.\n") - - flag = True - new_frame = DjangoTemplateFrame( - frame, - template_frame_file=template_frame_file, - template_frame_line=template_frame_line, - ) - - if django_breakpoint.condition is not None: - try: - val = eval(django_breakpoint.condition, new_frame.f_globals, new_frame.f_locals) - if not val: - flag = False - pydev_log.debug("Condition '%s' is evaluated to %s. Not suspending.\n" % (django_breakpoint.condition, val)) - except: - pydev_log.info( - 'Error while evaluating condition \'%s\': %s\n' % (django_breakpoint.condition, sys.exc_info()[1])) - - if django_breakpoint.expression is not None: - try: - try: - val = eval(django_breakpoint.expression, new_frame.f_globals, new_frame.f_locals) - except: - val = sys.exc_info()[1] - finally: - if val is not None: - thread.additionalInfo.message = val - if flag: - frame = suspend_django(self, mainDebugger, thread, frame) - return flag, frame + pass #ok, psyco not available \ No newline at end of file diff --git a/python/helpers/pydev/pydevd_vars.py b/python/helpers/pydev/pydevd_vars.py index 3baea5b61b99..655449f36be7 100644 --- a/python/helpers/pydev/pydevd_vars.py +++ b/python/helpers/pydev/pydevd_vars.py @@ -2,7 +2,6 @@ resolution/conversion to XML. """ import pickle -from django_frame import DjangoTemplateFrame from pydevd_constants import * #@UnusedWildImport from types import * #@UnusedWildImport @@ -360,10 +359,10 @@ def changeAttrExpression(thread_id, frame_id, attr, expression): try: expression = expression.replace('@LINE@', '\n') - if isinstance(frame, DjangoTemplateFrame): - result = eval(expression, frame.f_globals, frame.f_locals) - frame.changeVariable(attr, result) - return + # if isinstance(frame, DjangoTemplateFrame): # TODO: implemente for plugins + # result = eval(expression, frame.f_globals, frame.f_locals) + # frame.changeVariable(attr, result) + # return if attr[:7] == "Globals": attr = attr[8:]