U Kyh[ @sdZddlZddlmZddlZddlmZejdddkrFedddl Z ddl Z ddl Z ddl Z ddl mZdd lmZdd lmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*dd l)m+Z+m,Z,dd l-m.Z.ddl/m0Z0ddl1m2Z2ddl1m3Z3ddl1m4Z4ddl5m6Z6m7Z7ddl8Z8ddl5m9Z9ddl5m:Z:ddl;mZ>m?Z?m@Z@ddlAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\ddl]m^Z^m_Z_ddl`maZambZbddlcmdZdddlemfZgmhZhmiZimjZjddlkmlZlmmZmmnZnddlompZpddlqmrZrddlsmtZtmuZumvZvmwZwdd lxmyZymzZzdd!l{m|Z|m}Z}m~Z~ddlZdd"lmZdd#l{mZmZejZd$ZgZeD]Zeeeqd%eZdfd&d'Zee ZdZer,dd(lmZe2jZe2jZejZzd)d*Wn YnXd+ad+ad+ad+Zd+ae.ZGd,d-d-eNZGd.d/d/eNZGd0d1d1eZGd2d3d3eZGd4d5d5eZGd6d7d7eZd8d9Zd:d;Zdgdd?ZGd@dAdAeZdidBdCZdjdDdEZdkdHdIZe4ZdJdKZdLdMZGdNdOdOeZGdPdQdQePZdRdSZdTdUZdVdWZGdXdYdYZdZd[Zd\d]Zd^d_Zdd`lmZddal5mZeeD]ZejedbqdcddZedekredS)lzF Entry point module (keep at root): This module starts the debugger. N)contextmanager)collect_return_inforzThe PyDev.Debugger requires Python 2.6 onwards to be run. If you need to use an older Python version, use an older version of the debugger.)partial) defaultdict)IS_JYTH_LESS25 IS_PYCHARM get_thread_idget_current_thread_id dict_keysdict_iter_itemsDebugInfoHolderPYTHON_SUSPEND STATE_SUSPEND STATE_RUN get_framexrangeclear_cached_thread_idINTERACTIVE_MODE_AVAILABLESHOW_DEBUG_INFO_ENVIS_PY34_OR_GREATERIS_PY36_OR_GREATERIS_PY2NULL NO_FTRACEdummy_excepthook IS_CPYTHONGOTO_HAS_RESPONSE) fix_getpass) pydev_imports pydev_log)getfilesystemencoding)is_thread_alive) threading)time)thread) pydevd_iopydevd_vm_type) pydevd_utils) pydevd_vars) overrides)ExceptionBreakpointset_fallback_excepthookdisable_excepthook) CMD_SET_BREAKCMD_SET_NEXT_STATEMENT CMD_STEP_INTO CMD_STEP_OVERCMD_STEP_RETURNCMD_STEP_INTO_MY_CODECMD_THREAD_SUSPENDCMD_RUN_TO_LINECMD_ADD_EXCEPTION_BREAKCMD_SMART_STEP_INTOInternalConsoleExecNetCommandFactoryPyDBDaemonThread_queue ReaderThreadGetGlobalDebuggerget_global_debuggerset_global_debugger WriterThread pydevd_log start_client start_serverInternalGetBreakpointExceptionInternalSendCurrExceptionTrace'InternalSendCurrExceptionTraceProceededCommunicationRolerun_as_pydevd_daemon_thread)CustomFramesContainercustom_frames_container_init)add_exception_to_frameremove_exception_from_frame)kill_all_pydev_threads)trace_dispatchglobal_cache_skipsglobal_cache_frame_skipsshow_tracing_warning)frame_eval_funcdummy_trace_dispatchshow_frame_eval_warning)set_additional_thread_info)save_main_module)ThreadingLogger AsyncioLogger send_messagecur_time) wrap_threads wrap_asyncio) get_fullnamerPathget_package_dir) DONT_TRACE)*get_abs_path_real_path_and_base_from_frameNORM_PATHS_AND_BASE_CONTAINER)r.cCs,|dkrddlm}|}tjdkr(|t_dS)Nr)breakpointhook))Z$_pydevd_bundle.pydevd_breakpointhookrhsys version_info)Zpydevd_breakpointhookrhrm0/usr/local/lib/python3.8/dist-packages/pydevd.pyinstall_breakpointhookJs   ro) PluginManagerdummyutf-8Fc@s&eZdZddZeejddZdS)PyDBCommandThreadcCs&t||j|_||_|ddS)Nzpydevd.CommandThread)r<__init___py_db_command_thread_eventpy_dbsetNameselfrvrmrmrnrt{s zPyDBCommandThread.__init__cCstd|jrdSzH|jsZz|jWntddYnX|j|jdqWnt t dYnXdS)N333333?rz#Finishing debug communication...(2)) r&sleep killReceivedrvprocess_internal_commandsrCruclearwaitr"debugrkexc_inforyrmrmrn_on_runs  zPyDBCommandThread._on_runN)__name__ __module__ __qualname__rtr,r<rrmrmrmrnrsysrsc@s8eZdZddZeejddZd ddZdd Zd S) CheckOutputThreadcCs$t|||_|dd|_dS)Nzpydevd.CheckAliveThreadF)r<rtrvrwdaemonrxrmrmrnrts  zCheckOutputThread.__init__cCsx|jsttd|jsh|jjrhztd|j t Wnt YnX| d|_|jqdS)Nrzz)No threads alive, finishing debug sessionT)r|r&r{rvhas_threads_alivewriteremptyr"rfinish_debugging_sessionrO traceback print_excwait_pydb_threads_to_finishcheck_output_redirectrrmrmrnrs    zCheckOutputThread._on_run?csvtdj}t}t||krPt|dkrD|drDdStdqtddfdd|DdS)Nz)Waiting for pydb daemon threads to finishre{Gz?z9The following pydb threads may not finished correctly: %sz, csg|]}|k r|qSrm)getName.0trrmrn szACheckOutputThread.wait_pydb_threads_to_finish..)r"rcreated_pydb_daemon_threadsr&lengetr{join)rytimeoutZpydb_daemon_threadsZ started_atrmrrnrs  z-CheckOutputThread.wait_pydb_threads_to_finishcCs d|_dSNT)r|rrmrmrndo_kill_pydev_threadsz&CheckOutputThread.do_kill_pydev_threadN)r) rrrrtr,r<rrrrmrmrmrnrs   rc@s@eZdZdZddZddZddZdd Zd d Zd d Z dS) TrackedLockzGThe lock that tracks if it has been acquired by the current thread cCs t|_t|_d|j_dSNF)r' allocate_lock_lockr%local_tlsis_lock_acquiredrrmrmrnrts  zTrackedLock.__init__cCs|jd|j_dSr)racquirerrrrmrmrnrs zTrackedLock.acquirecCs|jd|j_dSr)rreleaserrrrmrmrnrs zTrackedLock.releasecCs |dSN)rrrmrmrn __enter__szTrackedLock.__enter__cCs |dSr)r)ryexc_typeexc_valexc_tbrmrmrn__exit__szTrackedLock.__exit__cCs|jjSr)rrrrmrmrnis_acquired_by_current_threadsz)TrackedLock.is_acquired_by_current_threadN) rrr__doc__rtrrrrrrmrmrmrnrsrc@sbeZdZdZdddddddgZd Zd d Zd d ZddZddZ ddZ ddZ e ddZ dS)"AbstractSingleNotificationBehaviora The basic usage should be: # Increment the request time for the suspend. single_notification_behavior.increment_suspend_time() # Notify that this is a pause request (when a pause, not a breakpoint). single_notification_behavior.on_pause() # Mark threads to be suspended. set_suspend(...) # On do_wait_suspend, use notify_thread_suspended: def do_wait_suspend(...): with single_notification_behavior.notify_thread_suspended(thread_id): ... _last_resume_notification_time_last_suspend_notification_timer_next_request_time_suspend_time_request_suspended_thread_ids_pause_requestedrcCsBttt|_d|_d|_||_t |_ t |_ d|_ dS)NF)rnext itertoolscountrrrrr'rrsetrrrrmrmrnrts  z+AbstractSingleNotificationBehavior.__init__cCs tddSNz#abstract: subclasses must override.AssertionErrorry thread_id stop_reasonrmrmrnsend_suspend_notificationszd?Z"d@dAZ#dBdCZ$dxdDdEZ%dFdGZ&dydHdIZ'dJdKZ(dLdMZ)dNdOZ*dPdQZ+dRdSZ,dTdUZ-dVdWZ.dzdXdYZ/dZd[Z0d\d]Z1d^d_Z2d`daZ3dbdcZ4dddeZ5d{dfdgZ6dhdiZ7d|djdkZ8dldmZ9dndoZ:dpdqZ;eZ>e?Z?dS)}PyDBa8 Main debugging class Lots of stuff going on here: PyDB starts two threads on startup that connect to remote debugger (RDB) The threads continuously read & write commands to RDB. PyDB communicates with these threads through command queues. Every RDB command is processed by calling process_net_command. Every PyDB net command is sent to the net by posting NetCommand to WriterThread queue Some commands need to be executed on the right thread (suspend/resume & friends) These are placed on the internal command queue. TcCs|rt|td|_d|_d|_d|_d|_t|_ t t j |_ i|_d|_i|_i|_i|_i|_d|_t|_t|_t|_|r|jt_d|_d|_d|_ tj!|_!d|_"d|_#d|_$d|_%d|_&d|_'d|_(d|_)i|_*d|_+i|_,d|_-d|_.d|_/d|_0d|_1d|_2d|_3i|_4i|_5d|_6t78|_8t79|_9d|_:d|_;d|_t?||_@tA|_BtC|_Dd|_EtF|_Fd|_GdS)NrFTrm)HrApydevd_tracingZreplace_sys_set_trace_funcreaderroutput_checker_threadpy_db_command_threadZquittingr;rrr=Queue _cmd_queue breakpointsmtimeZfile_to_id_to_line_breakpointZfile_to_id_to_plugin_breakpointbreak_on_uncaught_exceptionsbreak_on_caught_exceptions ready_to_runr _main_lockr'r_lock_running_thread_idsr%EventrurK_finish_debugging_sessionZ_termination_event_setsignature_factorySetTraceZ)skip_on_exceptions_thrown_in_same_contextZ7ignore_exceptions_thrown_in_lines_with_ignore_exceptionZ$skip_suspend_on_breakpoint_exceptionZskip_print_breakpoint_exceptionZdisable_property_traceZdisable_property_getter_traceZdisable_property_setter_traceZdisable_property_deleter_trace_running_thread_idsZ_set_breakpoints_with_idZ.filename_to_lines_where_exceptions_are_ignoredpluginhas_plugin_line_breakshas_plugin_exception_breaksthread_analyserasyncio_analyser mpl_in_usempl_hooks_in_debug_consolempl_modules_for_patchingZ_filename_to_not_in_scopeZfirst_breakpoint_reachedr*Zis_filter_enabledZis_filter_librariesZshow_return_valuesZremove_return_values_flagredirect_outputZuse_frame_eval stop_on_startr&_threads_suspended_single_notificationr_local_thread_trace_funcdict#process_created_msg_received_eventscommunication_rolerstop_on_failed_tests)ryZ set_as_globalrmrmrnrtosx       z PyDB.__init__cCs,z |jj}Wntk r&|j}YnX|Sr)rthread_trace_funcAttributeErrorrP)ryrrmrmrnget_thread_local_trace_funcs   z PyDB.get_thread_local_trace_funcNFcCsvt|jdk r<|t|jtr8|r8t|jdS|dkrN|}n||j_ t|trr|rrt|dS)aT Enables tracing. If in regular mode (tracing), will set the tracing function to the tracing function for this thread -- by default it's `PyDB.trace_dispatch`, but after `PyDB.enable_tracing` is called with a `thread_trace_func`, the given function will be the default for the given thread. N) r.rTrrrUrZset_trace_to_threadsrrr)ryrapply_to_all_threadsrmrmrnenable_tracings      zPyDB.enable_tracingcCstddSr)rrrrmrmrndisable_tracingszPyDB.disable_tracingcCs(|js dS|jd7_|s$|dS)zh When breakpoints change, we have to re-evaluate all the assumptions we've made so far. Nre)rr!set_tracing_for_untraced_contexts)ryZremovedrmrmrnon_breakpoints_changeds zPyDB.on_breakpoints_changedc Csd}|rt}tddtD}trVt}|D]\}}||kr8||q8nlt}zR|D]H}|j |ksb||krzqbt |} | |}z|dk r||W5d}XqbW5d}d}d}d} XdS)Ncss,|]$}t|ddst|ddr|jVqdS)is_pydev_daemon_threadFpydev_do_not_traceN)getattridentrrmrmrn s z9PyDB.set_tracing_for_untraced_contexts..) r%current_threadrthreadingEnumeraterrk_current_framesitemsset_trace_for_frame_and_parentsrrWget_topmost_frame) ryignore_current_threadZ ignore_threadZignore_thread_idsZ tid_to_framerframethreadsradditional_informrmrnrs4  z&PyDB.set_tracing_for_untraced_contextscCs|jjSrrrrrmrmrnr.sz&PyDB.multi_threads_single_notificationcCs ||j_dSrr)rynotifyrmrmrnr2scCs|jdkrtrt||_|jSr)rSUPPORT_PLUGINSrprrmrmrnget_plugin_lazy_init6s zPyDB.get_plugin_lazy_initcCs t|Sr)r*Zin_project_rootsryfilenamermrmrnin_project_scope;szPyDB.in_project_scopecCs t|Sr)r*Zis_ignored_by_filterrrmrmrnis_ignored_by_filters>szPyDB.is_ignored_by_filterscCs t|Sr)r*#is_exception_trace_in_project_scoperytracermrmrnrAsz(PyDB.is_exception_trace_in_project_scopecCs t|Sr)r*#is_top_level_trace_in_project_scoperrmrmrnrDsz(PyDB.is_top_level_trace_in_project_scopecCs t|Sr)r*is_test_item_or_set_up_caller)ryr rmrmrnrGsz"PyDB.is_test_item_or_set_up_callercCs d|_dSr)rrrmrmrnset_unit_tests_debugging_modeJsz"PyDB.set_unit_tests_debugging_modecCsFtD]8}t|tr tdt|r|r:t|drdSqdS)NWError in debugger: Found PyDBDaemonThread not marked with is_pydev_daemon_thread=True. Z__pydevd_main_threadTF) r*get_non_pydevd_threads isinstancer<r" error_oncer$isDaemonhasattr)ryrrmrmrnrMs  zPyDB.has_threads_alivecCs d|_dSr)rrrmrmrnrYszPyDB.finish_debugging_sessioncCsRz|dWn YnXt||_t||_|j|jtddS)N皙?) settimeoutrBrr>rstartr&r{)rysockrmrmrninitialize_network]s    zPyDB.initialize_networkcCs6|rtj|_t||}ntj|_t|}||dSr)rIZCLIENTrrDSERVERrEr()ryhostportsrmrmrnconnectis  z PyDB.connectcCs*|dr ||ddd}|j|S)zm returns internal command queue for a given thread. if new queue is created, notify the RDB about it Z __frame__|reN) startswithrfindrrrmrmrnget_internal_queuets zPyDB.get_internal_queuecCs||}||dS)z) if thread_id is *, post to the '*' queueN)r1put)ryint_cmdrqueuermrmrnpost_internal_command{s zPyDB.post_internal_commandcCs*|a|a|p||_trttr&tdSr)bufferStdOutToServerbufferStdErrToServerrinit_stdout_redirectinit_stderr_redirect)ryredirect_stdoutredirect_stderrrmrmrnenable_output_redirections zPyDB.enable_output_redirectioncCstr ttrtdSr)r6r8r7r9rrmrmrnrszPyDB.check_output_redirectcCs4ddlm}t|jD]}|||j|qdS)Nr)import_hook_manager)Z_pydev_bundle.pydev_import_hookr=r rZadd_module_namepop)ryr=modulermrmrn init_matplotlib_in_debug_consoles z%PyDB.init_matplotlib_in_debug_consolecsbddlmm}m}mGdddfdd}ddlm}||fdd ||d |_dS) Nr)activate_matplotlibactivate_pylabactivate_pyplot do_enable_guic@seZdZdZdS)z7PyDB.init_matplotlib_support.._MatplotlibHelperFN)rrr_return_control_oscrmrmrmrn_MatplotlibHelpersrFcsj _jSr)rErm)rFrmrnreturn_controls z4PyDB.init_matplotlib_support..return_control)set_return_control_callbackcsSrrmrm)rArDrmrnz.PyDB.init_matplotlib_support..)Z matplotlibzmatplotlib.pyplotZpylab)Zpydev_ipython.matplotlibtoolsrArBrCrDpydev_ipython.inputhookrHr)ryrBrCrGrHrm)rFrArDrninit_matplotlib_supports   zPyDB.init_matplotlib_supportcCsDt|jdkr@t|jD]&}|tjkr|j|}|d|_qdS)NrT)rrr rkmodulesr>r)ryr?Zactivate_functionrmrmrn_activate_mpl_if_neededs   zPyDB._activate_mpl_if_neededcCs2z ddlm}|}|r|Wn YnXdS)Nr) get_inputhook)rKrO)ryrOZ inputhookrmrmrn_call_mpl_hooks  zPyDB._call_mpl_hookc Cs~|jdkrdS|r|jntD||jkr6W5QRdSt|}|jrRW5QRdS||j|<W5QRX|j|j|dSr) rrrrrWpydev_notify_killrrZmake_thread_created_message)ryrr'use_lockrrmrmrnnotify_thread_createds  zPyDB.notify_thread_createdc Csx|jdkrdS|r|jnt>|j|d}|dkrBW5QRdS|jj}|sVd|j_W5QRX|j|j |dS)z: if thread is not alive, cancel trace_dispatch processing NT) rrrrr>rrQrrmake_thread_killed_message)ryrrRr'Z was_notifiedrmrmrnnotify_thread_not_alives zPyDB.notify_thread_not_alivec CsV|jD|i}t}g}|j|D]}t|ddr>q,t|trTtdq,t |r,|j s|D]D}t |}t |t |}||krft |rft |}t ||qft |}|||<|j||ddq,t|j } | D]}||kr||q|D]}|j|ddqW5QRXt|dkrR||D]}t|dr4|q4ntt} | dfD]}||} g} z| d} |jst| trz| d|_!Wnt"d d t#$YnXd|_| %| rt"d d t&| | '|nt"d d t&| | | qxWn.t(j)k rB| D]} | *| q,YnXqdW5QRXd S)z2This function processes internal commands rFr)rRrr*Trz*Matplotlib support in debug console failedzprocessing internal command z NOT processing internal command N)+rrrrrr r<r"r!r$rr rr+Zhas_additional_frames_by_idZget_additional_frames_by_idadd_additional_frame_by_idrSlistkeysappendrUrrr#rr threadingCurrentThreadr1rrr:r@rrCr format_excZcan_be_executed_bystrdo_itr=Emptyr2)ryZprogram_threads_alive all_threadsZprogram_threads_deadrZexisting_threadZ old_thread_idrZ frames_by_idZ thread_idsZcurr_thread_idr4Zcmds_to_add_backr3rmrmrnr}sp               zPyDB.process_internal_commandscCs4i}t|D]\}}|||j<q |||<|dSr)rlineclear_skip_caches)ryfileZid_to_breakpointrZ break_dictZ breakpoint_idZ pybreakpointrmrmrnconsolidate_breakpointsIs  zPyDB.consolidate_breakpointscCsttdSr)rQr~rRrrmrmrnrbQszPyDB.clear_skip_cachesc Cszt|||||||}Wn&tk r>td|fYdSX|jrx|j} || |<tjdkrrtd| f| |_|j r|j } || |<tjdkrtd| f| |_ |S)NzQError unable to add break on exception for: %s (exception could not be imported) rz$Exceptions to hook on terminate: %s zExceptions to hook always: %s ) r- ImportErrorr"errornotify_on_unhandled_exceptionsrcopyrDEBUG_TRACE_BREAKPOINTSnotify_on_handled_exceptionsr) ry exception condition expressionrjrgZnotify_on_first_raise_onlyZignore_librariesZebcprmrmrnadd_break_on_exceptionUs4      zPyDB.add_break_on_exceptioncCs.t|}t|_||_|jdkr$t|_t|_|S)Nr)rWr suspend_typerpydev_step_cmdr2r pydev_state)ryr'rinformrmrn _mark_suspend}s zPyDB._mark_suspendc Cs|j|r|j|||}|rP||}|dk rPz||W5d}X|tkrz|jdk rz|j}d|_||||s|j rd}|rt }|D]P} t | ddrq| |krq|| t }|| }|dk rz||W5d}XqdS)a :param thread: The thread which should be suspended. :param stop_reason: Reason why the thread was suspended. :param suspend_other_threads: Whether to force other threads to be suspended (i.e.: when hitting a breakpoint with a suspend all threads policy). :param is_pause: If this is a pause to suspend all threads, any thread can be considered as the 'main' thread paused. NTr)rrrrtr r r0Z conditional_breakpoint_exception$_send_breakpoint_condition_exceptionrr*rrr6) ryr'rZsuspend_other_threadsZis_pausersr &conditional_breakpoint_exception_tupler`rrmrmrn set_suspends:         zPyDB.set_suspendcCs<t|}|r8t|dkr8|\}}t|||}|||dS)zoIf conditional breakpoint raises an exception during evaluation send exception details to java rN)r rrFr5)ryr'rvrrZ stacktracer3rmrmrnrus  z)PyDB._send_breakpoint_condition_exceptioncCs$t|}t|||}|||dS)zSends details on the exception which was caught (and where we stopped) to the java side. arg is: exception type, description, traceback object N)r rGr5)ryr'argZ curr_frame_idrr3rmrmrnsend_caught_exception_stacks z PyDB.send_caught_exception_stackcCs(t|}t|}||||dS)zXSends that some thread was resumed and is no longer showing an exception trace. N)r rHr5r})ryr'rr3rmrmrn%send_caught_exception_stack_proceededs z*PyDB.send_caught_exception_stack_proceededcCs|j}|j|dS)z=Sends a message that a new process has been created. N)rmake_process_created_messagerrrycmdrmrmrnsend_process_created_messages z!PyDB.send_process_created_messagecCsZ|jtjkrV|jr$tddS|j}t }||j |j <|j ||dS)aFWhen `PyDB` works in server mode this method sends a message that a new process is going to be created. After that it waits for the response from the IDE to be sure that the IDE received this message. Waiting for the response is required because the current process might become substituted before it actually sends the message and the IDE will not try to connect to `PyDB` in this case. When `PyDB` works in client mode this method does nothing because the substituted process will try to connect to the IDE itself. z/Skip sending process substitution notification N)rrIr)rrr"rrr{r%rrseqrrr)ryr}eventrmrmrn send_process_will_be_substituteds      z%PyDB.send_process_will_be_substitutedc Cshd}d}|j}|dks|dkr^|jj}|dkr2d}|dksB||krZ|} |j|_| |_d}nd}|||fS) NFrark)?zrVTz.jump is available only within the bottom frame)f_linenof_codeco_namerPf_trace) ryr r func_name next_linestop response_msgold_lineZcurr_func_namerarmrmrnset_next_statementszPyDB.set_next_statementcCs|jzlzRt}|D]B}t|ddrt|drt|dr|j|kr|j|kr|j qWnt YnXW5|jXdS)NrF cancel_eventr) rrrrrr#rframe_idrrrr)ryrrr`rrmrmrncancel_async_evaluations  zPyDB.cancel_async_evaluationc Cs<|d}t|}|j} |jj} |r|jj} d|j_i} |rb|d} | dk rb| j| | j<| j} qF|j j ||| | | | d}| |j }|j |tjjg}ttjD]T\}}|j|jkr|j |j ||j|j |j ||jtd| ||qW5QRX|j|| |||||| |W5QRXdS)a busy waits until the thread state changes to RUN it expects thread's state as attributes of the thread. Upon running, processes any outstanding Stepping commands. :param is_unhandled_exception: If True we should use the line of the exception instead of the current line in the frame as the paused location on the top-level frame (exception info must be passed on 'arg'). rrrN)frame_to_lineno)r}r rrZtrace_suspend_type pydev_message tb_linenotb_frametb_nextrZmake_thread_suspend_messager~thread_stack_strrrrKcustom_frames_lockr custom_framesrrZ!make_custom_frame_created_messagenamer r6rZrr_do_wait_suspend)ryr'r rrxsend_suspend_messageis_unhandled_exceptionrrrrpmessagertbr}from_this_threadr custom_framermrmrndo_wait_suspend+s6    zPyDB.do_wait_suspendc Cs|j}|jtkrP|jsP||jtkrP|jsP|jr<||t dq| t |t t ||jtks||jtkrd|_d|j_n|jtkr||_d|j_||n|jtkr||d|_||j_n|jtks|jtkrN||d}d} |j} tsZ||||j|j\}} } |rLd|_t|_t|_| ||||||dSnzPz||||j|j\}} } Wn,t'k r}z d|} W5d}~XYnXW5t!r|j"} |j#$| || } |j%&| d|_"X|r"|j#(t ||j} |j%&| t|_t|_|)||||dSd|_t|_t|_|j)||||dddSn@|jt*kr|j+}|dk r|||_||nd|_d|_t,|_~|j#(t ||j} |j%&| t-j.&|D]}|j%&|j#/|qW5QRXdS)NrFrrz%s)r)0rrrrrrNrrPr}r&r{rr r]idrqr2r5pydev_step_stopZpydev_smart_step_contextZsmart_step_stopr3r r9r7r1rr rZpydev_func_nameZpydev_next_liner6rrrrrZ"make_set_next_stmnt_status_messagerr ValueErrorZmake_thread_run_messagerr4f_backrrKrrT)ryr'r rrxrprrsrrr_rr}eZ back_framerrmrmrnrZs             zPyDB._do_wait_suspendc Cstdt|}t|||\}}}t|}tjt krHt |||t zxz.t||||t|j||d|ddWnDtk r} z| W5d} ~ XYn td|dfYnXW5t |t |d}XdS)NzWe are stopping in post-mortem rkT)rz5We've got an error while stopping in post-mortem: %s r)r"rr r+rWr*Z$get_top_level_trace_in_project_scoperk excepthookroriginal_excepthookr/rNZremove_additional_frame_by_idrMrwr8rKeyboardInterruptrf) ryr'r Z frames_byidrxrexctypevaluerrrmrmrnstop_on_unhandled_exceptions(         z PyDB.stop_on_unhandled_exceptioncKs|dd}|rt|dk rzt|jj}Wnt|}YnXt|d}|dkr|rv|jdk r|jtk rt|_n|j|j k r|j |_|j }q~dS)NdisableFr) r>rrdr co_filenamerc get_file_typerrrPr)ryr kwargsrZabs_path_real_path_and_base file_typermrmrnr s    z$PyDB.set_trace_for_frame_and_parentscCs0|j}|dk r|t|}|_|dSr)rrrsr&)ryZcurr_pydb_command_threadZnew_pydb_command_threadrmrmrn_create_pydb_command_threads z PyDB._create_pydb_command_threadcCs0|j}|dk r|t|}|_|dSr)rrrr&)ryZcurr_output_checker_threadrrmrmrn_create_check_output_threads z PyDB._create_check_output_threadcCs||dSr)rrrrmrmrnstart_auxiliary_daemon_threadssz#PyDB.start_auxiliary_daemon_threadscCsl||js"|jdk s"|jdk r0|d|_||rHt|j t sPt rh|j d}|j|dS)zO Shared code to prepare debugging by installing traces and registering threads Ncython)rrrrrrT patch_threadsrrrPrSrVrZmake_show_warning_messagerr)ryZenable_tracing_from_startr}rmrmrnprepare_to_runs  zPyDB.prepare_to_runcCs4zt|jWn YnXddlm}|dS)Nr)patch_thread_modules)r%settracerP_pydev_bundle.pydev_monkeyr)ryrrmrmrnrs  zPyDB.patch_threadsc Csvd}d}|r@dtjkr&tjdd|d\}}}|}t|} | dkrt|} | dkrntjd|dStd|} | dkrtjd|dS| }n| }tj | } tj | d} tj | d} | drtj | r| } ntj | r| } n@| d r6tj | r$tj | s$| } ntj | r6| } | tj d<tj|rntj |d} tj| rn| }d}|dkrt|d }|j}z t|d <Wntk rYnX|dkr|}tjddkr|dk r|jtjdrtjd=|stjdtjt|d|rb|js4td q|jsT|jsT|jsT|jrZd|_| t!}t"|}|j#dk rt$|j#%t&t'd d|(|dd|ddt)|d |j*dk rt+rt,t'dddddd|dddd zt-r|.Wn tjdt/0YnXt1tdr0t2|3|||j4rTt5|}t6|j7_8|rb|9|:||||||S)Nrr:zNo module named %s z %s.__main__z __main__.pyz __main__.pycz __init__.pycz __init__.pypydevd __builtins__r$Zthreading_eventr'r&re)parentZ asyncio_eventTaskr)r rz&Matplotlib support in debugger failed exc_clear);rkpathinsert partitionr_rastderrwriteosdirnamerendswithexistsargvisdirisfilerX__dict__r NameError__file__r/splitr`rr&r{rrrrrTrr[r rr]Zset_start_timer\r[rr rrr^rrLrrr#rrSrrWr5rrqr_exec)ryrcglobalslocals is_module set_trace module_nameentry_point_fnrrZmod_dirZmain_pyZmain_pyc new_targetmrrrsrmrmrnruns             . $     zPyDB.runc Cs|st|||nx|r>t|d|g||d}t||}|nNddl} t| drtjdddkrr| j|ddq| j|dd n | ||S) zs This function should have frames tracked by unhandled exceptions (the `_exec` name is important). r)levelfromlistrrN_run_module_as_mainrrF)Z set_argv0) alter_argv) r!Zexecfile __import__rrunpyr#rkrlr run_module) ryrrrrcrrmodfuncrrmrmrnrs   z PyDB._execcCs6tjtj||j}|j|dSr) rkstdoutflushrrrZmake_exit_messagerrr|rmrmrnexitings    z PyDB.exitingc Cs|t}ddlm}|dd|dtj tj t ||}t |}t |t||i|j||}|j||jr||tdq|dS)Nr)pydevd_frame_utilsrConsoler)rNr% currentThread_pydevd_bundlerFrameZFCoderrabspathrrr r+rWrrZmake_show_console_messagerrrrPr}r&r{)ryrr'rr rr}rmrmrnwait_for_commandss"  zPyDB.wait_for_commands)T)NF)F)F)T)T)F)FF)TF)T)NNFT)@rrrrrtrrrrrpropertyrsetterrrrrrrrrrr(r-r1r5r<rr@rLrNrPrSrUr}rdrbrortrwruryrzr~rrrrrrr rrrrrrrrr_trace_dispatchrPrTrUrmrmrmrnr`s~ d   (         ] ( >   /c  rcCsd|d<d|d<d|d<dS)NTDEBUG_RECORD_SOCKET_READSreririDEBUG_TRACE_LEVELrmsetuprmrmrn set_debugsrcCsddlm}||dS)Nr)pydev_monkey_qt) _pydev_bundlerZpatch_qt)Zqt_support_moderrmrmrnenable_qt_supports rcCst|dS)zE Helper to dump thread info (default is printing to stderr). N)r* dump_threads)streamrmrmrnrsrcCs*tjdtjd|r&tddS)NzUsage: zUpydevd.py --port N [(--client hostname) | --server] --file executable [file_options] r)rkrrexit)ZdoExitrmrmrnusages  rc@s&eZdZdddZddZddZdS) _CustomWriterNcCs>t|dtjdd|_||_|r4t||d|d|_||_dS)a :param out_ctx: 1=stdout and 2=stderr :param wrap_stream: Either sys.stdout or sys.stderr. :param bool wrap_buffer: If True the buffer attribute (which wraps writing bytes) should be wrapped. :param callable(str) on_write: May be a custom callable to be called when to write something. If not passed the default implementation will create an io message and send it through the debugger. encodingPYTHONIOENCODINGrrF) wrap_bufferon_writeN) rrenvironrr_out_ctxrbuffer _on_write)ryZout_ctxZ wrap_streamrrrmrmrnrts z_CustomWriter.__init__cCsdSrrmrrmrmrnrsz_CustomWriter.flushcCs|jdk r||dS|r|tr8t|trR|dd}nt|trR|j|jdd}t}|dk r||j ||j }|j |dS)Nrrreplace)errors)rrr unicodeencodebytesdecoderr@rZmake_io_messagerrr)ryr,rvr}rmrmrnrs    z_CustomWriter.write)N)rrrrtrrrmrmrmrnrs rcCsHttdsDtsdnd}tj}td|||t_|t_t|tj|t_dS)N_pydevd_out_buffer_TFre) r#rkrrrr Zstdout_originalr( IORedirectorrroriginalrmrmrnr8*s   r8cCsHttdsDtsdnd}tj}td|||t_|t_t|tj|t_dS)N_pydevd_err_buffer_TFr) r#rkrrrrZstderr_originalr(rrrmrmrnr92s   r9.Tc Cs2tzt||||||||W5tXdS)aSets the tracing function with the pydev debug function and initializes needed facilities. @param host: the user may specify another host, if the debug server is not in the same machine (default is the local host) @param stdoutToServer: when this is true, the stdout is passed to the debug server @param stderrToServer: when this is true, the stderr is passed to the debug server so that they are printed in its console and not in this process console. @param port: specifies which port to use for communicating with the server (note that the server must be started in the same port). @note: currently it's hard-coded at 5678 in the client @param suspend: whether a breakpoint should be emulated as soon as this function is called. @param trace_only_current_thread: determines if only the current thread will be traced or all current and future threads will also have the tracing enabled. @param overwrite_prev_trace: deprecated @param patch_multiprocessing: if True we'll patch the functions which create new processes so that launched processes are debugged. @param stop_at_frame: if passed it'll stop at the given frame, otherwise it'll stop in the function which called this method. N)_set_trace_lockrr_locked_settrace) r*stdoutToServerstderrToServerr+suspendtrace_only_current_threadoverwrite_prev_tracepatch_multiprocessing stop_at_framermrmrnr>s% rcCs|r*zddlm}Wn Yn X|it_ts>ttj dkr`|dt ||d} | t_ t } | ||da|a |at rttrtt| t} t| } | jstdq| tjtjz$ttjD]\} }| |j qW5tjX| !| j"dd|s2| #| j$ddt%&t'n8t(} | tjt} t| } | "|sv| #|r|dk rt)| _*t+| _,|| _-t.| _/n | 0| t1dS) Nr pydev_monkeyF)clientserverr+ multiprocessTr$)r)r )2rrpatch_new_process_functionsr<r connectedr) setup_type SetupHolderrintrr-r6r7r8r9 patch_stdinr[rWrr&r{r rrrKrrrrrr rrrratexitregister stoptracer@rrrr3rqrrrprwr0)r*rrr+rrrrrrdebuggerrrZ_frameIdrrmrmrnrvsp          rcCsttrpttdztdWn YnXddlm}|t}|rl|j t dd| t dadS)Nr)undo_patch_thread_modulesT)rF) r"rrestore_sys_set_trace_funcrkrr%rr+r@r rrrO)r+r*rmrmrnr)s  r)c@s$eZdZddZddZddZdS) DispatchercCs d|_dSr)r+rrmrmrnrtszDispatcher.__init__cCs<||_||_t|j|j|_t||_d|j_|jdSr)r*r+rDrDispatchReaderrrr)ryr*r+rmrmrnr-s  zDispatcher.connectcCs z|jWn YnXdSr)rrrrmrmrnclose szDispatcher.closeN)rrrrtr-r/rmrmrmrnr-sr-c@s6eZdZddZeejddZddZddZd S) r.cCs||_t||jjdSr) dispatcherr>rtr)ryr0rmrmrnrtszDispatchReader.__init__cCst}d|_t|Sr)r%rrr>r)ry dummy_threadrmrmrnrszDispatchReader._on_runcCst|dSr)r> handle_exceptrrmrmrnr2szDispatchReader.handle_exceptcCs|dkrt||j_d|_dS)NcT)r%r0r+r|)ryZcmd_idrtextrmrmrnprocess_commands zDispatchReader.process_commandN) rrrrtr,r>rr2r5rmrmrmrnr.s  r.cCs |ddS)z The new connection dispatch approach is used by PyDev when the `multiprocess` option is set, the existing connection approach is used by PyCharm when the `multiproc` option is set. multiprocF)rrrmrmrn_should_use_existing_connection%sr7cCsNtj}|d}|d}t|rFt}z||||j}W5|X||fS)Nrr+)r$rr7r-r/r-r+)rr*r+r0rmrmrndispatch-s   r8cCstddlm}d|_ddlm}t\}}ddl}||dk rpdada t |dk r\|t ||ddddddS)zo When creating a fork from a process in the debugger, we need to reset the whole debugger environment! r)GlobalDebuggerHolderN)clear_thread_local_infoFT)r+rrrr) _pydevd_bundle.pydevd_constantsr9Z global_dbg)_pydevd_frame_eval.pydevd_frame_eval_mainr:r8rr,r"forkedrLr)r9r:r*r+rrmrmrnsettrace_forked;s(   r>c@seZdZdZdS)r$N)rrrrrmrmrmrnr$_sr$cCspddd}|||}t}|drXttjjkrDtjdnddl m }||_ |drlt |dd S) z/ :type setup_options: dict[str, bool] Fr)save-signatures qt-supportr?zACollecting run-time type information is not supported for Jython r)SignatureFactoryr@N) updater?r)Z get_vm_typeZ PydevdVmTypeZJYTHONrkrrZ_pydevd_bundle.pydevd_signaturerArr)Z setup_optionsZdefault_optionsr*rArmrmrnapply_debugger_optionsds   rCcCs"ddlm}tj}|||t_dS)Nr)DebugConsoleStdIn)Z_pydev_bundle.pydev_stdinrDrkstdin)r*rDZ orig_stdinrmrmrnr&zs r&cCst}|sdS|t\}}}|rN|jjj}||rFd|krFqN|j}q$|rd}|j}|rr|j|jkrrd}|r|jjj}t t j |sd|krq|d7}|jr|jj|jk r|j}qrqqrz| |}Wntk r||_YnXd|_tjt||||dtdS)NZ_pydevdre)limit)r@rrkrrrrrrrrrbasenamewith_tracebackr __traceback__ __cause__rprint_exceptiontyper/)r*rrrrrFrrmrmrnhandle_keyboard_interrupts<   rM)DebuggerEventHandler)pydevd_extension_utils)Zdebugger_versionc Csz ddlm}|tj}|t_Wn$tk rDtt dYnX|drzdt }Wnd}YnXtj d|ttd|d td ttjt|d dtrt||d tjt_|d tjt_|dtjt_|d}|d}|d }d}t}zddlm}WnYnX|drT|n|drtdt} zz| !||| j"dk r| j"}td|t#dt z |Wnt$dtYnXn t$dW5| Xn@z |%Wnt$dtYnX|&ddkr8t j'(|)dr8t j'*|} t j'+| d} t j',| r8zt-| d} z| ./D]} | 0} | )dr| dd0} | 1d d}|2d!}t3|ddkrd"}n(t3|ddkrt3|dd#krd"}qqW5| XWntYnXzdd$l4m5}|6Wn&z t7Wn YnXYnX|d%}t8||r$tj d&t j'*t9}t j'+|d'}tj:dd(|ddl;}t9|d)<tj:d*d+|<|tj:d,d-tj:d.d/|j=|d dd|dd0n|d1r6t>|_?|d2rNt@rNtA|_BtC|z|!||Wn2tj d3||fttDdYnXd"aEz|=|d dd|}Wn,tFk r}z tGW5d}~XYnX|d4r|H|dS)5Nr)process_command_linerezprint-in-debugger-startupz (pid: %s)rzpydev debugger: starting%s zExecuting file %srcz arguments: %sZvm_typerrirr+rFrr r6zStarted in multiproc mode zReceived port %d z)pydev debugger: process %d is connecting z!Error patching process functions z8pydev debugger: couldn't get port for new debug process zdev_appserver.pyrVERSIONrzrelease:"rgTrj)pydevd_stacklessr?z6pydev debugger: google app engine integration enabled z!pydev_app_engine_debug_startup.pyz--python_startup_script=rrz--python_startup_args=%sriz--automatic_restart=norfz--max_module_instances=1)rzsave-threadingz save-asynciozCould not connect to %s: %s zcmd-line)IZ+_pydevd_bundle.pydevd_command_line_handlingrPrkrr$rrrrrrgetpidrrr r"rr]r)r#rrrrrrirrrrr!r-r/r-r+rsrfZ(patch_new_process_functions_with_warningfindrrGr/rrropenread splitlinesstriprrr%rrUZpatch_stacklessrr&rrjsondumpsrrYrrrZrrCrr"rrMr)rPrpidr+r*fZfix_app_engine_debugr*rr0Z appserver_dirZ version_filerraversionrUrZcurr_dirZapp_engine_startup_filer\rrrmrmrnmains                            ra__main__)N)N)r)N)N) NFFrTFFFN)rrk contextlibrrZ-_pydevd_bundle.pydevd_collect_try_except_inforrl RuntimeErrorrr'rr functoolsr collectionsrr;r r r r r rrrrrrrrrrrrrrrrrrrr r!r"Z(_pydev_bundle._pydev_filesystem_encodingr#Z#_pydev_bundle.pydev_is_thread_aliver$Z _pydev_imps._pydev_saved_modulesr%r&r'rr(r)rr*r+Z_pydev_bundle.pydev_overrider,Z!_pydevd_bundle.pydevd_breakpointsr-r.r/Z_pydevd_bundle.pydevd_commr0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJZ#_pydevd_bundle.pydevd_custom_framesrKrLZ!_pydevd_bundle.pydevd_frame_utilsrMrNZ-_pydevd_bundle.pydevd_kill_all_pydevd_threadsrOZ$_pydevd_bundle.pydevd_trace_dispatchrPrrQrRrSr<rTrUrVZ,_pydevd_bundle.pydevd_additional_thread_inforWZ_pydevd_bundle.pydevd_utilsrXZ5pydevd_concurrency_analyser.pydevd_concurrency_loggerrYrZr[r\Z2pydevd_concurrency_analyser.pydevd_thread_wrappersr]r^Zpydevd_file_utilsr_r`raZ pydev_ipythonZ&_pydevd_bundle.pydevd_dont_trace_filesrbrcrdrr__version_info__Z__version_info_str__vrZr]r __version__rorrpZ"_pydevd_bundle.pydevd_plugin_utils enumeraterrr[__excepthook__rr r"r6r7remoter=Zfile_system_encodingrsrobjectrrrrrrrrrr8r9rrrrr)r-r.r7r8r>r$rCr&rMZ#_pydevd_bundle.pydevd_extension_apirNrOZextensions_of_typehandlerZon_debugger_modules_loadedrarrmrmrmrns    d         t       ")^$  4   6p$*  +