pyqt-code-editor 1.0.4__tar.gz → 1.0.6__tar.gz

{pyqt_code_editor-1.0.4 → pyqt_code_editor-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyqt_code_editor
-Version: 1.0.4
+Version: 1.0.6
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>

{pyqt_code_editor-1.0.4 → pyqt_code_editor-1.0.6}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '1.0.4'
+__version__ = '1.0.6'

{pyqt_code_editor-1.0.4 → pyqt_code_editor-1.0.6}/pyqt_code_editor/components/sigmund/sigmund_analyst_widget.py

@@ -174,7 +174,7 @@ class SigmundAnalystWidget(SigmundWidget):
         time.sleep(.5)
         self._execution_result = None
         self._execution_loop = QEventLoop()
-        QTimer.singleShot(30000, self._execution_loop.quit)  # 30 second timeout
+        QTimer.singleShot(5 * 60000, self._execution_loop.quit)  # 5min timeout
         self._jupyter_console.execute_code(code)
         self._execution_loop.exec_()
         self._execution_loop = None

{pyqt_code_editor-1.0.4 → pyqt_code_editor-1.0.6}/pyqt_code_editor/mixins/base.py

@@ -146,6 +146,13 @@ class Base:
         # This function periodically prunes worker processes if they are unused.
         for pid in to_remove:
             self._active_requests.pop(pid, None)
+        # Non-blockingly finish cleaning up any workers that were
+        # previously asked to stop, and possibly ask further idle
+        # workers to stop (throttled internally). Neither call blocks
+        # the GUI thread, even on platforms (e.g. Windows) where
+        # joining a worker process can take a noticeable amount of
+        # time.
+        manager.reap_stopping_workers()
         manager.stop_unused_workers()
         
     def set_modified(self, modified):

{pyqt_code_editor-1.0.4 → pyqt_code_editor-1.0.6}/pyqt_code_editor/worker/manager.py

@@ -5,8 +5,11 @@ from .process import main_worker_process_function
 from .. import watchdog, settings
 logger = logging.getLogger(__name__)
 STOP_UNUSED_INTERVAL = 10
+MAX_CONCURRENT_STARTING = 2
 _last_stop_unused_time = 0
 _workers = {}  # pid -> {"process", "request_queue", "result_queue", "is_free"}
+_stopping = {}  # pid -> same shape as _workers, but already asked to quit
+_starting = set()  # pids of workers created but not yet proven alive-and-useful
 suspended = False
 
 
@@ -35,6 +38,9 @@ def _cleanup_dead_workers():
             w["process"].join(timeout=1)
         except Exception as e:
             logger.warning(f"Error joining dead worker {pid}: {e}")
+        # If this worker died before ever completing its first request, it
+        # was still occupying a "starting" slot; free that slot up.
+        _starting.discard(pid)
 
 
 def send_worker_request(**data) -> (Queue, int):
@@ -46,7 +52,17 @@ def send_worker_request(**data) -> (Queue, int):
     call mark_worker_as_free(pid) to release this worker for future use.
 
     If workers are suspended, return (None, None).
-    """
+
+    We also decline to create a new worker (returning (None, None)) if
+    MAX_CONCURRENT_STARTING workers are already "starting" -- i.e. have
+    been created but haven't yet completed a first successful round-trip
+    (see _starting / mark_worker_as_free()). This caps how many freshly
+    spawned, still-booting worker processes can pile up at once. A single
+    worker creation still pays the normal (and, on Windows, sometimes
+    substantial) process-creation cost on the GUI thread, but we avoid the
+    much worse case of several such creations happening back-to-back and
+    competing for CPU/disk/antivirus scanning at the same time.
+    """    
     if suspended:
         return None, None
     # 1. Look for an existing free worker
@@ -57,7 +73,12 @@ def send_worker_request(**data) -> (Queue, int):
             w["request_queue"].put(data)
             return w["result_queue"], pid
 
-    # 2. If no free worker was found, create a new one.
+    # 2. If no free worker was found, create a new one -- unless too many
+    # workers are already in the process of starting up.
+    if len(_starting) >= MAX_CONCURRENT_STARTING:
+        logger.info("declining requst, because too many worker(s) already starting.")
+        return None, None
+
     request_queue = Queue()
     result_queue = Queue()
     p = Process(target=main_worker_process_function,
@@ -72,6 +93,7 @@ def send_worker_request(**data) -> (Queue, int):
         "result_queue": result_queue,
         "is_free": False,
     }
+    _starting.add(pid)
 
     logger.info(f"Creating new worker {pid} for request {data['action']}")
     settings_action = {'action': 'set_settings',
@@ -85,12 +107,18 @@ def mark_worker_as_free(pid: int):
     """
     Mark a previously-used worker process (identified by pid)
     as free for reuse. If the worker has died, clean it up instead.
+
+    This is also the point at which a worker is considered to have proven
+    itself alive-and-useful (it has completed a request), so we release
+    its "starting" slot here if it still held one -- whether it succeeded
+    or died in the process.
     """
     w = _workers.get(pid)
     if w is None:
         return
     if w["process"].is_alive():
         w["is_free"] = True
+        _starting.discard(pid)
         logger.info(f"Marking worker {pid} as free")
     else:
         # The worker died while handling a request; clean up its resources
@@ -98,16 +126,51 @@ def mark_worker_as_free(pid: int):
         _workers.pop(pid)
         _close_worker_queues(w)
         w["process"].join(timeout=1)
+        _starting.discard(pid)
 
 def check_worker_alive(pid: int) -> bool:
     w = _workers.get(pid)
     return w and w["process"].is_alive()
 
-def stop_unused_workers(max_free: int = 1, force: bool = False):
+def reap_stopping_workers():
+    """
+    Finish cleaning up worker processes that were previously asked to quit
+    (via stop_unused_workers()), but only once they have actually
+    terminated. This is non-blocking: we merely check `is_alive()` for each
+    stopping worker, and only `join()` (with a zero timeout, so it returns
+    essentially instantly) processes that have already exited. Workers that
+    haven't exited yet are left in place and will be picked up on a later
+    call.
+
+    This should be called periodically (e.g. from the same timer that calls
+    stop_unused_workers()) so that workers asked to stop are eventually
+    cleaned up and their queues closed.
+    """
+    done_pids = [pid for pid, w in _stopping.items() if not w["process"].is_alive()]
+    for pid in done_pids:
+        w = _stopping.pop(pid)
+        logger.info(f"Reaping stopped worker {pid}.")
+        try:
+            w["process"].join(timeout=0)
+        except Exception as e:
+            logger.warning(f"Error joining stopped worker {pid}: {e}")
+        _close_worker_queues(w)
+
+def stop_unused_workers(max_free: int = 3, force: bool = False):
     """
-    Stop free worker processes until there is at most 'max_free' free processes
-    left. This keeps us from accumulating too many idle worker processes. Also
-    prunes any workers that have died unexpectedly.
+    Request that free worker processes stop until there is at most
+    'max_free' free processes left. This keeps us from accumulating too
+    many idle worker processes. Also prunes any workers that have died
+    unexpectedly.
+
+    Important: this function never blocks waiting for a worker to actually
+    exit. Workers that we decide to stop are sent a "quit" message and
+    moved into an internal `_stopping` bookkeeping dict; they are only
+    joined (and their queues closed) once they have actually terminated,
+    which is handled by reap_stopping_workers(). This matters because
+    joining a process that hasn't exited yet can block for a noticeable
+    amount of time, especially on Windows, and this function is typically
+    called from a periodic timer on the main/GUI thread.
     """
     global _last_stop_unused_time
     if not force and time.time() - _last_stop_unused_time < STOP_UNUSED_INTERVAL:
@@ -125,21 +188,24 @@ def stop_unused_workers(max_free: int = 1, force: bool = False):
         logger.info("No free workers to stop.")
         return
 
-    # Stop some free workers until we have exactly max_free left
+    # Ask some free workers to stop until we have max_free left. We don't
+    # wait for them to exit here; see reap_stopping_workers().
     while to_stop > 0 and free_pids:
         pid = free_pids.pop()
         w = _workers.pop(pid)
-        logger.info(f"Stopping free worker {pid} because we have too many.")
+        logger.info(f"Asking free worker {pid} to stop because we have too many.")
         w["request_queue"].put({"action": "quit"})
-        w["process"].join()
-        _close_worker_queues(w)
+        _stopping[pid] = w
         to_stop -= 1
 
-    logger.info("Finished stopping unused workers.")
+    logger.info("Finished requesting unused workers to stop.")
 
 def stop_all_workers():
     """
-    Cleanly shut down all worker processes.
+    Cleanly shut down all worker processes. Unlike stop_unused_workers(),
+    this function blocks until every worker has actually exited, since it
+    is only used when we need a hard guarantee that no worker processes
+    remain (e.g. on application shutdown or when suspending).
     """
     logger.info(f"Stopping {len(_workers)} worker processes...")
     for pid, w in list(_workers.items()):
@@ -149,6 +215,18 @@ def stop_all_workers():
             w["process"].join()
         _close_worker_queues(w)
         del _workers[pid]
+    # Also finish off any workers that were previously asked to stop (via
+    # stop_unused_workers()) but haven't been reaped yet.
+    for pid, w in list(_stopping.items()):
+        logger.info(f"Joining previously-stopping worker {pid}.")
+        try:
+            w["process"].join()
+        except Exception as e:
+            logger.warning(f"Error joining stopping worker {pid}: {e}")
+        _close_worker_queues(w)
+        del _stopping[pid]
+    # Nothing is left running, so no worker can still be "starting".
+    _starting.clear()
     logger.info("All workers stopped.")
 
 
@@ -177,4 +255,4 @@ def resume():
     logger.info("Resuming worker processes...")
 
 
-settings.setting_changed.connect(update_setting)
+settings.setting_changed.connect(update_setting)