Mh,&dZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZddlmZGddeZGdd eeZGd d eZGd d ejZdZGddeZGddeZeZ GddeZGddeZGddeZGddeZ Gdde!Z"Gdde"Z#Gdd eZ$Gd!d"eZ%dS)#zAn implementation of the session and presentation layers as used in the Debug Adapter Protocol (DAP): channels and their lifetime, JSON messages, requests, responses, and events. https://microsoft.github.io/debug-adapter-protocol/overview#base-protocol ) annotationsN)jsonlogutil)hide_thread_from_debuggerc"eZdZdZfdZxZS) JsonIOErrorzDIndicates that a read or write operation on JsonIOStream has failed.c|d}|dd}t|s|t|g}tj|i|||_ ||_dS)Nstreamcause)poplenstrsuper__init__r r )selfargskwargsr r __class__s X/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/debugpy/common/messaging.pyrzJsonIOError.__init__s~H%% 7D))4yy U.JJNN000000000rr c"eZdZdZfdZxZS)NoMoreMessagesz`Indicates that there are no more messages that can be read from or written to a stream. cbt|r|ndg}tj|i|dS)NzNo more messages)rrr)rrrrs rrzNoMoreMessages.__init__7s=4yy:tt'9&:$)&)))))rrrs@rr r 2sB*********rr ceZdZdZdZejZ ejZ e ddZ e ddZ e ddZ ddfd Zd Zejfd Zd Zdd ZddZdZdS) JsonIOStreamzImplements a JSON value stream over two byte streams (input and output). Each value is encoded as a DAP packet, with metadata headers and a JSON payload. istdiocX|tjjtjj|S)zlCreates a new instance that receives messages from sys.stdin, and sends them to sys.stdout. )sysstdinbufferstdout)clsnames r from_stdiozJsonIOStream.from_stdioJs" s39#SZ%6===rc0||j|j|S)ztCreates a new instance that receives messages from process.stdin, and sends them to process.stdout. )r)r')r*processr+s r from_processzJsonIOStream.from_processQs s7>7=$777rNcd|t}dd}fd}|||||S)zFCreates a new instance that sends and receives messages over a socket.Nrwbrc tjn#t$rYnwxYwdSN)shutdownsocket SHUT_RDWR Exceptionclose)socksrcleanupz)JsonIOStream.from_socket..cleanupfsQ  f.////     JJLLLLLs # 00) settimeoutreprmakefile)r*r9r+ socket_ior:s ` r from_socketzJsonIOStream.from_socketXsm  <::D MM%++      s9iw777rcdSr3rArrzJsonIOStream.os$rc`|d|d|}||_||_||_||_d|_dS)aCreates a new JsonIOStream. reader must be a BytesIO-like object, from which incoming messages will be read by read_json(). writer must be a BytesIO-like object, into which outgoing messages will be written by write_json(). cleanup must be a callable; it will be invoked without arguments when the stream is closed. reader.readline() must treat " " as the line terminator, and must leave " " as is - it must not replace " " with " " automatically, as TextIO does. Nzreader=z , writer=F)r+_reader_writer_cleanup_closed)rreaderwriterr+r:s rrzJsonIOStream.__init__osE <:V::::D     rc|jrdSd|_tjd|j |j|j|jur|jn-#|j|jur|jwwxYw|dS#|wxYw#t$rtj d|jYdSwxYw)z.Closes the stream, the reader, and the writer.NTzClosing {0} message streamz&Error while closing {0} message stream) rGrdebugr+rEr8rDrFr7reraise_exceptionrs rr8zJsonIOStream.closes  <  F  . ::: W -L&&(((|4<77 **,,,|4<77 **,,,,8   W W W  !"JDI V V V V V V Ws5A/(B2/*BB2C 2CC $C32C3c(|d|j||S)Nz {0} {1} {2}r+)rdirdataloggers r _log_messagezJsonIOStream._log_messagesvmTYT:::rcd} ||z }n0#t$r#}tt||d}~wwxYw|st||dr |dd}|S})NrTr s r)readliner7r rendswith)rrHlineexcs r _read_linezJsonIOStream._read_lines  <))) < < <$SXXd;;;; < 2$D1111}}W%% AbDz  s A AA c||n}j}tjj|}dfd }gi} |}n#t $r|r |dnYnwxYw|dgz |dkrn|d\}}} | ||<X t|d } d | cxkr jks ntnA#ttf$r- td #t $r |YnwxYwYnwxYwt} | } | d kr} | | } | stn0#t $r#}tt!| d}~wwxYw| | t| z} | d k}| d ksJd| d} |d }n#t $r |YnwxYw ||}n#t $r |YnwxYwd||S)zRead a single JSON value from reader. Returns JSON value as parsed by decoder.decode(), or raises NoMoreMessages if there are no more values to be read. Nc|r|dz }|dz }dd}dd|D}tj|g|Rj|d|dS)Nz z{name} --> {raw_lines}r  c34K|]}t|VdSr3)r<).0rYs r zTJsonIOStream.read_json..log_message_and_reraise_exception..s(!C!C$t**!C!C!C!C!C!Cr)r+ raw_lines)joinsplitrrLr+) format_stringrrrd raw_chunksrs r!log_message_and_reraise_exceptionzAJsonIOStream.read_json..log_message_and_reraise_exceptions (' 6 6M,,22599I !C!C!C!C!CCCI  !  $  +/9   MS     rTz$Error while reading message headers:r_r:sContent-Lengthrz%Content-Length is missing or invalid:rUutf-8z-->)r])json_decoder_factoryrD functoolspartialr[r7 partitionint MAX_BODY_SIZE ValueErrorKeyErrorIOErrorrreadEOFErrorr rappendredecoderS)rdecoderrH read_lineriheadersrYkey_valuelength body_startbody_remainingchunkrZbodyrhs` @r read_jsonzJsonIOStream.read_jsonsL%0''d6O6O6Q6Q%dov>>         !  y{{    55>   4- 'Js{{ NN400MCE GCL) !, 4!2344F55554#55555  6*% 4 4 4 4EFFF 4 4 41133333 433  4 __ q   < N33#"N# < < <$SXXd;;;; <   e $ $ $ c%jj (Nq  """"xx :;;/00 0;;w''DD 0 0 0 - - / / / / / 0 0>>$''DD 0 0 0 - - / / / / / 0 %&&& s~ AA0/A0!0CD$C33D D D  DD+E E7E22E7 G##G:9G:>HH+*H+c|jrt|||n|}|j} ||}n?#t $r2|dt|tj YnwxYw|d}dt|dd}||z}d } |t|kr7| ||d}|||z }|t|k7| nE#t $r8} |d|tj t|| d} ~ wwxYw|d|dS) ziWrite a single JSON value into writer. Value is written as encoded by encoder.encode(). rUNz<--)rRrkzContent-Length: z asciir)r r )rGr json_encoder_factoryrEencoder7rSr<rrLrwriteflushswallow_exceptionr ) rr~encoderrIrheaderrQ data_writtenwrittenrZs r write_jsonzJsonIOStream.write_json s < .!--- -$0''d6O6O6Q6Q  P>>%((DD P P P   eT%[[9N  O O O O O P{{7##7CII777>>wGG}  6T** ,,tLMM':;;& G+LT** LLNNNN 6 6 6   eU33H  I I IT555 5 6 %'''''s*A9B  B AD// E193E,,E1c@t|jd|jdSN()typerr+rMs r__repr__zJsonIOStream.__repr__3$t**%66 6666r)r$r3)rrrrrqr JsonDecoderrl JsonEncoderr classmethodr,r/r?rr8rrKrSr[rrrrArrr#r#<s1 M+3+4>>>[> 888[8 888[8,-1,,2WWW2.1Y;;;;   YYYYv%(%(%(%(N77777rr#ceZdZdZdfd ZfdZd dZdZeej j Z eej j Z eej j Z [xZ S) MessageDictaA specialized dict that is used for JSON message payloads - Request.arguments, Response.body, and Event.body. For all members that normally throw KeyError when a requested key is missing, this dict raises InvalidMessageError instead. Thus, a message handler can skip checks for missing properties, and just work directly with the payload on the assumption that it is valid according to the protocol specification; if anything is missing, it will be reported automatically in the proper manner. If the value for the requested key is itself a dict, it is returned as is, and not automatically converted to MessageDict. Thus, to enable convenient chaining - e.g. d["a"]["b"]["c"] - the dict must consistently use MessageDict instances rather than vanilla dicts for all its values, recursively. This is guaranteed for the payload of all freshly received messages (unless and until it is mutated), but there is no such guarantee for outgoing messages. Nc|t|tsJ|!tn!t|||_dSr3) isinstanceMessagerrmessage)rritemsrs rrzMessageDict.__init__Isa*Wg">"> = GG       GG  U # # #   rc ttj|S#t$r#t cYSwxYwr3)formatrr<r7rr)rrs rrzMessageDict.__repr__YsU &$)D//** * & & &77##%% % % % &s $*AAFc |sd}ndt|tst|trtj||}n#t |stj|}||d} ||}n#ttf$rl}|j tn|j }t|}| dsd|z}|dtj||d}~wwxYw|S)aILike get(), but with validation. The item is first retrieved as if with self.get(key, default=()) - the default value is () rather than None, so that JSON nulls are distinguishable from missing properties. If optional=True, and the value is (), it's returned as is. Otherwise, the item is validated by invoking validate(item) on it. If validate=False, it's treated as if it were (lambda x: x) - i.e. any value is considered valid, and is returned unchanged. If validate is a type or a tuple, it's treated as json.of_type(validate). Otherwise, if validate is not callable(), it's treated as json.default(validate). If validate() returns successfully, the item is substituted with the value it returns - thus, the validator can e.g. replace () with a suitable default value for the property. If validate() raises TypeError or ValueError, raises InvalidMessageError with the same text that applies_to(self.messages). See debugpy.common.json for reusable validators. c|Sr3rA)xs rrBz&MessageDict.__call__..ysr)optionalrAN[ z{0}{1})rrtuplerof_typecallabledefaultget TypeErrorrrrrr startswith isnt_validr<)rr|validaterr~rZrerrs r__call__zMessageDict.__call___s2 ."{HH $ ' ' .:h+F+F .|Hx@@@HH(## .|H--Hb!! DHUOOEE:& D D D!%!5gg4>#&& Ci$$Xty~~sCC C  D  s BD A'DD cfd}|S)Nc ||g|Ri|S#t$r,|jtn|j}|d|wxYw)Nzmissing property {0!r})rsrrr)rr|rrrfuncs rwrapz,MessageDict._invalid_if_no_key..wrapss HtD#7777777 H H H%)\%9''t|(()A3GGG Hs 6ArA)rrs` r_invalid_if_no_keyzMessageDict._invalid_if_no_keys( H H H H H rr3)F)rrrrrrrr collections OrderedDict __getitem__ __delitem__r rrs@rrr7s"      &&&&& ))))V%$[%<%HIIK$$[%<%HIIK  [48 9 9Crrc4dkr.ttrttsJSfd}td|_S)zoJSON validator for message payload. If that value is missing or null, it is treated as if it were {}. NrAc|_dSr3)r)rr~s rassociate_withz _payload..associate_withs r)rdictrr)r~rs` r_payloadrsu  Ub[[ eT " " 2e[11 1 1 1         E)E LrcneZdZdZddZdZdZeddZd Z d Z d Z d Z d Z dZdZdZdS)rzRepresents a fully parsed incoming or outgoing message. https://microsoft.github.io/debug-adapter-protocol/specification#protocolmessage Nc2||_||_ ||_dSr3)channelseqr)rrrrs rrzMessage.__init__s(     rc`|jtj|jnt|Sr3)rr<rMs r__str__zMessage.__str__s&'+y'tj dtj||YdSwxYw)NrzHandler z tried to respond to .$Handler {0} couldn't handle {1}: {2} Handler {0} couldn't handle {1}:) r_get_handler_forrr srcnameofrr applies_torrrr7rLrrhandlerresultrZs rrz Event._handleBs[,**7DJ??   NN^dnW55^^DMMOO^^^#NNNN'   ~~d++ <N7++MMOOHH       !3w''        s2AA)) C3ACCCCAD'&D'r3) rrrrrrrr staticmethodrrrrs@rrrs0PPPX<<\<rrcbeZdZdZd fd ZdZedZdZe dZ dZ xZ S) ra_Represents an incoming or an outgoing request. Incoming requests are represented directly by instances of this class. Outgoing requests are represented by instances of OutgoingRequest, which provides additional functionality to handle responses. For incoming requests, it is guaranteed that arguments is a MessageDict associated with this Request, and so are all the nested dicts in it. If "arguments" was missing or null in JSON, arguments is an empty dict. To handle the request, JsonMessageChannel tries to find a handler for this request in JsonMessageChannel.handlers. Given command="X", if handlers.X_request exists, then it is the specific handler for this request. Otherwise, handlers.request must exist, and it is the generic handler for this request. A missing handler is a fatal error. The handler is then invoked with the Request object as its sole argument. If the handler itself invokes respond() on the Request at any point, then it must not return any value. Otherwise, if the handler returns NO_RESPONSE, no response to the request is sent. It must be sent manually at some later point via respond(). Otherwise, a response to the request is sent with the returned value as the body. To fail the request, the handler can return an instance of MessageHandlingError, or respond() with one, or raise one such that it applies_to() the Request object being handled. Helper methods Message.isnt_valid() and Message.cant_handle() can be used to raise the appropriate exception type that applies_to() the Request object. Nct|||||_t|tr%t |dr||||_d|_dSr) rrrrrrr argumentsresponse)rrrrr rrs rrzRequest.__init__sv #t,,, i - - +')EU2V2V +  $ $T * * *"   rcZd|jdtj|jd|jS)Nr request rrrr<rrrMs rrzRequest.describes0S48SSdi &=&=SST\SSSrc|jSr3)r rMs rrzRequest.payloads ~rcT|jJd|j|jd}t|trd|d<t ||d<nd|d<| |ikr||d<|j|5} dddn #1swxYwYt|j||||_dS)Nr)r request_seqrFsuccessrTr) rrrrr7rr _send_messager)rrdrs rrzRequest.responds}$$$T\ R R dI & & ! AiLt99AiLLAiLDBJJ & \ ' ' * * c                 sD$?? s3BBBc|dt}|dt}|dt}t|||||}|||jdS)Nrrr r)rprrrrr)rrrrr rs rrzRequest._parseskl5#&&,y#.. Lh77 '3NNN!!'7?;;;;;rc |j}|d|j} ||}nw#t$rj}||s|}t jdtj|| t|Yd}~nd}~wwxYw|turK|j BJd tj|| dS|j V|P||j jusDJd tj|| dSdS|BJd tj||  ||dS#t $r>t jdtj|| YdSwxYw#t$$r>t jdtj|| YdSwxYw)Nrrz\Handler {0} for {1} must not return NO_RESPONSE if it has already invoked request.respond().z`Handler {0} for {1} must not return a response body if it has already invoked request.respond().z}Handler {0} for {1} must either call request.respond() before it returns, or return the response body, or return NO_RESPONSE.zLChannel was closed before the response from handler {0} to {1} could be sentr)rrrrrrrrrrr NO_RESPONSErrrrr warningr7rLrs rrzRequest._handles,**9dlCC1   '   ~~d++ <N7++MMOOHH  $$},,117w//22-,,,, *~4=3E)E)E)E99?w//::*F)E)E~~)E)E))SSYSYw//TT*)) LL(((((%Kfw//      !3w''        sa 1H B%A B H B%%AH.run_handlers-s #   ))))/"~~h77"! D N733$--//HH !);w// ))++  s3 B  BAB<B BB  ACC)rrrr)rr-r,rs @@rr'z*OutgoingRequest._enqueue_response_handlers'st=   F      **111- &&x>>>  #AAA & & &r)T) rrrrrrrrr%r)r'rrs@rrrsFW%%%%%QQQ""""&...,'''''''rrceZdZdZd fd ZdZedZedZedZ e d dZ xZ S) ra^Represents an incoming or an outgoing response to a Request. https://microsoft.github.io/debug-adapter-protocol/specification#response error_message corresponds to "message" in JSON, and is renamed for clarity. If success is False, body is None. Otherwise, it is a MessageDict associated with this Response, and so are all the nested dicts in it. If "body" was missing or null in JSON, body is an empty dict. If this is a response to an outgoing request, it will be handled by the handler registered via self.request.on_response(), if any. Regardless of whether there is such a handler, OutgoingRequest.wait_for_response() can also be used to retrieve and handle the response. If there is a handler, it is executed before wait_for_response() returns. No further incoming messages are processed until the handler returns, except for responses to requests that have wait_for_response() invoked on them. To report failure to handle the event, the handler must raise an instance of MessageHandlingError that applies_to() the Response object it was handling. Any such failure is logged, after which the message loop moves on to the next message. Helper methods Message.isnt_valid() and Message.cant_handle() can be used to raise the appropriate exception type that applies_to() the Response object. Nct|||||_ t|tr%t |dr||||_dSr)rrrrrrrr)rrrrrrrs rrzResponse.__init__dsr #t,,, 8 dK ( ( &WT;K-L-L &    % % %  rcJd|jd|jS)Nrz response to )rrrrMs rrzResponse.describeys(C48CC$,*?*?*A*ACCCrc|jSr3rrMs rrzResponse.payload|rrc8t|jt S)z%Whether the request succeeded or not.)rrr7rMs rrzResponse.successsdi3333rc,|jr|jS|j)zResult of the request. Returns the value of response.body, unless it is an exception, in which case it is raised instead. )rrrMs rr zResponse.results < 9 )Orc&||dtnd}|dt}|dt}|dt}||r|dt}nl|dt}t}|t jr(|tt jd}t }||d} |5|j |} d} dddn #1swxYwYn$#t$rt|||d } d } YnwxYw|s| |_ t||| || } |5| | _| dddn #1swxYwY| r| S| d |) NrrrrrrTrz Frz0request_seq={0} does not match any known request)rprboolrrrrPREFIXr_sent_requestsr rsrr rrr'r) rrrrrrr error_messagerr known_requestrs rrzResponse._parsesU+/C;?DD$#D$E..E25E2r3) rrrrrrrrrr r rrrs@rrrGs8      *DDDX44X4X(((\(((((rrc(eZdZdZfdZdZxZS) DisconnectznA dummy message used to represent disconnect. It's always the last message received from any channel. cLt|ddSr3)rr)rrrs rrzDisconnect.__init__s# $'''''rcd|jS)Nzdisconnect from )rrMs rrzDisconnect.describes0$,000r)rrrrrrrrs@rr<r<sQ(((((1111111rr<cDeZdZdZd dZdZdZdZdZd Z d Z d Z dS) raIndicates that a message couldn't be handled for some reason. If the reason is a contract violation - i.e. the message that was handled did not conform to the protocol specification - InvalidMessageError, which is a subclass, should be used instead. If any message handler raises an exception not derived from this class, it will escape the message loop unhandled, and terminate the process. If any message handler raises this exception, but applies_to(message) is False, it is treated as if it was a generic exception, as desribed above. Thus, if a request handler issues another request of its own, and that one fails, the failure is not silently propagated. However, a request that is delegated via Request.delegate() will also propagate failures back automatically. For manual propagation, catch the exception, and call exc.propagate(). If any event handler raises this exception, and applies_to(event) is True, the exception is silently swallowed by the message loop. If any request handler raises this exception, and applies_to(request) is True, the exception is silently swallowed by the message loop, and a failure response is sent with "message" set to str(reason). Note that, while errors are not logged when they're swallowed by the message loop, by that time they have already been logged by their __init__ (when instantiated). NFc||_ |t|tsJ||_ |s' |#t$rt jYdSwxYwdS)aCreates a new instance of this class, and immediately logs the exception. Message handling errors are logged immediately unless silent=True, so that the precise context in which they occured can be determined from the surrounding log entries. N)rrrr rrr)rrr rs rrzMessageHandlingError.__init__s  } 5' : :}}}   ( ( ' ( ( (%'''''' ( ( (s/AAcRt|jt|jfSr3)hashridr rMs r__hash__zMessageHandlingError.__hash__sT["TZ..1222rct|tstSt|t|urtS|j|jkrdS|j#|j|jj|jjkrdSdS)NFT)rrNotImplementedrrr rrothers r__eq__zMessageHandlingError.__eq__sx%!566 "! ! ::T%[[ ( (! ! ;%, & &5 : !ek&=z~00utrc||k Sr3rArGs r__ne__zMessageHandlingError.__ne__ s5=  rc*t|jSr3)rrrMs rrzMessageHandlingError.__str__s4;rct|j}|j|d|jdz }n-|d|jjjd|jjd|jdz }|S)Nzreason=rzchannel=z, cause=z , reason=)rrr rrr+r)rss rrzMessageHandlingError.__repr__sm JJ  :  +4;+++ +AA jDJ.3jjtz~jjZ^Zejjj jArc&|jdup|j|uS)zWhether this MessageHandlingError can be treated as a reason why the handling of message failed. If self.cause is None, this is always true. If self.cause is not None, this is only true if cause is message. N)r rrs rrzMessageHandlingError.applies_toszT!:TZ7%::rcBt||j|d)z}Propagates this error, raising a new instance of the same class with the same reason, but a different cause. Tr5)rr)r new_causes r propagatezMessageHandlingError.propagate#s#d4jji====r)NF) rrrrrrDrIrKrrrrSrArrrrs6((((2333   !!!   ;;;>>>>>rrceZdZdZdZ dZdS)raIndicates that an incoming message did not follow the protocol specification - for example, it was missing properties that are required, or the message itself is not allowed in the current state. Raised by MessageDict in lieu of KeyError for missing keys. zInvalid message: cDtjt|jzSr3)rr7rrrMs rrzInvalidMessageError.__str__:s")C ,<,<<(""$$$ > > > I< = = = = = > ?!1N)##%%%%%*) ? ? ? I= > > > > > > ?s! AAA&&BB) rrrrrrrr rrcD|jD]}||vr||}||=|||<dS)z>Reorders items in a MessageDict such that it is more readable.N)_prettify_order)rrr|r~s r _prettifyzJsonMessageChannel._prettifysK' & &C,&& %ES! %L    & &rc#8Kd|vsJ|5t|j}dddn #1swxYwYtd|}||d<|||5|V|j|ddddS#1swxYwYdS)aSends a new message to the other party. Generates a new sequence number for the message, and provides it to the caller before the message is sent, using the context manager protocol:: with send_message(...) as seq: # The message hasn't been sent yet. ... # Now the message has been sent. Safe to call concurrently for the same channel from different threads. rN)nextr`rr}r r)rrrs rrz JsonMessageChannel._send_messages8G####  ' 't~&&C ' ' ' ' ' ' ' ' ' ' ' ' ' ' 'dG,, w  , ,III K " "7 + + + , , , , , , , , , , , , , , , , , ,s,00#BBBcd|d}| |ikr||d<||5}t||||}| ||||j|<dddn #1swxYwY|S)aSends a new request, and returns the OutgoingRequest object for it. If arguments is None or {}, "arguments" will be omitted in JSON. If on_before_send is not None, invokes on_before_send() with the request object as the sole argument, before the request actually gets sent. Does not wait for response - use OutgoingRequest.wait_for_response(). Safe to call concurrently for the same channel from different threads. r)rrNr )rrr8)rrr on_before_sendrrrs r send_requestzJsonMessageChannel.send_requests7 3 3  Y"__&AkN    " " /c%dC)DDG)w''''.D  $  / / / / / / / / / / / / / / / s*AA"%A"cd|d}| |ikr||d<||5 ddddS#1swxYwYdS)zSends a new event. If body is None or {}, "body" will be omitted in JSON. Safe to call concurrently for the same channel from different threads. r)rrNr)r)rrrrs r send_eventzJsonMessageChannel.send_eventsu - -   AfI    " "                     s 7;;c@|j|i|S)z-Same as send_request(...).wait_for_response())rr%rs rrzJsonMessageChannel.requests& t $1&11CCEEErc|s|sJ|r ||j|jS||j|jdS)zSends a new message with the same type and payload. If it was a request, returns the new OutgoingRequest object for it. N)rrrrr rrrrPs rrSzJsonMessageChannel.propagatesz !!##9w'7'7'9'9999      9$$W_g6GHH H OOGM7< 8 8 8 8 8rc ||}|r|}|S#t$r }||Yd}~dSd}~wwxYw)z~Like propagate(message).wait_for_response(), but will also propagate any resulting MessageHandlingError back. N)rSrr%r)rrr rZs rdelegatezJsonMessageChannel.delegates #^^G,,F  "" 41133M# # # # MM' " " " " " " " " " #s>A A+ A&&A+c tjd| |#t$r }tjd|||5t |}t |j}|D]?}tdd|j |j d|d}t |||@t|jrJ|t||j|dddn#1swxYwYYd}~dSYd}~dSd}~wwxYw)Nz%Starting message loop for channel {0}Tz)Exiting message loop for channel {0}: {1}F)rrrrrr)rrK_parse_incoming_messager rlistr8valuesrrrrrrrr<_handle_disconnectr8)rrZ err_message sent_requestsr response_jsons rrtz+JsonMessageChannel._parse_incoming_messages s 94@@@  /,,... /    IA4 M M M  !#hh !%T%8%?%?%A%A B B , C CG$/#%+2;'.','2  % %MOOD-cOBBBBt233333&&z$'7'79PQQQ /                            s9- ED=C D& D=&D* *D=-D* .D==E)rrrc fd}fdgj|}j|}t|tsJ|dt jddd}j|} ||d S#t$rA}tj dt|t j |Yd }~d Sd }~wt$rk}t|tr|jjurtjd t j |t!jd Yd }~d Sd }~wwxYw) zReads incoming messages, parses them, and puts handlers into the queue for _run_handlers() to invoke, until the channel is closed. ctd|}d|vr||_||S)Nr)rr}rrw)rr message_dictsrs r object_hookz?JsonMessageChannel._parse_incoming_message..object_hook;sND!$$Azzq!!!-A    # # #Hrc$D] }||_|` dSr3)rr)rrrs rrzBJsonMessageChannel._parse_incoming_message..associate_withMs," % %# $$ % %r)rrrrrz3Failed to parse message in channel {0}: {1} in: {2}Nz-Fatal error in channel {0} while parsing: {1}rY)r rlrrrrenum_message_parsersrrrrr<r7r ros_exit) rrryrmsg_typeparserrZrrs ` @@rrz*JsonMessageChannel._parse_incoming_message3s       $ % % % % %  +22{2KK{,,W55 , 44444< '9j(Q(QRR&x0  F4 & & & & &"    IFC ,''              #~.. 3:3L3L  !@ ,''    HQKKKKKKKKK s% B E$6C  E-A EEc|5|jfd|D|jt |jrW|jPt j|j|d|_t|j|j ddddS#1swxYwYdS)zEnqueues handlers for _run_handlers() to run. `what` is the Message being handled, and is used for logging purposes. If the background thread with _run_handlers() isn't running yet, starts it. c3 K|]}|fV dSr3rA)rbrwhats rrcz7JsonMessageChannel._enqueue_handlers..us'&O&O7g&O&O&O&O&O&OrNz message handlerrq) raextendr" notify_allrrcr[rs _run_handlersrrv)rrr,s ` rrz$JsonMessageChannel._enqueue_handlersls! - -   & &&O&O&O&Oh&O&O&O O O O  # . . 0 0 04&'' -D,@,H'0'7- 222((($*$*>???$**,,,' - - - - - - - - - - - - - - - - - -sB+B<<CCc |5|j}dddn #1swxYwY|r|j|5|s-t|js|j|jdd}|jdd=|r$t|sd|_ ddddSdddn #1swxYwY|D]\}}|r|tj tj fvr"tj d| 5 |n8#t$r+|t!jdYnwxYwdddn #1swxYwYn)zRuns enqueued handlers until the channel is closed, or until the handler queue is empty once the channel is closed. TNz/handling {0}/ rY)rGrdrerrar"r#rcrrrrprefixedrr7r8rr)rclosedr,rrs rrz JsonMessageChannel._run_handlerssw ) $ & & & & & & & & & & & & & & & & & +#((***  3c$*=&>&>3+00222 .qqq1'*#h-- ,0D(                       ""* $ $ g g%-)III\"4dmmooFF$$$ $$$$  $$$$$$$$$$$$$$$$G) $sUA"B;;B?B?E" DE"2EE"EE""E& )E& c|5|j}dddn #1swxYwY|dz|z|fD]$} t||cS#t$rY!wxYwtdt j||||)z2Returns the handler for a message of a given type.Nr}z?handler object {0} for channel {1} has no handler for {2} {3!r})r,getattrAttributeErrorrrr)rrr+r, handler_names rrz#JsonMessageChannel._get_handler_fors % %}H % % % % % % % % % % % % % % %"CZ$.5  L x66666!     M T Tx((      sA A Act|jdd} |dS#t$r,tjdt j||YdSwxYw)N disconnectcdSr3rArArrrBz7JsonMessageChannel._handle_disconnect..strz0Handler {0} couldn't handle disconnect from {1}:)rr,r7rrLrr)rrs rrz%JsonMessageChannel._handle_disconnects}$-||DD  GIIIII     !Cw''       s %2AA)NNr3)!rrrrrrrrirnr8rvr#r|r} contextlibcontextmanagerrrrrrSrrtrrrrrrrrrrrArrrWrW>s   # # # #777 $ $ $$$$&???& O&&&,,,40    FFF 9 9 9 # # #D>O 777r---:.$.$.$`   *     rrWceZdZdZdZdS)MessageHandlerszA simple delegating message handlers object for use with JsonMessageChannel. For every argument provided, the object gets an attribute with the corresponding name and value. c \|D]\}}t|||dSr3)rsetattr)rrr+rs rrzMessageHandlers.__init__s< ,,.. & &JD$ D$ % % % % & &rN)rrrrrrArrrrs- &&&&&rr)&r __future__rrrrmr^rr5r&r[debugpy.commonrrrdebugpy.common.utilrrtr rvr objectr#rrrrrrrrrr<r7rrrWrrArrrs #""""" **********99999900000'000.*****[(***x7x7x7x7x76x7x7x7vaaaaa+)aaaH.\A\A\A\A\Af\A\A\A~HHHHHGHHHVfhh IIIIIgIIIXT'T'T'T'T'gT'T'T'nqqqqqwqqqh 1 1 1 1 1 1 1 1`>`>`>`>`>9`>`>`>F=====.===(YYYYYYYYx &&&&&f&&&&&r