mwxlib 1.0.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

mwx/wxpdb.py

@@ -27,17 +27,18 @@ echo.verbose = 0
 
 
 class Debugger(Pdb):
-    """Graphical debugger with extended Pdb
+    """Graphical debugger with extended Pdb.
     
     Args:
-        parent  : shellframe
-        stdin   : shell.interp.stdin
-        stdout  : shell.interp.stdout
+        parent: shellframe
+        stdin:  shell.interp.stdin
+        stdout: shell.interp.stdout
     
     Attributes:
-        editor  : Notebook to show the stack frames
+        editor: Notebook to show the stack frames
+    
+    Key bindings::
     
-    Key bindings:
         C-g     : quit
         C-q     : quit
         C-n     : next   (step-over)
@@ -46,27 +47,26 @@ class Debugger(Pdb):
         C-b     : Set a breakpoint at the current line.
         C-@     : Jump to the first lineno of the code.
         C-S-j   : Jump to the lineno of the code.
-        C-S-b   : Continue execution until the lineno of the code.
+        C-S-n   : Continue execution until the lineno of the code.
         C-w     : Stamp current where(frame) message.
     """
     verbose = False
     use_rawinput = False
     prompt = property(lambda self: self.indents + '(Pdb) ',
-                      lambda self,v: None) # fake setter
-    parent = property(lambda self: self.__shellframe)
+                      lambda self, v: None)  # fake setter
     handler = property(lambda self: self.__handler)
-    
+
     @property
     def interactive_shell(self):
         return self.__shell
-    
+
     @interactive_shell.setter
     def interactive_shell(self, v):
         self.__shell = v
-        ## Don't use rawinput
+        ## Don't use rawinput.
         self.stdin = self.__shell.interp.stdin
         self.stdout = self.__shell.interp.stdout
-    
+
     @property
     def busy(self):
         """Indicates that the current state is debug mode.
@@ -79,39 +79,39 @@ class Debugger(Pdb):
             return self.curframe is not None
         except AttributeError:
             pass
-    
+
     @property
     def tracing(self):
         """Indicates that the current state is trace mode.
         """
         ## cf. (self.handler.current_state == 2)
         return self.__hookpoint is not None
-    
+
     def __init__(self, parent, *args, **kwargs):
         Pdb.__init__(self, *args, **kwargs)
         
-        self.__shellframe = parent
-        self.__hookpoint = None
+        self.parent = parent
         self.indents = ' ' * 2
         self.interactive_shell = parent.rootshell
         self.editor = None
         self.code = None
+        self.__hookpoint = None
         
         def _input(msg):
-            ## redirects input such as cl(ear)
+            ## Redirects input such as cl(ear).
             self.message(msg, indent=0)
             return self.stdin.readline()
         pdb.input = _input
         
         def _help():
-            self.parent.handler('add_help', pdb.__doc__)
+            self.parent.handler('add_help', pdb.__doc__, "pdb")
         pdb.help = _help
         
         def dispatch(evt):
             """Fork events to the parent."""
             self.parent.handler(self.handler.current_event, evt)
         
-        self.__handler = FSM({ # DNA<Debugger>
+        self.__handler = FSM({  # DNA<Debugger>
             0 : {
                   'debug_begin' : (1, self.on_debug_begin, dispatch),
                   'trace_begin' : (2, dispatch),
@@ -129,7 +129,7 @@ class Debugger(Pdb):
                   'C-b pressed' : (1, lambda v: self.set_breakpoint()),
                   'C-@ pressed' : (1, lambda v: self.jump_to_entry()),
                 'C-S-j pressed' : (1, lambda v: self.jump_to_lineno()),
-                'C-S-b pressed' : (1, lambda v: self.exec_until_lineno()),
+                'C-S-n pressed' : (1, lambda v: self.exec_until_lineno()),
                   'C-w pressed' : (1, lambda v: self.stamp_where()),
             },
             2 : {
@@ -138,26 +138,26 @@ class Debugger(Pdb):
                   'debug_begin' : (1, self.on_debug_begin, dispatch),
             },
         })
-    
+
     def set_breakpoint(self):
         """Set a breakpoint at the current line."""
         filename = self.curframe.f_code.co_filename
         ln = self.editor.buffer.cline + 1
         if ln not in self.get_file_breaks(filename):
             self.send_input('b {}'.format(ln), echo=True)
-    
+
     def jump_to_entry(self):
         """Jump to the first lineno of the code."""
         ln = self.editor.buffer.markline + 1
         if ln:
             self.send_input('j {}'.format(ln), echo=True)
-    
+
     def jump_to_lineno(self):
         """Jump to the lineno of the code."""
         ln = self.editor.buffer.cline + 1
         if ln:
             self.send_input('j {}'.format(ln), echo=True)
-    
+
     def exec_until_lineno(self):
         """Continue execution until the lineno of the code."""
         frame = self.curframe
@@ -170,14 +170,14 @@ class Debugger(Pdb):
             self.message("--> {}:{}:{}".format(filename, ln, name), indent=0)
         else:
             self.stamp_where()
-    
+
     def stamp_where(self):
         """Stamp current where(frame) message."""
         ## cf. (print_stack_entry for frame in self.stack)
         self.send_input('w')
         if not self.verbose:
             self.message("--> {}".format(where(self.curframe)), indent=0)
-    
+
     def send_input(self, c, echo=False):
         """Send input:str (echo message if needed)."""
         def _send():
@@ -185,41 +185,41 @@ class Debugger(Pdb):
             if echo or self.verbose:
                 self.message(c, indent=0)
         wx.CallAfter(_send)
-    
+
     def message(self, msg, indent=True):
         """Add prefix and insert msg at the end of command-line."""
         shell = self.interactive_shell
         shell.goto_char(shell.eolc)
         prefix = self.indents if indent else ''
         print("{}{}".format(prefix, msg), file=self.stdout)
-    
+
     def watch(self, bp):
         """Start tracing."""
-        if self.busy: # don't set while debugging
+        if self.busy:  # don't set while debugging
             return
         self.__hookpoint = bp
         self.reset()
         sys.settrace(self.trace_dispatch)
         threading.settrace(self.trace_dispatch)
         self.handler('trace_begin', bp)
-    
+
     def unwatch(self):
         """End tracing."""
-        if self.busy: # don't unset while debugging
+        if self.busy:  # don't unset while debugging
             return
         bp = self.__hookpoint
         self.reset()
         sys.settrace(None)
         threading.settrace(None)
-        ## delete bp *after* setting dispatcher -> None
+        ## Delete bp *after* setting dispatcher -> None.
         self.__hookpoint = None
         if bp:
             self.handler('trace_end', bp)
         else:
-            ## Called to abort when the debugger is invalid status:
-            ## e.g., (self.handler.current_state > 0 but not busy)
+            ## Called to abort when the debugger is invalid status.
+            ## e.g., (self.handler.current_state > 0 but not busy).
             self.handler('abort')
-    
+
     def debug(self, obj, *args, **kwargs):
         """Debug a callable object.
         """
@@ -241,11 +241,10 @@ class Debugger(Pdb):
         except Exception as e:
             ## Note: post-call to avoid crashing by a kill-focus event.
             wx.CallAfter(wx.MessageBox,
-                         f"Debugger is closed.\n\n{e}")
+                         f"Debugger has been closed.\n\n{e}")
         finally:
             self.set_quit()
-            return
-    
+
     def run(self, cmd, filename="<string>"):
         """Debug a statement executed via the exec() function.
         """
@@ -268,34 +267,33 @@ class Debugger(Pdb):
         except Exception as e:
             ## Note: post-call to avoid crashing by a kill-focus event.
             wx.CallAfter(wx.MessageBox,
-                         f"Debugger is closed.\n\n{e}")
+                         f"Debugger has been closed.\n\n{e}")
         finally:
             self.set_quit()
-            return
-    
+
     ## --------------------------------
-    ## Actions for handler
+    ## Actions for handler.
     ## --------------------------------
-    
+
     def _markbp(self, lineno, style):
         """Add a marker to lineno, with the following style markers:
-        [1] white-arrow for breakpoints
-        [2] red-arrow for exception
+        [1] white_arrow for breakpoints
+        [2] red_arrow for exceptions
         """
         if self.editor:
             if lineno:
                 self.editor.buffer.MarkerAdd(lineno - 1, style)
             else:
                 self.editor.buffer.MarkerDeleteAll(style)
-    
+
     def on_debug_begin(self, frame):
         """Called before set_trace.
         Note: self.busy -> False or None
         """
         self.__hookpoint = None
         self.indents = ' ' * 2
-        self.stdin.input = '' # clear stdin buffer
-    
+        self.stdin.input = ''  # clear stdin buffer
+
     def on_debug_mark(self, frame):
         """Called when interaction."""
         code = frame.f_code
@@ -307,8 +305,8 @@ class Debugger(Pdb):
             module = import_module(m.group(1))
             filename = inspect.getfile(module)
         
-        editor = self.parent.find_editor(code)\
-              or self.parent.find_editor(filename)
+        editor = next(self.parent.get_all_editors(code),
+                 next(self.parent.get_all_editors(filename), None))
         if not editor:
             editor = self.parent.Log
             ## Note: Need a post-call for a thread debugging.
@@ -319,37 +317,38 @@ class Debugger(Pdb):
             self.editor.buffer.SetFocus()
         
         for ln in self.get_file_breaks(filename):
-            self._markbp(ln, 1) # (>>) bp:white-arrow
+            self._markbp(ln, 1)  # (>>) bp:white-arrow
         
         def _mark():
             buffer = self.editor.buffer
             if filename == buffer.filename:
                 if code != self.code:
-                    buffer.markline = firstlineno - 1 # (o) entry:marker
+                    buffer.markline = firstlineno - 1  # (o) entry:mark
                     buffer.goto_marker(1)
                     buffer.recenter(3)
                 buffer.goto_line(lineno - 1)
-                buffer.pointer = lineno - 1 # (->) pointer:marker
-                buffer.EnsureLineMoreOnScreen(lineno - 1)
+                buffer.pointer = lineno - 1  # (->) pointer:mark
+                buffer.ensureLineMoreOnScreen(lineno - 1)
             self.code = code
         wx.CallAfter(_mark)
-    
+
     def on_debug_next(self, frame):
         """Called in preloop (cmdloop)."""
         shell = self.interactive_shell
         self.__cpos = shell.cpos
+        
         def _next():
             shell.goto_char(shell.eolc)
             pos = self.__cpos
             out = shell.GetTextRange(pos, shell.cpos)
             if out.strip(' ') == self.prompt.strip(' ') and pos > shell.bol:
-                shell.cpos = pos # backward selection
+                shell.cpos = pos  # backward selection
                 shell.ReplaceSelection('')
                 shell.prompt()
             shell.EnsureCaretVisible()
             self.__cpos = shell.cpos
         wx.CallAfter(_next)
-    
+
     def on_debug_end(self, frame):
         """Called after set_quit.
         Note: self.busy -> True (until this stage)
@@ -361,23 +360,23 @@ class Debugger(Pdb):
         
         ## Note: Required to terminate the reader of threading pdb.
         self.send_input('\n')
-    
+
     def on_trace_hook(self, frame):
         """Called when a breakppoint is reached."""
         self.__hookpoint = None
-        self.interactive_shell.write('\n', -1) # move to eolc and insert LFD
+        self.interactive_shell.write('\n', -1)  # move to eolc and insert LFD
         self.message(where(frame.f_code), indent=0)
-    
+
     ## --------------------------------
-    ## Override Bdb methods
+    ## Override Bdb methods.
     ## --------------------------------
-    
+
     def break_anywhere(self, frame):
         """Return False (override)
         even if there is any breakpoint for frame's filename.
         """
         return False
-    
+
     def dispatch_line(self, frame):
         """Invoke user function and return trace function for line event.
         
@@ -396,7 +395,7 @@ class Debugger(Pdb):
             else:
                 return None
         return Pdb.dispatch_line(self, frame)
-    
+
     def dispatch_call(self, frame, arg):
         """Invoke user function and return trace function for call event.
         
@@ -407,14 +406,14 @@ class Debugger(Pdb):
             filename = frame.f_code.co_filename
             lineno = frame.f_lineno
             if target == filename:
-                if lineno <= line: # continue to dispatch_line
+                if lineno <= line:  # continue to dispatch_line
                     return self.trace_dispatch
                 else:
                     return None
             else:
                 return None
         return Pdb.dispatch_call(self, frame, arg)
-    
+
     def dispatch_return(self, frame, arg):
         """Invoke user function and return trace function for return event.
         
@@ -423,7 +422,7 @@ class Debugger(Pdb):
         if self.__hookpoint:
             return None
         return Pdb.dispatch_return(self, frame, arg)
-    
+
     def dispatch_exception(self, frame, arg):
         """Invoke user function and return trace function for exception event.
         
@@ -432,7 +431,7 @@ class Debugger(Pdb):
         if self.__hookpoint:
             return None
         return Pdb.dispatch_exception(self, frame, arg)
-    
+
     def set_trace(self, frame=None):
         if self.busy:
             wx.MessageBox("Debugger is running.\n\n"
@@ -442,34 +441,34 @@ class Debugger(Pdb):
             frame = inspect.currentframe().f_back
         self.handler('debug_begin', frame)
         Pdb.set_trace(self, frame)
-    
+
     def set_break(self, filename, lineno, *args, **kwargs):
         self._markbp(lineno, 1)
         return Pdb.set_break(self, filename, lineno, *args, **kwargs)
-    
+
     def set_quit(self):
         try:
             Pdb.set_quit(self)
         finally:
-            if self.parent: # Check if Destroy has begun.
+            if self.parent:  # Check if the parent is being deleted.
                 self.handler('debug_end', self.curframe)
-    
+
     ## --------------------------------
-    ## Override Pdb methods
+    ## Override Pdb methods.
     ## --------------------------------
-    
+
     @echo
     def print_stack_entry(self, frame_lineno, prompt_prefix=None):
         """Print the stack entry frame_lineno (frame, lineno).
         
         (override) Change prompt_prefix.
-                   Add pointer:marker when step next or jump.
+                   Add pointer:mark when step next or jump.
         """
         if self.verbose:
             Pdb.print_stack_entry(self, frame_lineno,
                 prompt_prefix or "\n{}-> ".format(self.indents))
         self.handler('debug_mark', frame_lineno[0])
-    
+
     @echo
     def user_call(self, frame, argument_list):
         """--Call--
@@ -481,13 +480,13 @@ class Debugger(Pdb):
             self.message("> {}".format(where(frame)), indent=0)
         self.indents += ' ' * 2
         Pdb.user_call(self, frame, argument_list)
-    
+
     @echo
     def user_line(self, frame):
         """--Next--
         """
         Pdb.user_line(self, frame)
-    
+
     @echo
     def user_return(self, frame, return_value):
         """--Return--
@@ -502,10 +501,10 @@ class Debugger(Pdb):
         frame.f_locals['__return__'] = return_value
         self.message('--Return--')
         if len(self.indents) > 2:
-            self.indents = self.indents[:-2] # remove '  '
+            self.indents = self.indents[:-2]  # remove '  '
         self.interaction(frame, None)
         ## Pdb.user_return(self, frame, return_value)
-    
+
     @echo
     def user_exception(self, frame, exc_info):
         """--Exception--
@@ -516,7 +515,7 @@ class Debugger(Pdb):
         self._markbp(tb.tb_lineno, 2)
         self.message(tb.tb_frame, indent=0)
         Pdb.user_exception(self, frame, exc_info)
-    
+
     @echo
     def bp_commands(self, frame):
         """--Break--
@@ -529,13 +528,13 @@ class Debugger(Pdb):
         for lineno in breakpoints:
             self._markbp(lineno, 1)
         return Pdb.bp_commands(self, frame)
-    
+
     @echo
     def preloop(self):
         """Hook method executed once when the cmdloop() method is called."""
         Pdb.preloop(self)
         self.handler('debug_next', self.curframe)
-    
+
     @echo
     def postloop(self):
         """Hook method executed once when the cmdloop() method is about to return."""

mwx/wxwil.py

@@ -17,11 +17,11 @@ def _repr(value):
 
 
 class LocalsWatcher(wx.ListCtrl, ListCtrlAutoWidthMixin, CtrlInterface):
-    """Locals info watcher
+    """Locals info watcher.
     
     Attributes:
-        parent : shellframe
-        target : locals:dict to watch
+        parent: shellframe
+        target: locals:dict to watch
     """
     def __init__(self, parent, **kwargs):
         wx.ListCtrl.__init__(self, parent,
@@ -34,8 +34,8 @@ class LocalsWatcher(wx.ListCtrl, ListCtrlAutoWidthMixin, CtrlInterface):
         
         self.Font = wx.Font(9, wx.DEFAULT, wx.NORMAL, wx.NORMAL)
         
-        self.__dir = True # sort direction
-        self.__items = [] # list of data:str
+        self.__dir = True  # sort direction
+        self.__items = []  # list of data:str
         
         _alist = (
             ("key", 140),
@@ -59,13 +59,13 @@ class LocalsWatcher(wx.ListCtrl, ListCtrlAutoWidthMixin, CtrlInterface):
             self.copy()
         
         dispatcher.connect(receiver=self._update, signal='Interpreter.push')
-    
+
     def _update(self, *args, **kwargs):
         if not self:
             dispatcher.disconnect(receiver=self._update, signal='Interpreter.push')
             return
         self.update()
-    
+
     def watch(self, locals):
         self.clear()
         if not isinstance(locals, dict):
@@ -86,18 +86,18 @@ class LocalsWatcher(wx.ListCtrl, ListCtrlAutoWidthMixin, CtrlInterface):
                 self.blink(i)
         finally:
             self.Thaw()
-    
+
     def unwatch(self):
         self.target = None
-    
+
     ## --------------------------------
-    ## Actions on list items
+    ## Actions on list items.
     ## --------------------------------
-    
+
     def clear(self):
         self.DeleteAllItems()
         del self.__items[:]
-    
+
     def update(self):
         if not self.target:
             return
@@ -116,7 +116,7 @@ class LocalsWatcher(wx.ListCtrl, ListCtrlAutoWidthMixin, CtrlInterface):
             if i is not None:
                 if data[i][1] == vstr:
                     continue
-                data[i][1] = vstr # Update data to locals
+                data[i][1] = vstr  # Update data to locals
             else:
                 i = len(data)
                 item = [key, vstr]
@@ -125,15 +125,16 @@ class LocalsWatcher(wx.ListCtrl, ListCtrlAutoWidthMixin, CtrlInterface):
             self.SetItem(i, 1, vstr)
             self.blink(i)
             self.EnsureVisible(i)
-    
+
     def blink(self, i):
         if self.GetItemBackgroundColour(i) != wx.Colour('yellow'):
             self.SetItemBackgroundColour(i, "yellow")
+            
             def _reset_color():
                 if self and i < self.ItemCount:
                     self.SetItemBackgroundColour(i, 'white')
             wx.CallAfter(wx.CallLater, 1000, _reset_color)
-    
+
     def copy(self):
         if not self.SelectedItemCount:
             return
@@ -143,8 +144,8 @@ class LocalsWatcher(wx.ListCtrl, ListCtrlAutoWidthMixin, CtrlInterface):
                 key, vstr = self.__items[i]
                 text += "{} = {}\n".format(key, vstr)
         Clipboard.write(text)
-    
-    def OnSortItems(self, evt): #<wx._controls.ListEvent>
+
+    def OnSortItems(self, evt):  # <wx._controls.ListEvent>
         n = self.ItemCount
         if n < 2:
             return
@@ -163,7 +164,7 @@ class LocalsWatcher(wx.ListCtrl, ListCtrlAutoWidthMixin, CtrlInterface):
             self.Select(i, item in ls)
             if item == fi:
                 self.Focus(i)
-    
+
     def OnContextMenu(self, evt):
         Menu.Popup(self, [
             (1, "Copy data", Icon('copy'),