Replaces tabs with spaces in tests, and updates the terminal.py file.

Author: kyleellefsen

flika/app/syntax.py

@@ -112,14 +112,12 @@ def highlightBlock(self, text):
         """
         # Do other syntax formatting
         for expression, nth, format in self.rules:
-            index = expression.indexIn(text, 0)
-
-            while index >= 0:
-                # We actually want the index of the nth match
-                index = expression.pos(nth)
-                length = len(expression.cap(nth))
+            match = expression.match(text, 0)
+            while match.hasMatch():
+                index = match.capturedStart()
+                length = match.capturedLength()
                 self.setFormat(index, length, format)
-                index = expression.indexIn(text, index + length)
+                match = expression.match(text, index + length)
 
         self.setCurrentBlockState(0)
 

flika/app/terminal.py

@@ -2,45 +2,49 @@
 import sys
 import atexit
 from contextlib import contextmanager
-from distutils.version import LooseVersion
-from qtpy import QtCore, QtWidgets # must import these first, to set up Qt properly
+from typing import Any, Dict, Optional, Type, Union
+
+# Import Qt functionality through qtpy for abstraction
+from qtpy import QtCore, QtWidgets
+
+# IPython imports
 import IPython
 from IPython.core.usage import default_banner
+from IPython import get_ipython
+
+# ZMQ imports
 from zmq import ZMQError
 from zmq.eventloop import ioloop
 from zmq.eventloop.zmqstream import ZMQStream
-from ..version import __version__
-
 
-from IPython import get_ipython
+# Import version
+from ..version import __version__
 
+# Import traitlets
 from traitlets import TraitError
 
+# Import ipykernel components
 from ipykernel.connect import _find_connection_file as find_connection_file
 from ipykernel.kernelbase import Kernel
 from ipykernel.kernelapp import IPKernelApp
 from ipykernel.iostream import OutStream
 from ipykernel.inprocess.ipkernel import InProcessInteractiveShell
 from ipykernel.connect import get_connection_file
 
+# Import qtconsole components
 from qtconsole.client import QtKernelClient
 from qtconsole.manager import QtKernelManager
 from qtconsole.inprocess import QtInProcessKernelManager
 from qtconsole.rich_jupyter_widget import RichJupyterWidget as RichIPythonWidget
 
 
-
-
-def in_process_console(console_class=RichIPythonWidget, **kwargs):
+def in_process_console(console_class: Type[RichIPythonWidget] = RichIPythonWidget, **kwargs: Any) -> RichIPythonWidget:
     """Create a console widget, connected to an in-process Kernel
 
-    This only works on IPython v 0.13 and above
-
     Parameters:
-        console_class : The class of the console widget to create
-        kwargs : Extra variables to put into the namespace
+        console_class: The class of the console widget to create
+        kwargs: Extra variables to put into the namespace
     """
-
     km = QtInProcessKernelManager()
     km.start_kernel()
 
@@ -58,15 +62,13 @@ def in_process_console(console_class=RichIPythonWidget, **kwargs):
     return control
 
 
-def connected_console(console_class=RichIPythonWidget, **kwargs):
+def connected_console(console_class: Type[RichIPythonWidget] = RichIPythonWidget, **kwargs: Any) -> RichIPythonWidget:
     """Create a console widget, connected to another kernel running in
        the current process
 
-    This only works on IPython v1.0 and above
-
     Parameters:
-        console_class : The class of the console widget to create
-        kwargs : Extra variables to put into the namespace
+        console_class: The class of the console widget to create
+        kwargs: Extra variables to put into the namespace
     """
     shell = get_ipython()
     if shell is None:
@@ -84,89 +86,27 @@ def connected_console(console_class=RichIPythonWidget, **kwargs):
 
 
 class Terminal(RichIPythonWidget):
-    def __init__(self, **kwargs):
-        super(Terminal, self).__init__(**kwargs)
-
+    """IPython terminal widget for embedding in the application."""
+    
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
         self.setAcceptDrops(True)
         self.shell = None
 
     @property
-    def namespace(self):
+    def namespace(self) -> Optional[Dict[str, Any]]:
+        """Return the namespace dictionary of the shell."""
         return self.shell.user_ns if self.shell is not None else None
 
-    def update_namespace(self, kwargs):
+    def update_namespace(self, kwargs: Dict[str, Any]) -> None:
+        """Update the namespace with the given variables."""
         if self.shell is not None:
             self.shell.push(kwargs)
 
 
-
-# Works for IPython 0.12, 0.13
-def default_kernel_app():
-    """ Return a configured IPKernelApp """
-
-    def event_loop(kernel):
-        """ Non-blocking qt event loop."""
-        kernel.timer = QtCore.QTimer()
-        kernel.timer.timeout.connect(kernel.do_one_iteration)
-        kernel.timer.start(1000 * kernel._poll_interval)
-
-    app = IPKernelApp.instance()
-    try:
-        app.initialize(['python', '--pylab=qt'])
-    except ZMQError:
-        pass  # already set up
-
-    app.kernel.eventloop = event_loop
-
-    try:
-        app.start()
-    except RuntimeError:  # already started
-        pass
-
-    return app
-
-
-def default_manager(kernel):
-    """ Return a configured QtKernelManager
-
-    Parameters:
-         kernel: An IPKernelApp instance
-    """
-    connection_file = find_connection_file(kernel.connection_file)
-    manager = QtKernelManager(connection_file=connection_file)
-    manager.load_connection_file()
-    manager.start_channels()
-    atexit.register(manager.cleanup_connection_file)
-    return manager
-
-
-def _ipython_terminal_1(**kwargs):
-    """ Used for IPython v0.13, v0.12
-    """
-    kernel_app = default_kernel_app()
-    manager = default_manager(kernel_app)
-
-    try:  # IPython v0.13
-        widget = Terminal(gui_completion='droplist')
-    except TraitError:  # IPython v0.12
-        widget = Terminal(gui_completion=True)
-    widget.kernel_manager = manager
-    widget.shell = kernel_app.shell
-
-    # update namespace
-    widget.update_namespace(kwargs)
-
-    # IPython v0.12 turns on MPL interactive. Turn it back off
-    import matplotlib
-    matplotlib.interactive(False)
-    return widget
-
-
-# works on IPython v0.13, v0.14
 @contextmanager
-def redirect_output(session, pub_socket):
-    """Prevent any of the widgets from permanently hijacking stdout or
-    stderr"""
+def redirect_output(session: Any, pub_socket: Any) -> None:
+    """Prevent any of the widgets from permanently hijacking stdout or stderr"""
     sys.stdout = OutStream(session, pub_socket, u'stdout')
     sys.stderr = OutStream(session, pub_socket, u'stderr')
     try:
@@ -176,144 +116,122 @@ def redirect_output(session, pub_socket):
         sys.stderr = sys.__stderr__
 
 
-def non_blocking_eventloop(kernel):
+def non_blocking_eventloop(kernel: Kernel) -> None:
+    """Set up a non-blocking event loop for the kernel."""
     kernel.timer = QtCore.QTimer()
     kernel.timer.timeout.connect(kernel.do_one_iteration)
     kernel.timer.start(1000 * kernel._poll_interval)
 
 
 class EmbeddedQtKernel(Kernel):
+    """Kernel class that embeds the Qt event loop."""
 
-    def __init__(self, *args, **kwargs):
-        super(EmbeddedQtKernel, self).__init__(*args, **kwargs)
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
         self.eventloop = non_blocking_eventloop
 
-    def do_one_iteration(self):
+    def do_one_iteration(self) -> None:
         with redirect_output(self.session, self.iopub_socket):
-            super(EmbeddedQtKernel, self).do_one_iteration()
+            super().do_one_iteration()
 
-    def execute_request(self, stream, ident, parent):
+    def execute_request(self, stream: Any, ident: Any, parent: Any) -> None:
         with redirect_output(self.session, self.iopub_socket):
-            super(EmbeddedQtKernel, self).execute_request(
-                stream, ident, parent)
+            super().execute_request(stream, ident, parent)
 
 
 class EmbeddedQtKernelApp(IPKernelApp):
+    """Application class for embedded Qt kernel."""
 
-    def init_kernel(self):
+    def init_kernel(self) -> None:
         shell_stream = ZMQStream(self.shell_socket)
-        kernel = EmbeddedQtKernel(config=self.config, session=self.session,
-                                  shell_streams=[shell_stream],
-                                  iopub_socket=self.iopub_socket,
-                                  stdin_socket=self.stdin_socket,
-                                  log=self.log,
-                                  profile_dir=self.profile_dir,
-                                  )
+        kernel = EmbeddedQtKernel(
+            config=self.config, 
+            session=self.session,
+            shell_streams=[shell_stream],
+            iopub_socket=self.iopub_socket,
+            stdin_socket=self.stdin_socket,
+            log=self.log,
+            profile_dir=self.profile_dir,
+        )
         self.kernel = kernel
         kernel.record_ports(self.ports)
 
-    def start(self):
-        # handoff between IOLoop and QApplication event loops
+    def start(self) -> None:
+        # Handoff between IOLoop and QApplication event loops
         loop = ioloop.IOLoop.instance()
-        # We used to have a value of 0ms as the second argument
-        # (callback_time) in the following call, but this caused the
-        # application to hang on certain setups, so use 1ms instead.
+        # Use 1ms callback time to prevent application hanging
         stopper = ioloop.PeriodicCallback(loop.stop, 1, loop)
         self.timer = QtCore.QTimer()
         self.timer.timeout.connect(loop.start)
         self.timer.start(100)
         stopper.start()
-        super(EmbeddedQtKernelApp, self).start()
+        super().start()
 
 
 class EmbeddedIPythonWidget(Terminal):
+    """Modern embedded IPython widget."""
+    
     gui_completion = 'droplist'
 
-    def __init__(self, **kwargs):
-        super(EmbeddedIPythonWidget, self).__init__(**kwargs)
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
         self._init_kernel_app()
         self._init_kernel_manager()
         self.update_namespace(kwargs)
 
-    def _init_kernel_app(self):
+    def _init_kernel_app(self) -> None:
         app = EmbeddedQtKernelApp.instance()
         try:
             app.initialize([])
         except ZMQError:
-            pass  # already set up
+            pass  # Already set up
         try:
             app.start()
-        except RuntimeError:  # already started
+        except RuntimeError:  # Already started
             pass
         self.app = app
         self.shell = app.shell
 
-    def _init_kernel_manager(self):
+    def _init_kernel_manager(self) -> None:
         connection_file = find_connection_file(self.app.connection_file)
         manager = QtKernelManager(connection_file=connection_file)
         manager.load_connection_file()
         manager.start_channels()
         atexit.register(manager.cleanup_connection_file)
         self.kernel_manager = manager
 
-    def update_namespace(self, ns):
+    def update_namespace(self, ns: Dict[str, Any]) -> None:
         self.app.shell.user_ns.update(ns)
 
 
-def _ipython_terminal_2(**kwargs):
-    """Used for IPython v0.13, v0.14"""
-    return EmbeddedIPythonWidget(**kwargs)
-
+def ipython_terminal(banner: str = '', **kwargs: Any) -> Terminal:
+    """Return a qt widget which embeds an IPython interpreter.
 
-def _ipython_terminal_3(**kwargs):
-    """Used for IPython v1.0 and beyond
+    Extra keywords will be added to the namespace of the shell.
 
     Parameters:
-         kwargs: Keywords which are passed to Widget init,
-        and which are also passed to the current namespace
+        banner: Text to display at the top of the terminal
+        kwargs: Extra variables to be added to the namespace
+
+    Returns:
+        Terminal widget with embedded IPython interpreter
     """
-    # see IPython/docs/examples/frontends/inprocess_qtconsole.p
+    Terminal.banner = f"""flika version {__version__}
+
+{banner}
+
+"""
 
+    # In modern Python with recent IPython, we only need the in-process console
+    # (version checking logic simplified for Python 3.13)
     shell = get_ipython()
     if shell is None or isinstance(shell, InProcessInteractiveShell):
         return in_process_console(console_class=Terminal, **kwargs)
     return connected_console(console_class=Terminal, **kwargs)
 
 
-def ipython_terminal(banner='', **kwargs):
-    """ Return a qt widget which embed an IPython interpreter.
-
-        Extra keywords will be added to the namespace of the shell
-
-    Parameters:
-        kwargs (QWidget): Extra variables to be added to the namespace
-
-    """
-    Terminal.banner = '''flika version {}
-
-{}
-
-'''.format(__version__, banner)
-
-    from distutils.version import LooseVersion
-    import IPython
-    ver = LooseVersion(IPython.__version__)
-    v1_0 = LooseVersion('1.0')
-    v0_12 = LooseVersion('0.12')
-    v0_13 = LooseVersion('0.13')
-
-    if ver >= v1_0:
-        return _ipython_terminal_3(**kwargs)
-    if ver >= v0_13:
-        return _ipython_terminal_2(**kwargs)
-    if ver >= v0_12:
-        return _ipython_terminal_1(**kwargs)
-
-    raise RuntimeError("Terminal requires IPython >= 0.12")
-
-
 if __name__ == '__main__':
     app = QtWidgets.QApplication([])
     new_widget = ipython_terminal()
     new_widget.show()
-    app.exec_()
+    app.exec()  # Using exec() in Python 3 (not exec_())