pydevd-pycharm 252.21735.39__tar.gz → 252.23892.194__tar.gz

{pydevd_pycharm-252.21735.39/pydevd_pycharm.egg-info → pydevd_pycharm-252.23892.194}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pydevd-pycharm
-Version: 252.21735.39
+Version: 252.23892.194
 Summary: PyCharm Debugger (used in PyCharm and PyDev)
 Home-page: https://github.com/JetBrains/intellij-community
 Author: JetBrains, Fabio Zadrozny and others
@@ -9,7 +9,6 @@ Keywords: pydev,pydevd,pydev.debugger,pycharm
 Classifier: Development Status :: 6 - Mature
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX

pydevd_pycharm-252.23892.194/VERSION

@@ -0,0 +1 @@
+252.23892.194

{pydevd_pycharm-252.21735.39 → pydevd_pycharm-252.23892.194}/_pydev_bundle/pydev_code_executor.py

@@ -7,6 +7,7 @@ from _pydev_bundle._pydev_calltip_util import get_description
 from _pydev_bundle.pydev_imports import _queue
 from _pydev_bundle.pydev_stdin import DebugConsoleStdIn
 from _pydevd_bundle import pydevd_vars
+from _pydevd_bundle.pydevd_utils import interrupt_main_thread
 
 
 # =======================================================================================================================
@@ -229,40 +230,8 @@ class BaseCodeExecutor(object):
         self.buffer = None  # Also clear the buffer when it's interrupted.
         try:
             if self.interruptable:
-                called = False
-                try:
-                    # Fix for #PyDev-500: Console interrupt can't interrupt on sleep
-                    if os.name == 'posix':
-                        # On Linux we can't interrupt 0 as in Windows because it's
-                        # actually owned by a process -- on the good side, signals
-                        # work much better on Linux!
-                        os.kill(os.getpid(), signal.SIGINT)
-                        called = True
-
-                    elif os.name == 'nt':
-                        # In windows sending a Ctrl+C to a process given its pid is difficult.
-                        # There are utilities to make it work such as
-                        # http://www.latenighthacking.com/projects/2003/sendSignal/
-                        # but fortunately for us, it seems Python does allow a CTRL_C_EVENT
-                        # for the current process in Windows if pid 0 is passed... if we needed
-                        # to send a signal to another process the approach would be
-                        # much more difficult.
-                        # Still, note that CTRL_C_EVENT is only Python 2.7 onwards...
-                        os.kill(0, signal.CTRL_C_EVENT)
-                        called = True
-                except:
-                    # Many things to go wrong (from CTRL_C_EVENT not being there
-                    # to failing import signal)... if that's the case, ask for
-                    # forgiveness and go on to the approach which will interrupt
-                    # the main thread (but it'll only work when it's executing some Python
-                    # code -- not on sleep() for instance).
-                    pass
+                interrupt_main_thread()
 
-                if not called:
-                    if hasattr(thread, 'interrupt_main'):  # Jython doesn't have it
-                        thread.interrupt_main()
-                    else:
-                        self.mainThread._thread.interrupt()  # Jython
             self.finish_exec(False, False)
             return True
         except:

{pydevd_pycharm-252.21735.39 → pydevd_pycharm-252.23892.194}/_pydev_bundle/pydev_monkey.py

@@ -280,8 +280,9 @@ def patch_args(args):
         # in practice it'd raise an exception here and would return original args, which is not what we want... providing
         # a proper fix for https://youtrack.jetbrains.com/issue/PY-9767 elsewhere.
         if i >= len(args) or _is_managed_arg(args[i]):  # no need to add pydevd twice
-            log_debug("Patched args: %s" % str(args))
-            return args
+            new_args = quote_args(args)
+            log_debug("Patched args: %s" % str(new_args))
+            return new_args
 
         for x in original:
             new_args.append(x)
@@ -862,7 +863,11 @@ class _NewThreadStartupWithTrace:
             ret = self.original_func(*self.args, **self.kwargs)
         finally:
             if thread_id is not None:
-                global_debugger.notify_thread_not_alive(thread_id)
+                if global_debugger is not None:
+                    # At thread shutdown we only have pydevd-related code running (which shouldn't
+                    # be tracked).
+                    global_debugger.disable_tracing()
+                    global_debugger.notify_thread_not_alive(thread_id)
         
         return ret
 

{pydevd_pycharm-252.21735.39 → pydevd_pycharm-252.23892.194}/_pydevd_bundle/pydevd_additional_thread_info_regular.py

@@ -7,7 +7,7 @@ from _pydev_bundle import pydev_log
 from _pydevd_bundle.pydevd_frame import PyDBFrame
 # ENDIF
 
-version = 55
+version = 58
 
 if not hasattr(sys, '_current_frames'):
 

{pydevd_pycharm-252.21735.39 → pydevd_pycharm-252.23892.194}/_pydevd_bundle/pydevd_comm.py

@@ -70,16 +70,18 @@ from _pydev_imps._pydev_saved_modules import thread
 from _pydev_imps._pydev_saved_modules import threading
 from _pydev_imps._pydev_saved_modules import time
 from _pydev_imps._pydev_saved_modules import socket
-from socket import socket, AF_INET, SOCK_STREAM, SHUT_RD, SHUT_WR, SOL_SOCKET, SO_REUSEADDR, SHUT_RDWR, timeout
+from socket import socket, AF_INET, SOCK_STREAM, SHUT_RD, SHUT_WR, SOL_SOCKET, SO_REUSEADDR, SHUT_RDWR, timeout, IPPROTO_TCP
 from _pydevd_bundle.pydevd_constants import DebugInfoHolder, get_thread_id, IS_JYTHON, \
     IS_PY2, IS_PY3K, \
     IS_PY36_OR_GREATER, STATE_RUN, dict_keys, ASYNC_EVAL_TIMEOUT_SEC, IS_IRONPYTHON, \
     GlobalDebuggerHolder, \
-    get_global_debugger, GetGlobalDebugger, set_global_debugger, NEXT_VALUE_SEPARATOR
+    get_global_debugger, GetGlobalDebugger, set_global_debugger, NEXT_VALUE_SEPARATOR, IS_WINDOWS
 from _pydev_bundle.pydev_override import overrides
 import json
 import weakref
 
+from _pydevd_bundle.pydevd_daemon_thread import PyDBDaemonThread
+
 try:
     from urllib import quote_plus, unquote, unquote_plus
 except:
@@ -149,7 +151,7 @@ from _pydevd_bundle.pydevd_comm_constants import (
 MAX_IO_MSG_SIZE = 1000  #if the io is too big, we'll not send all (could make the debugger too non-responsive)
 #this number can be changed if there's need to do so
 
-VERSION_STRING = "252.21735.39"
+VERSION_STRING = "252.23892.194"
 
 from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding
 file_system_encoding = getfilesystemencoding()
@@ -183,119 +185,44 @@ def pydevd_log(level, *args):
             pass
 
 
-#------------------------------------------------------------------- ACTUAL COMM
-
-#=======================================================================================================================
-# PyDBDaemonThread
-#=======================================================================================================================
-class PyDBDaemonThread(threading.Thread):
-    created_pydb_daemon_threads = {}
-
-    def __init__(self, target_and_args=None):
-        '''
-        :param target_and_args:
-            tuple(func, args, kwargs) if this should be a function and args to run.
-            -- Note: use through run_as_pydevd_daemon_thread().
-        '''
-        threading.Thread.__init__(self)
-        self.killReceived = False
-        mark_as_pydevd_daemon_thread(self)
-        self._target_and_args = target_and_args
-
-    def run(self):
-        created_pydb_daemon = self.created_pydb_daemon_threads
-        created_pydb_daemon[self] = 1
-        try:
-            try:
-                if IS_JYTHON and not isinstance(threading.current_thread(), threading._MainThread):
-                    # we shouldn't update sys.modules for the main thread, cause it leads to the second importing 'threading'
-                    # module, and the new instance of main thread is created
-                    import org.python.core as PyCore #@UnresolvedImport
-                    ss = PyCore.PySystemState()
-                    # Note: Py.setSystemState() affects only the current thread.
-                    PyCore.Py.setSystemState(ss)
-
-                self._stop_trace()
-                self._warn_pydevd_thread_is_traced()
-                self._on_run()
-            except:
-                if sys is not None and traceback is not None:
-                    traceback.print_exc()
-        finally:
-            del created_pydb_daemon[self]
-
-    def _on_run(self):
-        if self._target_and_args is not None:
-            target, args, kwargs = self._target_and_args
-            target(*args, **kwargs)
-        else:
-            raise NotImplementedError('Should be reimplemented by: %s' % self.__class__)
-
-    def do_kill_pydev_thread(self):
-        self.killReceived = True
-
-    def _stop_trace(self):
-        if self.pydev_do_not_trace:
-            pydevd_tracing.SetTrace(None)  # no debugging on this thread
-
-    def _warn_pydevd_thread_is_traced(self):
-        if self.pydev_do_not_trace and sys.gettrace():
-            pydevd_log(1, "The debugger thread '%s' is traced which may lead to debugging performance issues." % self.__class__.__name__)
-
-
-def mark_as_pydevd_daemon_thread(thread):
-    thread.pydev_do_not_trace = True
-    thread.is_pydev_daemon_thread = True
-    thread.daemon = True
-
-
-def run_as_pydevd_daemon_thread(func, *args, **kwargs):
-    '''
-    Runs a function as a pydevd daemon thread (without any tracing in place).
-    '''
-    t = PyDBDaemonThread(target_and_args=(func, args, kwargs))
-    t.name = '%s (pydevd daemon thread)' % (func.__name__,)
-    t.start()
-    return t
-
-
 #=======================================================================================================================
 # ReaderThread
 #=======================================================================================================================
 class ReaderThread(PyDBDaemonThread):
     """ reader thread reads and dispatches commands in an infinite loop """
-
-    def __init__(self, sock):
-        PyDBDaemonThread.__init__(self)
+    def __init__(self, sock, py_db):
+        PyDBDaemonThread.__init__(self, py_db)
         self.sock = sock
         self.name = "pydevd.Reader"
         from _pydevd_bundle.pydevd_process_net_command import process_net_command
         self.process_net_command = process_net_command
-        self.debugger = GlobalDebuggerHolder.global_dbg
 
     def do_kill_pydev_thread(self):
+        PyDBDaemonThread.do_kill_pydev_thread(self)
         #We must close the socket so that it doesn't stay halted there.
-        self.killReceived = True
+
         try:
-            self.sock.shutdown(SHUT_RD) #shutdown the socket for read
+           self.sock.shutdown(SHUT_RD)
         except:
-            #just ignore that
-            pass
+           pass
+        try:
+           self.sock.close()
+        except:
+           pass
 
     @overrides(PyDBDaemonThread._on_run)
     def _on_run(self):
         read_buffer = ""
         try:
-
-            while not self.killReceived:
+            while not self._kill_received:
                 try:
                     r = self.sock.recv(1024)
                 except OSError:
                     return
                 except:
-                    if not self.killReceived:
+                    if not self._kill_received:
                         traceback.print_exc()
-                        self.handle_except()
+                        self._terminate_on_socket_close()
                     return #Finished communication.
 
                 #Note: the java backend is always expected to pass utf-8 encoded strings. We now work with unicode
@@ -310,7 +237,7 @@ class ReaderThread(PyDBDaemonThread):
                     sys.stderr.flush()
 
                 if len(read_buffer) == 0:
-                    self.handle_except()
+                    self._terminate_on_socket_close()
                     break
                 while read_buffer.find(u'\n') != -1:
                     command, read_buffer = read_buffer.split(u'\n', 1)
@@ -327,13 +254,15 @@ class ReaderThread(PyDBDaemonThread):
 
         except:
             traceback.print_exc()
-            self.handle_except()
+            self._terminate_on_socket_close()
+        finally:
+            pydev_log.debug("ReaderThread: exit")
 
-    def handle_except(self):
-        self.debugger.finish_debugging_session()
+    def _terminate_on_socket_close(self):
+        self.py_db.dispose_and_kill_all_pydevd_threads()
 
     def process_command(self, cmd_id, seq, text):
-        self.process_net_command(self.debugger, cmd_id, seq, text)
+        self.process_net_command(self.py_db, cmd_id, seq, text)
 
 
 #----------------------------------------------------------------------------------- SOCKET UTILITIES - WRITER
@@ -342,8 +271,8 @@ class ReaderThread(PyDBDaemonThread):
 #=======================================================================================================================
 class WriterThread(PyDBDaemonThread):
     """ writer thread writes out the commands in an infinite loop """
-    def __init__(self, sock):
-        PyDBDaemonThread.__init__(self)
+    def __init__(self, sock, py_db):
+        PyDBDaemonThread.__init__(self, py_db)
         self.sock = sock
         self.name = "pydevd.Writer"
         self.cmdQueue = _queue.Queue()
@@ -354,22 +283,26 @@ class WriterThread(PyDBDaemonThread):
 
     def add_command(self, cmd):
         """ cmd is NetCommand """
-        if not self.killReceived: #we don't take new data after everybody die
+        if not self._kill_received: #we don't take new data after everybody die
             self.cmdQueue.put(cmd)
 
     @overrides(PyDBDaemonThread._on_run)
     def _on_run(self):
         """ just loop and write responses """
-
         try:
             while True:
                 try:
                     try:
-                        cmd = self.cmdQueue.get(1, 0.1)
+                        cmd = self.cmdQueue.get(True, 0.1)
                     except _queue.Empty:
-                        if self.killReceived:
+                        if self._kill_received:
+                            pydev_log.debug("WriterThread: kill_received (sock.shutdown(SHUT_WR))")
                             try:
                                 self.sock.shutdown(SHUT_WR)
+                            except:
+                                pass
+
+                            try:
                                 self.sock.close()
                             except:
                                 pass
@@ -390,46 +323,79 @@ class WriterThread(PyDBDaemonThread):
                     break #interpreter shutdown
                 time.sleep(self.timeout)
         except Exception:
-            GlobalDebuggerHolder.global_dbg.finish_debugging_session()
+            self.py_db.dispose_and_kill_all_pydevd_threads()
             if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 0:
                 traceback.print_exc()
+        finally:
+            pydev_log.debug("WriterThread: exit")
 
     def empty(self):
         return self.cmdQueue.empty()
 
+    @overrides(PyDBDaemonThread.do_kill_pydev_thread)
+    def do_kill_pydev_thread(self):
+        if not self._kill_received:
+            # Add command before setting the kill flag (otherwise the command may not be added).
+            exit_cmd = self.py_db.cmd_factory.make_exit_message()
+            self.add_command(exit_cmd)
 
+        PyDBDaemonThread.do_kill_pydev_thread(self)
 
 #--------------------------------------------------- CREATING THE SOCKET THREADS
 
 #=======================================================================================================================
 # start_server
 #=======================================================================================================================
-def start_server(port):
-    """ binds to a port, waits for the debugger to connect """
-    s = socket(AF_INET, SOCK_STREAM)
-    s.settimeout(None)
-
+def create_server_socket(host, port):
     try:
-        from socket import SO_REUSEPORT
-        s.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
-    except ImportError:
-        s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+        server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)
+        if IS_WINDOWS:
+            try:
+                from socket import SO_EXCLUSIVEADDRUSE
+                server.setsockopt(SOL_SOCKET, SO_EXCLUSIVEADDRUSE, 1)
+            except ImportError:
+                server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+        else:
+            try:
+                from socket import SO_REUSEPORT
+                server.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
+            except ImportError:
+                server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+
+        server.bind((host, port))
+        server.settimeout(None)
+    except Exception:
+        server.close()
+        raise
+
+    return server
 
-    s.bind(('', port))
-    pydevd_log(1, "Bound to port ", str(port))
+
+
+def start_server(port):
+    """ binds to a port, waits for the debugger to connect """
+    s = create_server_socket('', port)
 
     try:
         s.listen(1)
-        newSock, _addr = s.accept()
-        pydevd_log(1, "Connection accepted")
+        # Let the user know it's halted waiting for the connection.
+        host, port = s.getsockname()
+        msg = "pydevd: waiting for connection at: %host:%port%".format(host=host, port=port)
+        pydev_log.info(msg)
+
+        new_socket, _addr = s.accept()
+        pydev_log.info("Connection accepted")
         # closing server socket is not necessary but we don't need it
         try:
             s.shutdown(SHUT_RDWR)
         except:
             pass
-        finally:
+        try:
             s.close()
-        return newSock
+        except:
+            pass
+
+        return new_socket
 
     except:
         sys.stderr.write("Could not bind to port: %s\n" % (port,))
@@ -437,6 +403,7 @@ def start_server(port):
         traceback.print_exc()
         raise
 
+
 #=======================================================================================================================
 # start_client
 #=======================================================================================================================
@@ -455,19 +422,27 @@ def start_client(host, port):
     #  then sends a keepalive ping once every 3 seconds (TCP_KEEPINTVL),
     #  and closes the connection after 5 failed ping (TCP_KEEPCNT), or 15 seconds
     try:
-        from socket import IPPROTO_TCP, SO_KEEPALIVE, TCP_KEEPIDLE, TCP_KEEPINTVL, TCP_KEEPCNT
-        s.setsockopt(SOL_SOCKET, SO_KEEPALIVE, 1)
-        s.setsockopt(IPPROTO_TCP, TCP_KEEPIDLE, 1)
-        s.setsockopt(IPPROTO_TCP, TCP_KEEPINTVL, 3)
-        s.setsockopt(IPPROTO_TCP, TCP_KEEPCNT, 5)
-    except ImportError:
+        s.setsockopt(SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+    except (AttributeError, OSError):
+        pass  # May not be available everywhere.
+    try:
+        s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 1)
+    except (AttributeError, OSError):
+        pass  # May not be available everywhere.
+    try:
+        s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 3)
+    except (AttributeError, OSError):
+        pass  # May not be available everywhere.
+    try:
+        s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5)
+    except (AttributeError, OSError):
         pass  # May not be available everywhere.
 
     try:
         s.settimeout(10)  # 10 seconds timeout
         s.connect((host, port))
         s.settimeout(None)  # no timeout after connected
-        pydevd_log(1, "Connected.")
+        pydev_log.info("Connected to: {socket}.".format(socket=s))
         return s
     except:
         sys.stderr.write("Could not connect to %s: %s\n" % (host, port))
@@ -476,8 +451,6 @@ def start_client(host, port):
         raise
 
 
-
-
 #------------------------------------------------------------------------------------ MANY COMMUNICATION STUFF
 
 #=======================================================================================================================
@@ -549,8 +522,9 @@ class NetCommand:
             sock.sendall(('Content-Length: %s\r\n\r\n' % len(as_bytes)).encode('ascii'))
         try:
             sock.sendall(as_bytes)
-        except BrokenPipeError:
-            print("Connection closed unexpectedly!")
+        except OSError as e:
+            if not IS_PY2 and isinstance(e, ConnectionError):
+                print("Connection error: %s" % (e,))
 
     @classmethod
     def _show_debug_info(cls, cmd_id, seq, text):
@@ -742,7 +716,7 @@ class NetCommandFactory:
                 else:
                     my_file = abs_path_real_path_and_base[0]
 
-                if is_real_file(my_file) and not is_jup_cell:
+                if not is_jup_cell and is_real_file(my_file):
                     # if filename is Jupyter cell id
                     my_file = pydevd_file_utils.norm_file_to_client(abs_path_real_path_and_base[0])
 
@@ -1057,8 +1031,6 @@ class InternalThreadCommand:
 
 
 class ReloadCodeCommand(InternalThreadCommand):
-
-
     def __init__(self, module_name, thread_id):
         self.thread_id = thread_id
         self.module_name = module_name
@@ -1389,7 +1361,7 @@ class InternalDataViewerAction(InternalThreadCommand):
 class InternalTableCommand(InternalThreadCommand):
     def __init__(self, sequence, thread_id, frame_id, init_command, command_type,
                  start_index, end_index, format):
-        super().__init__(thread_id)
+        InternalThreadCommand.__init__(self, thread_id)
         self.sequence = sequence
         self.frame_id = frame_id
         self.init_command = init_command
@@ -1424,7 +1396,7 @@ class InternalTableCommand(InternalThreadCommand):
 #=======================================================================================================================
 class InternalTableImageCommandBase(InternalThreadCommand):
     def __init__(self, sequence, thread_id, frame_id, init_command, command_type):
-        super().__init__(thread_id)
+        InternalThreadCommand.__init__(self, thread_id)
         self.sequence = sequence
         self.frame_id = frame_id
         self.init_command = init_command
@@ -1467,7 +1439,7 @@ class InternalTableImageStartCommand(InternalTableImageCommandBase):
 
 class InternalTableImageChunkCommand(InternalTableImageCommandBase):
     def __init__(self, sequence, thread_id, frame_id, init_command, command_type, offset, image_id):
-        super().__init__(sequence, thread_id, frame_id, init_command, command_type)
+        InternalTableImageCommandBase.__init__(self, sequence, thread_id, frame_id, init_command, command_type)
         self._offset = offset
         self._image_id = image_id