debugpy 1.8.5__zip → 1.8.7__zip

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydevd_attach_to_process/add_code_to_python_process.py

@@ -1,4 +1,4 @@
-r'''
+r"""
 Copyright: Brainwy Software Ltda.
 
 License: EPL.
@@ -64,7 +64,7 @@ Other references:
 To build the dlls needed on windows, visual studio express 13 was used (see compile_dll.bat)
 
 See: attach_pydevd.py to attach the pydev debugger to a running python process.
-'''
+"""
 
 # Note: to work with nasm compiling asm to code and decompiling to see asm with shellcode:
 # x:\nasm\nasm-2.07-win32\nasm-2.07\nasm.exe
@@ -94,17 +94,16 @@ def _create_win_event(name):
     manual_reset = False  # i.e.: after someone waits it, automatically set to False.
     initial_state = False
     if not isinstance(name, bytes):
-        name = name.encode('utf-8')
+        name = name.encode("utf-8")
     event = CreateEventA(None, manual_reset, initial_state, name)
     if not event:
         raise ctypes.WinError()
 
     class _WinEvent(object):
-
         def wait_for_event_set(self, timeout=None):
-            '''
+            """
             :param timeout: in seconds
-            '''
+            """
             if timeout is None:
                 timeout = 0xFFFFFFFF
             else:
@@ -124,13 +123,13 @@ def _create_win_event(name):
         CloseHandle(event)
 
 
-IS_WINDOWS = sys.platform == 'win32'
-IS_LINUX = sys.platform in ('linux', 'linux2')
-IS_MAC = sys.platform == 'darwin'
+IS_WINDOWS = sys.platform == "win32"
+IS_LINUX = sys.platform in ("linux", "linux2")
+IS_MAC = sys.platform == "darwin"
 
 
 def is_python_64bit():
-    return (struct.calcsize('P') == 8)
+    return struct.calcsize("P") == 8
 
 
 def get_target_filename(is_target_process_64=None, prefix=None, extension=None):
@@ -140,7 +139,7 @@ def get_target_filename(is_target_process_64=None, prefix=None, extension=None):
     # debugger -- the only situation where it's imported is if the user actually does an attach to
     # process, through `attach_pydevd.py`, but this should usually be called from the IDE directly
     # and not from the debugger).
-    libdir = os.path.dirname(__file__)
+    libdir = os.path.dirname(os.path.abspath(__file__))
 
     if is_target_process_64 is None:
         if IS_WINDOWS:
@@ -150,41 +149,41 @@ def get_target_filename(is_target_process_64=None, prefix=None, extension=None):
         # For other platforms, just use the the same bitness of the process we're running in.
         is_target_process_64 = is_python_64bit()
 
-    arch = ''
+    arch = ""
     if IS_WINDOWS:
         # prefer not using platform.machine() when possible (it's a bit heavyweight as it may
         # spawn a subprocess).
-        arch = os.environ.get("PROCESSOR_ARCHITEW6432", os.environ.get('PROCESSOR_ARCHITECTURE', ''))
+        arch = os.environ.get("PROCESSOR_ARCHITEW6432", os.environ.get("PROCESSOR_ARCHITECTURE", ""))
 
     if not arch:
         arch = platform.machine()
         if not arch:
-            print('platform.machine() did not return valid value.')  # This shouldn't happen...
+            print("platform.machine() did not return valid value.")  # This shouldn't happen...
             return None
 
     if IS_WINDOWS:
         if not extension:
-            extension = '.dll'
-        suffix_64 = 'amd64'
-        suffix_32 = 'x86'
+            extension = ".dll"
+        suffix_64 = "amd64"
+        suffix_32 = "x86"
 
     elif IS_LINUX:
         if not extension:
-            extension = '.so'
-        suffix_64 = 'amd64'
-        suffix_32 = 'x86'
+            extension = ".so"
+        suffix_64 = "amd64"
+        suffix_32 = "x86"
 
     elif IS_MAC:
         if not extension:
-            extension = '.dylib'
-        suffix_64 = 'x86_64'
-        suffix_32 = 'x86'
+            extension = ".dylib"
+        suffix_64 = "x86_64"
+        suffix_32 = "x86"
 
     else:
-        print('Unable to attach to process in platform: %s', sys.platform)
+        print("Unable to attach to process in platform: %s", sys.platform)
         return None
 
-    if arch.lower() not in ('amd64', 'x86', 'x86_64', 'i386', 'x86'):
+    if arch.lower() not in ("amd64", "x86", "x86_64", "i386", "x86"):
         # We don't support this processor by default. Still, let's support the case where the
         # user manually compiled it himself with some heuristics.
         #
@@ -195,19 +194,19 @@ def get_target_filename(is_target_process_64=None, prefix=None, extension=None):
         # - linux_and_mac/compile_mac.sh
 
         try:
-            found = [name for name in os.listdir(libdir) if name.startswith('attach_') and name.endswith(extension)]
+            found = [name for name in os.listdir(libdir) if name.startswith("attach_") and name.endswith(extension)]
         except:
-            print('Error listing dir: %s' % (libdir,))
+            print("Error listing dir: %s" % (libdir,))
             traceback.print_exc()
             return None
 
         if prefix:
             expected_name = prefix + arch + extension
-            expected_name_linux = prefix + 'linux_' + arch + extension
+            expected_name_linux = prefix + "linux_" + arch + extension
         else:
             # Default is looking for the attach_ / attach_linux
-            expected_name = 'attach_' + arch + extension
-            expected_name_linux = 'attach_linux_' + arch + extension
+            expected_name = "attach_" + arch + extension
+            expected_name_linux = "attach_linux_" + arch + extension
 
         filename = None
         if expected_name in found:  # Heuristic: user compiled with "attach_<arch>.<extension>"
@@ -225,14 +224,10 @@ def get_target_filename(is_target_process_64=None, prefix=None, extension=None):
                 filename = os.path.join(libdir, found[0])
 
         if filename is None:
-            print(
-                'Unable to attach to process in arch: %s (did not find %s in %s).' % (
-                    arch, expected_name, libdir
-                )
-            )
+            print("Unable to attach to process in arch: %s (did not find %s in %s)." % (arch, expected_name, libdir))
             return None
 
-        print('Using %s in arch: %s.' % (filename, arch))
+        print("Using %s in arch: %s." % (filename, arch))
 
     else:
         if is_target_process_64:
@@ -243,33 +238,34 @@ def get_target_filename(is_target_process_64=None, prefix=None, extension=None):
         if not prefix:
             # Default is looking for the attach_ / attach_linux
             if IS_WINDOWS or IS_MAC:  # just the extension changes
-                prefix = 'attach_'
+                prefix = "attach_"
             elif IS_LINUX:
-                prefix = 'attach_linux_'  # historically it has a different name
+                prefix = "attach_linux_"  # historically it has a different name
             else:
-                print('Unable to attach to process in platform: %s' % (sys.platform,))
+                print("Unable to attach to process in platform: %s" % (sys.platform,))
                 return None
 
-        filename = os.path.join(libdir, '%s%s%s' % (prefix, suffix, extension))
+        filename = os.path.join(libdir, "%s%s%s" % (prefix, suffix, extension))
 
     if not os.path.exists(filename):
-        print('Expected: %s to exist.' % (filename,))
+        print("Expected: %s to exist." % (filename,))
         return None
 
     return filename
 
 
 def run_python_code_windows(pid, python_code, connect_debugger_tracing=False, show_debug_info=0):
-    assert '\'' not in python_code, 'Having a single quote messes with our command.'
+    assert "'" not in python_code, "Having a single quote messes with our command."
 
     # Suppress winappdbg warning about sql package missing.
     import warnings
+
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", category=ImportWarning)
         from winappdbg.process import Process
 
     if not isinstance(python_code, bytes):
-        python_code = python_code.encode('utf-8')
+        python_code = python_code.encode("utf-8")
 
     process = Process(pid)
     bits = process.get_bits()
@@ -282,41 +278,40 @@ def run_python_code_windows(pid, python_code, connect_debugger_tracing=False, sh
     #     "Target 64 bits: %s\n"
     #     "Current Python 64 bits: %s" % (is_target_process_64, is_python_64bit()))
 
-    with _acquire_mutex('_pydevd_pid_attach_mutex_%s' % (pid,), 10):
-        print('--- Connecting to %s bits target (current process is: %s) ---' % (bits, 64 if is_python_64bit() else 32))
+    with _acquire_mutex("_pydevd_pid_attach_mutex_%s" % (pid,), 10):
+        print("--- Connecting to %s bits target (current process is: %s) ---" % (bits, 64 if is_python_64bit() else 32))
         sys.stdout.flush()
 
         with _win_write_to_shared_named_memory(python_code, pid):
-
-            target_executable = get_target_filename(is_target_process_64, 'inject_dll_', '.exe')
+            target_executable = get_target_filename(is_target_process_64, "inject_dll_", ".exe")
             if not target_executable:
-                raise RuntimeError('Could not find expected .exe file to inject dll in attach to process.')
+                raise RuntimeError("Could not find expected .exe file to inject dll in attach to process.")
 
             target_dll = get_target_filename(is_target_process_64)
             if not target_dll:
-                raise RuntimeError('Could not find expected .dll file in attach to process.')
+                raise RuntimeError("Could not find expected .dll file in attach to process.")
 
-            print('\n--- Injecting attach dll: %s into pid: %s ---' % (os.path.basename(target_dll), pid))
+            print("\n--- Injecting attach dll: %s into pid: %s ---" % (os.path.basename(target_dll), pid))
             sys.stdout.flush()
             args = [target_executable, str(pid), target_dll]
             subprocess.check_call(args)
 
             # Now, if the first injection worked, go on to the second which will actually
             # run the code.
-            target_dll_run_on_dllmain = get_target_filename(is_target_process_64, 'run_code_on_dllmain_', '.dll')
+            target_dll_run_on_dllmain = get_target_filename(is_target_process_64, "run_code_on_dllmain_", ".dll")
             if not target_dll_run_on_dllmain:
-                raise RuntimeError('Could not find expected .dll in attach to process.')
+                raise RuntimeError("Could not find expected .dll in attach to process.")
 
-            with _create_win_event('_pydevd_pid_event_%s' % (pid,)) as event:
-                print('\n--- Injecting run code dll: %s into pid: %s ---' % (os.path.basename(target_dll_run_on_dllmain), pid))
+            with _create_win_event("_pydevd_pid_event_%s" % (pid,)) as event:
+                print("\n--- Injecting run code dll: %s into pid: %s ---" % (os.path.basename(target_dll_run_on_dllmain), pid))
                 sys.stdout.flush()
                 args = [target_executable, str(pid), target_dll_run_on_dllmain]
                 subprocess.check_call(args)
 
-                if not event.wait_for_event_set(15):
-                    print('Timeout error: the attach may not have completed.')
+                if not event.wait_for_event_set(30):
+                    print("Timeout error: the attach may not have completed.")
                     sys.stdout.flush()
-            print('--- Finished dll injection ---\n')
+            print("--- Finished dll injection ---\n")
             sys.stdout.flush()
 
     return 0
@@ -324,10 +319,10 @@ def run_python_code_windows(pid, python_code, connect_debugger_tracing=False, sh
 
 @contextmanager
 def _acquire_mutex(mutex_name, timeout):
-    '''
+    """
     Only one process may be attaching to a pid, so, create a system mutex
     to make sure this holds in practice.
-    '''
+    """
     from winappdbg.win32.kernel32 import CreateMutex, GetLastError, CloseHandle
     from winappdbg.win32.defines import ERROR_ALREADY_EXISTS
 
@@ -338,8 +333,8 @@ def _acquire_mutex(mutex_name, timeout):
         if acquired:
             break
         if time.time() - initial_time > timeout:
-            raise TimeoutError('Unable to acquire mutex to make attach before timeout.')
-        time.sleep(.2)
+            raise TimeoutError("Unable to acquire mutex to make attach before timeout.")
+        time.sleep(0.2)
 
     try:
         yield
@@ -369,18 +364,17 @@ def _win_write_to_shared_named_memory(python_code, pid):
     # Note: BUFSIZE must be the same from run_code_in_memory.hpp
     BUFSIZE = 2048
     assert isinstance(python_code, bytes)
-    assert len(python_code) > 0, 'Python code must not be empty.'
+    assert len(python_code) > 0, "Python code must not be empty."
     # Note: -1 so that we're sure we'll add a \0 to the end.
-    assert len(python_code) < BUFSIZE - 1, 'Python code must have at most %s bytes (found: %s)' % (BUFSIZE - 1, len(python_code))
+    assert len(python_code) < BUFSIZE - 1, "Python code must have at most %s bytes (found: %s)" % (BUFSIZE - 1, len(python_code))
 
-    python_code += b'\0' * (BUFSIZE - len(python_code))
-    assert python_code.endswith(b'\0')
+    python_code += b"\0" * (BUFSIZE - len(python_code))
+    assert python_code.endswith(b"\0")
 
     INVALID_HANDLE_VALUE = -1
     PAGE_READWRITE = 0x4
     FILE_MAP_WRITE = 0x2
-    filemap = CreateFileMapping(
-        INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, BUFSIZE, u"__pydevd_pid_code_to_run__%s" % (pid,))
+    filemap = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, BUFSIZE, "__pydevd_pid_code_to_run__%s" % (pid,))
 
     if filemap == INVALID_HANDLE_VALUE or filemap is None:
         raise Exception("Failed to create named file mapping (ctypes: CreateFileMapping): %s" % (filemap,))
@@ -399,26 +393,34 @@ def _win_write_to_shared_named_memory(python_code, pid):
 
 
 def run_python_code_linux(pid, python_code, connect_debugger_tracing=False, show_debug_info=0):
-    assert '\'' not in python_code, 'Having a single quote messes with our command.'
+    assert "'" not in python_code, "Having a single quote messes with our command."
 
     target_dll = get_target_filename()
     if not target_dll:
-        raise RuntimeError('Could not find .so for attach to process.')
+        libdir = os.path.dirname(os.path.abspath(__file__))
+        found = [name for name in os.listdir(libdir)]
+        raise RuntimeError(
+            "Could not find .so for attach to process.\nlibdir: %s\nAvailable in dir: %s"
+            % (
+                libdir,
+                found,
+            )
+        )
     target_dll_name = os.path.splitext(os.path.basename(target_dll))[0]
 
     # Note: we currently don't support debug builds
     is_debug = 0
     # Note that the space in the beginning of each line in the multi-line is important!
     cmd = [
-        'gdb',
-        '--nw',  # no gui interface
-        '--nh',  # no ~/.gdbinit
-        '--nx',  # no .gdbinit
-#         '--quiet',  # no version number on startup
-        '--pid',
+        "gdb",
+        "--nw",  # no gui interface
+        "--nh",  # no ~/.gdbinit
+        "--nx",  # no .gdbinit
+        #         '--quiet',  # no version number on startup
+        "--pid",
         str(pid),
-        '--batch',
-#         '--batch-silent',
+        "--batch",
+        #         '--batch-silent',
     ]
 
     # PYDEVD_GDB_SCAN_SHARED_LIBRARIES can be a list of strings with the shared libraries
@@ -442,16 +444,16 @@ def run_python_code_linux(pid, python_code, connect_debugger_tracing=False, show
     #
     # The downside is that it may be dependent on the Linux version being attached to (which is the
     # reason why this is no longer done by default -- see: https://github.com/microsoft/debugpy/issues/882).
-    gdb_load_shared_libraries = os.environ.get('PYDEVD_GDB_SCAN_SHARED_LIBRARIES', '').strip()
+    gdb_load_shared_libraries = os.environ.get("PYDEVD_GDB_SCAN_SHARED_LIBRARIES", "").strip()
     if gdb_load_shared_libraries:
-        print('PYDEVD_GDB_SCAN_SHARED_LIBRARIES set: %s.' % (gdb_load_shared_libraries,))
+        print("PYDEVD_GDB_SCAN_SHARED_LIBRARIES set: %s." % (gdb_load_shared_libraries,))
         cmd.extend(["--init-eval-command='set auto-solib-add off'"])  # Don't scan all libraries.
 
-        for lib in gdb_load_shared_libraries.split(','):
+        for lib in gdb_load_shared_libraries.split(","):
             lib = lib.strip()
             cmd.extend(["--eval-command='sharedlibrary %s'" % (lib,)])  # Scan the specified library
     else:
-        print('PYDEVD_GDB_SCAN_SHARED_LIBRARIES not set (scanning all libraries for needed symbols).')
+        print("PYDEVD_GDB_SCAN_SHARED_LIBRARIES not set (scanning all libraries for needed symbols).")
 
     cmd.extend(["--eval-command='set scheduler-locking off'"])  # If on we'll deadlock.
 
@@ -459,79 +461,83 @@ def run_python_code_linux(pid, python_code, connect_debugger_tracing=False, show
     # current host).
     cmd.extend(["--eval-command='set architecture auto'"])
 
-    cmd.extend([
-        "--eval-command='call (void*)dlopen(\"%s\", 2)'" % target_dll,
-        "--eval-command='sharedlibrary %s'" % target_dll_name,
-        "--eval-command='call (int)DoAttach(%s, \"%s\", %s)'" % (
-            is_debug, python_code, show_debug_info)
-    ])
+    cmd.extend(
+        [
+            "--eval-command='call (void*)dlopen(\"%s\", 2)'" % target_dll,
+            "--eval-command='sharedlibrary %s'" % target_dll_name,
+            "--eval-command='call (int)DoAttach(%s, \"%s\", %s)'" % (is_debug, python_code, show_debug_info),
+        ]
+    )
 
     # print ' '.join(cmd)
 
     env = os.environ.copy()
     # Remove the PYTHONPATH (if gdb has a builtin Python it could fail if we
     # have the PYTHONPATH for a different python version or some forced encoding).
-    env.pop('PYTHONIOENCODING', None)
-    env.pop('PYTHONPATH', None)
-    print('Running: %s' % (' '.join(cmd)))
-    subprocess.check_call(' '.join(cmd), shell=True, env=env)
+    env.pop("PYTHONIOENCODING", None)
+    env.pop("PYTHONPATH", None)
+    print("Running: %s" % (" ".join(cmd)))
+    subprocess.check_call(" ".join(cmd), shell=True, env=env)
 
 
 def find_helper_script(filedir, script_name):
-    target_filename = os.path.join(filedir, 'linux_and_mac', script_name)
+    target_filename = os.path.join(filedir, "linux_and_mac", script_name)
     target_filename = os.path.normpath(target_filename)
     if not os.path.exists(target_filename):
-        raise RuntimeError('Could not find helper script: %s' % target_filename)
+        raise RuntimeError("Could not find helper script: %s" % target_filename)
 
     return target_filename
 
 
 def run_python_code_mac(pid, python_code, connect_debugger_tracing=False, show_debug_info=0):
-    assert '\'' not in python_code, 'Having a single quote messes with our command.'
+    assert "'" not in python_code, "Having a single quote messes with our command."
 
     target_dll = get_target_filename()
     if not target_dll:
-        raise RuntimeError('Could not find .dylib for attach to process.')
+        raise RuntimeError("Could not find .dylib for attach to process.")
 
     libdir = os.path.dirname(__file__)
-    lldb_prepare_file = find_helper_script(libdir, 'lldb_prepare.py')
+    lldb_prepare_file = find_helper_script(libdir, "lldb_prepare.py")
     # Note: we currently don't support debug builds
 
     is_debug = 0
     # Note that the space in the beginning of each line in the multi-line is important!
     cmd = [
-        'lldb',
-        '--no-lldbinit',  # Do not automatically parse any '.lldbinit' files.
+        "lldb",
+        "--no-lldbinit",  # Do not automatically parse any '.lldbinit' files.
         # '--attach-pid',
         # str(pid),
         # '--arch',
         # arch,
-        '--script-language',
-        'Python'
+        "--script-language",
+        "Python",
         #         '--batch-silent',
     ]
 
-    cmd.extend([
-        "-o 'process attach --pid %d'" % pid,
-        "-o 'command script import \"%s\"'" % (lldb_prepare_file,),
-        "-o 'load_lib_and_attach \"%s\" %s \"%s\" %s'" % (target_dll,
-            is_debug, python_code, show_debug_info),
-    ])
+    cmd.extend(
+        [
+            "-o 'process attach --pid %d'" % pid,
+            "-o 'command script import \"%s\"'" % (lldb_prepare_file,),
+            '-o \'load_lib_and_attach "%s" %s "%s" %s\'' % (target_dll, is_debug, python_code, show_debug_info),
+        ]
+    )
 
-    cmd.extend([
-        "-o 'process detach'",
-        "-o 'script import os; os._exit(1)'",
-    ])
+    cmd.extend(
+        [
+            "-o 'process detach'",
+            "-o 'script import os; os._exit(1)'",
+        ]
+    )
 
     # print ' '.join(cmd)
 
     env = os.environ.copy()
     # Remove the PYTHONPATH (if lldb has a builtin Python it could fail if we
     # have the PYTHONPATH for a different python version or some forced encoding).
-    env.pop('PYTHONIOENCODING', None)
-    env.pop('PYTHONPATH', None)
-    print('Running: %s' % (' '.join(cmd)))
-    subprocess.check_call(' '.join(cmd), shell=True, env=env)
+    env.pop("PYTHONIOENCODING", None)
+    env.pop("PYTHONPATH", None)
+    print("Running: %s" % (" ".join(cmd)))
+    subprocess.check_call(" ".join(cmd), shell=True, env=env)
 
 
 if IS_WINDOWS:
@@ -543,12 +549,12 @@ elif IS_LINUX:
 else:
 
     def run_python_code(*args, **kwargs):
-        print('Unable to attach to process in platform: %s', sys.platform)
+        print("Unable to attach to process in platform: %s", sys.platform)
 
 
 def test():
-    print('Running with: %s' % (sys.executable,))
-    code = '''
+    print("Running with: %s" % (sys.executable,))
+    code = """
 import os, time, sys
 print(os.getpid())
 #from threading import Thread
@@ -558,16 +564,16 @@ if __name__ == '__main__':
         time.sleep(.5)
         sys.stdout.write('.\\n')
         sys.stdout.flush()
-'''
+"""
 
-    p = subprocess.Popen([sys.executable, '-u', '-c', code])
+    p = subprocess.Popen([sys.executable, "-u", "-c", code])
     try:
         code = 'print("It worked!")\n'
 
         # Real code will be something as:
         # code = '''import sys;sys.path.append(r'X:\winappdbg-code\examples'); import imported;'''
         run_python_code(p.pid, python_code=code)
-        print('\nRun a 2nd time...\n')
+        print("\nRun a 2nd time...\n")
         run_python_code(p.pid, python_code=code)
 
         time.sleep(3)
@@ -580,19 +586,18 @@ def main(args):
     # in the target process.
     pid = int(args[0])
     del args[0]
-    python_code = ';'.join(args)
+    python_code = ";".join(args)
 
     # Note: on Linux the python code may not have a single quote char: '
     run_python_code(pid, python_code)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     args = sys.argv[1:]
     if not args:
-        print('Expected pid and Python code to execute in target process.')
+        print("Expected pid and Python code to execute in target process.")
     else:
-        if '--test' == args[0]:
+        if "--test" == args[0]:
             test()
         else:
             main(args)
-

debugpy-1.8.7/src/debugpy/_vendored/pydevd/pydevd_attach_to_process/attach_pydevd.py

@@ -0,0 +1,89 @@
+import sys
+import os
+
+
+def process_command_line(argv):
+    setup = {}
+    setup["port"] = 5678  # Default port for PyDev remote debugger
+    setup["pid"] = 0
+    setup["host"] = "127.0.0.1"
+    setup["protocol"] = ""
+    setup["debug-mode"] = ""
+
+    i = 0
+    while i < len(argv):
+        if argv[i] == "--port":
+            del argv[i]
+            setup["port"] = int(argv[i])
+            del argv[i]
+
+        elif argv[i] == "--pid":
+            del argv[i]
+            setup["pid"] = int(argv[i])
+            del argv[i]
+
+        elif argv[i] == "--host":
+            del argv[i]
+            setup["host"] = argv[i]
+            del argv[i]
+
+        elif argv[i] == "--protocol":
+            del argv[i]
+            setup["protocol"] = argv[i]
+            del argv[i]
+
+        elif argv[i] == "--debug-mode":
+            del argv[i]
+            setup["debug-mode"] = argv[i]
+            del argv[i]
+
+    if not setup["pid"]:
+        sys.stderr.write("Expected --pid to be passed.\n")
+        sys.exit(1)
+    return setup
+
+
+def main(setup):
+    sys.path.append(os.path.dirname(__file__))
+    import add_code_to_python_process
+
+    show_debug_info_on_target_process = 0
+
+    pydevd_dirname = os.path.dirname(os.path.dirname(__file__))
+
+    if sys.platform == "win32":
+        setup["pythonpath"] = pydevd_dirname.replace("\\", "/")
+        setup["pythonpath2"] = os.path.dirname(__file__).replace("\\", "/")
+        python_code = (
+            """import sys;
+sys.path.append("%(pythonpath)s");
+sys.path.append("%(pythonpath2)s");
+import attach_script;
+attach_script.attach(port=%(port)s, host="%(host)s", protocol="%(protocol)s", debug_mode="%(debug-mode)s");
+""".replace("\r\n", "")
+            .replace("\r", "")
+            .replace("\n", "")
+        )
+    else:
+        setup["pythonpath"] = pydevd_dirname
+        setup["pythonpath2"] = os.path.dirname(__file__)
+        # We have to pass it a bit differently for gdb
+        python_code = (
+            """import sys;
+sys.path.append(\\\"%(pythonpath)s\\\");
+sys.path.append(\\\"%(pythonpath2)s\\\");
+import attach_script;
+attach_script.attach(port=%(port)s, host=\\\"%(host)s\\\", protocol=\\\"%(protocol)s\\\", debug_mode=\\\"%(debug-mode)s\\\");
+""".replace("\r\n", "")
+            .replace("\r", "")
+            .replace("\n", "")
+        )
+
+    python_code = python_code % setup
+    add_code_to_python_process.run_python_code(
+        setup["pid"], python_code, connect_debugger_tracing=True, show_debug_info=show_debug_info_on_target_process
+    )
+
+
+if __name__ == "__main__":
+    main(process_command_line(sys.argv[1:]))