eric: comparison DebugClients/Python3/BreakpointWatch.py

-:fb9168c2e069
+:8c48f5e0cd92
 """
 breaks = {}     # indexed by (filename, lineno) tuple: Breakpoint
 breakInFile = {}  # indexed by filename: [lineno]
 breakInFrameCache = {}
-def __init__(self, filename, lineno, temporary=0, cond=None):
+def __init__(self, filename, lineno, temporary=False, cond=None):
 """
 Constructor
-@param filename the filename where a breakpoint is set
+@param filename file name where a breakpoint is set
 @type str
-@param lineno the line number of the breakpoint
+@param lineno line number of the breakpoint
 @type int
 @keyparam temporary flag to indicate a temporary breakpoint
-@type int
+@type bool
 @keyparam cond Python expression which dynamically enables this bp
 @type str
 """
 filename = os.path.abspath(filename)
 self.file = filename
 self.line = lineno
 self.temporary = temporary
 self.cond = cond
-self.enabled = 1
+self.enabled = True
 self.ignore = 0
 self.hits = 0
 self.breaks[filename, lineno] = self
 lines = self.breakInFile.setdefault(filename, [])
 if lineno not in lines:
 def enable(self):
 """
 Public method to enable this breakpoint.
 """
-self.enabled = 1
+self.enabled = True
 def disable(self):
 """
 Public method to disable this breakpoint.
 """
-self.enabled = 0
+self.enabled = False
 @staticmethod
 def clear_break(filename, lineno):
 """
 Public method reimplemented from bdb.py to clear a breakpoint.
-@param filename the filename of the bp to retrieve
+@param filename file name of the bp to retrieve
 @type str
-@param lineno the linenumber of the bp to retrieve
+@param lineno line number of the bp to retrieve
 @type int
 """
 bp = Breakpoint.breaks.get((filename, lineno))
 if bp:
 bp.deleteMe()
 Public method to get the breakpoint of a particular line.
 Because eric6 supports only one breakpoint per line, this
 method will return only one breakpoint.
-@param filename the filename of the bp to retrieve
+@param filename file name of the bp to retrieve
 @type str
-@param lineno the linenumber of the bp to retrieve
+@param lineno line number of the bp to retrieve
 @type int
 @return Breakpoint or None, if there is no bp
 @rtype Breakpoint object or None
 """
 return Breakpoint.breaks.get((filename, lineno))
 Called only if we know there is a bpt at this
 location.  Returns breakpoint that was triggered and a flag
 that indicates if it is ok to delete a temporary bp.
-@param filename the filename of the bp to retrieve
+@param filename file name of the bp to retrieve
 @type str
-@param lineno the linenumber of the bp to retrieve
+@param lineno line number of the bp to retrieve
 @type int
 @param frame the current execution frame
 @type frame object
 @return tuple of Breakpoint and a flag to indicate, that a
 temporary breakpoint may be deleted
 @rtype tuple of Breakpoint, bool
 """
 b = Breakpoint.breaks[filename, lineno]
-if b.enabled == 0:
+if not b.enabled:
-return (None, 0)
+return (None, False)
 # Count every hit when bp is enabled
 b.hits += 1
 if not b.cond:
 # If unconditional, and ignoring,
 # go on to next, else break
 if b.ignore > 0:
 b.ignore -= 1
-return (None, 0)
+return (None, False)
 else:
 # breakpoint and marker that's ok
 # to delete if temporary
-return (b, 1)
+return (b, True)
 else:
 # Conditional bp.
 # Ignore count applies only to those bpt hits where the
 # condition evaluates to true.
 try:
 if val:
 if b.ignore > 0:
 b.ignore -= 1
 # continue
 else:
-return (b, 1)
+return (b, True)
 # else:
 #   continue
 except Exception:
 # if eval fails, most conservative
 # thing is to stop on breakpoint
 # regardless of ignore count.
 # Don't delete temporary,
 # as another hint to user.
-return (b, 0)
+return (b, False)
-return (None, 0)
+return (None, False)
 class Watch:
 """
 Watch class.
 Implements temporary watches, ignore counts, disabling and
 (re)-enabling, and conditionals.
 """
 watches = []
-def __init__(self, cond, compiledCond, flag, temporary=0):
+def __init__(self, cond, compiledCond, flag, temporary=False):
 """
 Constructor
 @param cond condition as string with flag
 @type str
 @param compiledCond precompiled condition
 @type code object
 @param flag indicates type of watch (created or changed)
 @type str
 @keyparam temporary flag for temporary watches
-@type int
+@type bool
 """
 # Should not occur
 if not cond:
 return
 self.cond = cond
 self.compiledCond = compiledCond
 self.temporary = temporary
-self.enabled = 1
+self.enabled = True
 self.ignore = 0
 self.created = False
 self.changed = False
 if flag == '??created??':
 def enable(self):
 """
 Public method to enable this watch.
 """
-self.enabled = 1
+self.enabled = True
 def disable(self):
 """
 Public method to disable this watch.
 """
-self.enabled = 0
+self.enabled = False
 @staticmethod
 def clear_watch(cond):
 """
 Public method to clear a watch expression.
 @return tuple of watch expression and a flag to indicate, that a
 temporary watch expression may be deleted
 @rtype tuple of Watch, int
 """
 for b in Watch.watches:
-if b.enabled == 0:
+if not b.enabled:
 continue
 try:
 val = eval(b.compiledCond, frame.f_globals, frame.f_locals)
 if b.created:
 if frame in b.values:
 continue
 else:
 b.values[frame] = [1, val, b.ignore]
-return (b, 1)
+return (b, True)
 elif b.changed:
 try:
 if b.values[frame][1] != val:
 b.values[frame][1] = val
 if b.values[frame][2] > 0:
 b.values[frame][2] -= 1
 continue
 else:
-return (b, 1)
+return (b, True)
 elif val:
 if b.ignore > 0:
 b.ignore -= 1
 continue
 else:
-return (b, 1)
+return (b, True)
 except Exception:
 continue
-return (None, 0)
+return (None, False)
 #
 # eflag: noqa = M702

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python3/BreakpointWatch.py

DebugClients/Python3/BreakpointWatch.py