eddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z Gdde ZGdde ZGdd eZGd d eZGd d eZGddeZeZddZGddeZGddeZy)N)cprintceZdZdZy) ClosedErrorz}Raised when an event handler receives a request to close the connection or discovers that the connection has been closed.N__name__ __module__ __qualname____doc__D/usr/lib/python3/dist-packages/pyqtgraph/multiprocess/remoteproxy.pyrrs 9r rceZdZdZy) NoResultErrorzlRaised when a request for the return value of a remote call fails because the call has not yet returned.Nrr r rrrs .r rceZdZdZy)RemoteExceptionWarningzBEmitted when a request to a remote object results in an Exception Nrr r rrrsLr rceZdZdZiZddZedZdZdZ dZ dZ dZ d Z d Zdd Zdd ZdZdZdZdZdZdZdZdZdZy )RemoteEventHandlera. This class handles communication between two processes. One instance is present on each process and listens for communication from the other process. This enables (amongst other things) ObjectProxy instances to look up their attributes and call their methods. This class is responsible for carrying out actions on behalf of the remote process. Each instance holds one end of a Connection which allows python objects to be passed between processes. For the most common operations, see _import(), close(), and transfer() To handle and respond to incoming requests, RemoteEventHandler requires that its processRequests method is called repeatedly (this is usually handled by the Process classes defined in multiprocess.processes). cz||_||_||_i|_t j |_i|_t j |_dddddtdttttttt t"t$g d|_t j |_d|_d|_t j |_t j |_|3|j3t5j6|j9}|t:j<|<y)Nsync autoF)callSynctimeout returnType autoProxy deferGetattr noProxyTypesr)debugconnnameresults threadingRLock resultLockproxies proxyLocktypestrbytesintfloattuplelistdictLocalObjectProxy ObjectProxy proxyOptionsoptsLock nextRequestIdexited processLocksendLocksendosgetpidrecvrhandlers)self connectionr!pidrs r__init__zRemoteEventHandler.__init__7s    $//+ "*  !T CUE4 +  ")  %??,!) ; OOBIIK (//#C+/##C(r cZ |j|S#t||jxYwN)r<printclsr?s r getHandlerzRemoteEventHandler.getHandlerds. <<$ $  #s|| $ s*c|jsytj|jdtjt ||zfzdy)Nz[%d] %s )rrcoutr9r:r))r=msgargss rdebugMsgzRemoteEventHandler.debugMsgls8zz  DJJ ryy{CHTM.J JBOr cd|j5|j|cdddS#1swYyxYwrB)r3r2)r=opts rgetProxyOptionz!RemoteEventHandler.getProxyOptionqs, ]] *$$S) * * *s&/c ||j5|jj|dddy#1swYyxYw)z~ Set the default behavior options for object proxies. See ObjectProxy._setProxyOptions for more info. N)r3r2update)r=kwdss rsetProxyOptionsz"RemoteEventHandler.setProxyOptionsus4 ]] +    $ $T * + + +s2;c(|j5|jr|jdtd}|jj r1 |j |dz }|jj r1|dkDr|jd||cdddS#t$r|jdd|_td|jztjtjYxYw#1swYyxYw) zProcess all pending requests from the pipe, return after no more events are immediately available. (non-blocking) Returns the number of events processed. z5 processRequests: exited already; raise ClosedError.rzIprocessRequests: got ClosedError from handleRequest; setting exited=True.TzError in process %sz%processRequests: finished %d requestsN) r6r5rLrr poll handleRequestrCr!sys excepthookexc_info)r= numProcesseds rprocessRequestsz"RemoteEventHandler.processRequests}s   $ {{ UV!m#L)).."4&&( A%L)).."4a E|TI$ $ (#MM"mn"&DK4/$));<NNCLLN3A$ $ s+ADB$'DD$ADDDc h d} |jj\}}}} |jd||g}|dkDr|jd |t|D]-} |j|jj/ |d k(s|dk(r|} d}tj|} |jd|| | jdd} |d k(r+|j5d | d f|j <dddn|dk(r0|j5d| d| dff|j <dddnV|dk(rt!| d| d}n=|dk(r,| d} | d} | d}t#|dkDrt%| D]g\}}t'|t(st#|dkDs&|ddk(s/|d}|d\}}t+j,|||j/|| |<i|j1D]g\}}t'|t(st#|dkDs&|ddk(s/|d}|d\}}t+j,|||j/|||<it#|dk(r | | }n| | i|}n |dk(r| d}d } n|d!k(r| d}d"} n|d#k(r2t+j,|d| d$j/| d%}d"} n|d&k(r| d'}| jd(g}t5j6||)}t#|dk(r9|j9d*j;d*}|}|ddD]}t!||}n@t=|j>|}n)|d+k(rt@jC| d,n |d-k(r|d}d } d}||s|jd.|| dk(r7|jH5|jJd/}ddd|jM|}n| d"k(r tA|} |jO||n:|jd0||jR|g|n|tEjP||d-k(r4 jd1d2durtUjVdyt y#t$r|jdt t $r\}|j dk(r|jdYd}~|jd|j |jt d}~wwxYw#t$r|jd t t $rF}|j dk(r|jd Yd}~|jd t d}~wwxYw#1swYxYw#1swYxYw#t3d| t#| | ddfzxYw#tEjF}YAxYw#1swYxYw#tEjPtEjF|jR|gtEjFYxYw)3z^Handle a single request from the remote process. Blocks until a request is available.NTz; handleRequest: got EOFError from recv; raise ClosedError.z4 handleRequest: got IOError 4 from recv; try again.zB handleRequest: got IOError %d from recv (%s); raise ClosedError.z handleRequest: received %s %srz+ handleRequest: reading %d byte messageszJ handleRequest: got EOF while reading byte messages; raise ClosedError.zH handleRequest: got IOError 4 while reading byte messages; try again.zN handleRequest: got IOError while reading byte messages; raise ClosedError.resulterrorz handleRequest: id=%s opts=%srr exception excString getObjAttrobjattrcallObjrKrR__byte_message__rUr)dtypez Failed to call object %s: %d, %s getObjValuevaluetransferproxy transferArrayrhshapeimportmodulefromlist)rq.delproxyIdclosez2 handleRequest: sending return value for %d: %srz- handleRequest: returning exception for %d noCleanupF),r r;EOFErrorrLrIOErrorerrnostrerrorrangeappend recv_bytespickleloadsgetr%r"getattrlen enumerate isinstancer-np frombufferreshapeitemsrCbuiltins __import__lstripsplitmap __getattr__r0releaseProxyIdrXrZr3r2r replyResultrY replyErrorr9_exit)r=r_cmdreqId nByteMsgsoptStrerrbyteDatairesultIdoptsrrdfnargsfnkwdsargindrhrnkr!rqmodpartspartexcrs rrWz RemoteEventHandler.handleRequests? (04 0@-UIv 7eD q= MMG Sy! ,A ,OODII$8$8$:;  ,"Q !h#. <<'D MMxx U+t3 "m# _ $ [\!m# (99>MM"XYMM"fhkhqhqsvssA%-'  (& (MM"no%-',yyA~ &pq  &vw)m+ ,*HH__4@CVV\]^]_V`CaabJ !,,.CII<NNCLLN3#DOOE;CLLN;sQ=!)T AV:&U=;V:V 0A'V:V:'V:0A!V:V:!V:*A V:4V9DV::W6W#=,T) T1TT,U:4 U5U55U:=VV: VV: V77V::WW #A X1cB|jd|dt|y)Nr_off)r_requestrrrr8r/)r=rr_s rrzRemoteEventHandler.replyResultJs (%%dRXFY Zr c tj|} |jd|dt|d|y#|jd|dtd|YyxYw)Nr`rrU)rarbr) tracebackformat_exceptionr8r/)r=rrexcStrs rrzRemoteEventHandler.replyErrorMs`++S1 q IIgUUX[\]X^jpIqI r q IIgUUX\hnIoI ps #8"ANc j|jr|jdt|j5|i}|dvs Jd|z|'|dk7r(|j}|xjdz c_n|dvsJ|||d< t j |} d } | t|} ||| | f}|jd |d | |||jj||F|D]&} |jjt| (|jd t||jd||dk(r dddy dddt||t||} |dk(r| S|dk(r| jSy#td t|td xYw#1swYexYw)a]Send a request or return packet to the remote process. Generally it is not necessary to call this method directly; it is for internal use. (The docstring has information that is nevertheless useful to the programmer as it describes the internal protocol used to communicate between processes) ============== ==================================================================== **Arguments:** request String describing the type of request being sent (see below) reqId Integer uniquely linking a result back to the request that generated it. (most requests leave this blank) callSync 'sync': return the actual result of the request 'async': return a Request object which can be used to look up the result later 'off': return no result timeout Time in seconds to wait for a response when callSync=='sync' opts Extra arguments sent to the remote process that determine the way the request will be handled (see below) returnType 'proxy', 'value', or 'auto' byteData If specified, this is a list of objects to be sent as byte messages to the remote process. This is used to send large arrays without the cost of pickling. ============== ==================================================================== Description of request strings and options allowed for each: ============= ============= ======================================================== request option description ------------- ------------- -------------------------------------------------------- getObjAttr Request the remote process return (proxy to) an attribute of an object. obj reference to object whose attribute should be returned attr string name of attribute to return returnValue bool or 'auto' indicating whether to return a proxy or the actual value. callObj Request the remote process call a function or method. If a request ID is given, then the call's return value will be sent back (or information about the error that occurred while running the function) obj the (reference to) object to call args tuple of arguments to pass to callable kwds dict of keyword arguments to pass to callable returnValue bool or 'auto' indicating whether to return a proxy or the actual value. getObjValue Request the remote process return the value of a proxied object (must be picklable) obj reference to object whose value should be returned transfer Copy an object to the remote process and request it return a proxy for the new object. obj The object to transfer. import Request the remote process import new symbols and return proxy(ies) to the imported objects module the string name of the module to import fromlist optional list of string names to import from module del Inform the remote process that a proxy has been released (thus the remote process may be able to release the original object) proxyId id of proxy which is no longer referenced by remote host close Instruct the remote process to stop its event loop and exit. Optionally, this request may return a confirmation. result Inform the remote process that its request has been processed result return value of a request error Inform the remote process that its request failed exception the Exception that was raised (or None if the exception could not be pickled) excString string-formatted version of the exception and traceback ============= ===================================================================== z* send: exited already; raise ClosedError.N)rrasyncz:callSync must be one of "off", "sync", or "async" (got %r)rrU)r_r`rz'==== Error pickling this object: ====z'=======================================rz/send request: cmd=%s nByteMsgs=%d id=%s opts=%sz sent %d byte messagesz call sync: %s) descriptionrrr)r5rLrr7r4r~dumpsrCrr r8 send_bytesr*Requestr)r_) r=rrrrrrrrRrrrdreqs rr8zRemoteEventHandler.sendUsd ;; MMF G-  ]]/ |77 A9uyA:A A7}u$ ..E&&!+&"5555%%/\"  d+I#M y&9G MMKWUVZYbdiko p IINN7 ###5CII((s45 7XG MM+X 65 _/ / \!]/ bdEs7|WM w J v ::<  ; ?@d ?@9/ / s%A F)>FB(F)$F&&F))F2c r |jddt||d|d|_y#t$rYywxYw)Nru)rvrrrTr )r8r/r5r)r=rrvrRs rruzRemoteEventHandler.closesA  DII agD9,EPX a\` aDK   s '* 66c|j5||jv}ddds |j|j5||jvr t |jj |\}}ddddk(rS|dk(r\}|vdg}t fd|Ds]tjdttjdjttjdt|tdjtdtd #1swY!xYw#t$rYwxYw#1swYxYw) Nr_r`AttributeErrorc3FK|]}dj|yw)rHN) startswith).0xrs r z/RemoteEventHandler.getResult..s D6":003Ds!z7===== Remote process raised exception on request: =====z/===== Local Traceback to request follows: =====zBError getting result. See above for exception from remote process.zInternal error.) r%r"r\rrpopanywarningswarnrjoinrC Exception)r=r haveResultstatusr_rnormalrs @r getResultzRemoteEventHandler.getResultsF__ /$,,.J / $$& __ 5DLL(#o%!\\--e4NFF 5 X M w  KC++DVDDMM"[]stMM"''&/3IJMM"SUkl bggfo& dee-. .E / /    5 5s(D<E 7E<E EEE"c B|jdddt|d|S)az Request the remote process import a module (or symbols from a module) and return the proxied results. Uses built-in __import__() function, but adds a bit more processing: _import('module') => returns module _import('module.submodule') => returns submodule (note this differs from behavior of __import__) _import('module', fromlist=[name1, name2, ...]) => returns [module.name1, module.name2, ...] (this also differs from behavior of __import__) ror)rp)rrrr r)r=rrRs r_importzRemoteEventHandler._imports'tyyZFSAQZUYZZr c B|jddt||d|S)Nrc)rdrerrr r)r=rdrerRs rrczRemoteEventHandler.getObjAttr s%tyyUDSt4LUPTUUr c @|jddt|d|S)Nrirdrr r)r=rdrRs rrizRemoteEventHandler.getObjValue#s!tyyKTc]KdKKr c |j}t|}|j5|jdd}||jd}|jd|jd}ddddurL|Dcgc]}|j |}}|j D]\}}|j |||<g} t|D][\} } | jtjk(s$dt| | j| jff|| <| j| ]|j D][\}}|jtjk(s$dt| |j|jff||<| j|]|jddt!|||| d|S#1swYUxYwcc}w) NrrTrgrfrdrKrRrrrr )copyr.r3rr2rrr __class__rndarrayrrhrnr|r8r/) r=rdrKrRrrrvrbyteMsgsrrs rrfzRemoteEventHandler.callObj&syy{Dz]] N88ND9L##00@ d.?.? .LMI  N  =ABDNN1l3BDB  :1..L9Q :t_ %EAc}} *-s8}syy#))>TUQ$ %::< #CAa{{bjj(-s8}qww>PQQ" # tyyp#Dt1T_gpkopp3 N NCsAF>;G >Gc|j5tj||j}|j|j |<dddy#1swYyxYwrB)r'weakrefref deleteProxy_proxyIdr&)r=rlrs r registerProxyz RemoteEventHandler.registerProxyFsF ^^ /++eT%5%56C %DLL  / / /s :AAc|jy|j5|jj|}ddd |jdt dy#1swY)xYw#t $rYywxYw)Nrs)rtrr)r8r'r&rr/r)r=rrts rrzRemoteEventHandler.deleteProxyKsn 99   ^^ ,ll&&s+G ,  IIe$w*?%I P  , ,    sAA*A'* A65A6c |jtjur0|j|jd}|j dd||gd|S|j ddt |d|S)z Transfer an object by value to the remote host (the object must be picklable) and return a proxy for the new remote object. )rhrnrmrrkrrr )rrrrhrnr8r/)r=rdrRrs rrkzRemoteEventHandler.transferXse ==BJJ & YY;D499X_43%XSWX X499LZdsmLtL Lr cF|D]}t||s|cSt|SrB)rr0)r=rdrtyps rrzRemoteEventHandler.autoProxycs- C#s#   $$r )F)NNrrNN)rF)rr r r r<r@ classmethodrFrLrOrSr\rWrrr8rurrrcrirfrrrkrr r rrrs(H+0ZP *+) V^$D[qL \%/N [VLq@/  M%r rc&eZdZdZddZddZdZy)ra Request objects are returned when calling an ObjectProxy in asynchronous mode or if a synchronous call has timed out. Use hasResult() to ask whether the result of the call has been returned yet. Use result() to get the returned value. NcX||_||_||_d|_d|_||_y)NF)procrr gotResult_resultr)r=processrrrs rr@zRequest.__init__rs- &   r cd|jr |jS| |j}|rtj}|j s|j j r ttjd|dk\rQtj|z |kDr7td|jzddl }|jt|j s|jS|j j|j|_d|_|jS)a Return the result for this request. If block is True, wait until the result has arrived or *timeout* seconds passes. If the timeout is reached, raise NoResultError. (use timeout=None to disable) If block is False, raise NoResultError immediately if the result has not arrived yet. If the process's connection has closed before the result arrives, raise ClosedError. Ng{Gzt?rzRequest timed out: %sT)rrrtime hasResultrr5rsleeprCrr print_stackrrr)r=blockrstartrs rr_zRequest.resultzs >><<  ?llG IIKEnn&99##%-' 5!ad>Z?d?Z@y)Ar1aZ Proxy to an object stored by the remote process. Proxies are created by calling Process._import(), Process.transfer(), or by requesting/calling attributes on existing proxy objects. For the most part, this object can be used exactly as if it were a local object:: rsys = proc._import('sys') # returns proxy to sys module on remote process rsys.stdout # proxy to remote sys.stdout rsys.stdout.write # proxy to remote sys.stdout.write rsys.stdout.write('hello') # calls sys.stdout.write('hello') on remote machine # and returns the result (None) When calling a proxy to a remote function, the call can be made synchronous (result of call is returned immediately), asynchronous (result is returned later), or return can be disabled entirely:: ros = proc._import('os') ## synchronous call; result is returned immediately pid = ros.getpid() ## asynchronous call request = ros.getpid(_callSync='async') while not request.hasResult(): time.sleep(0.01) pid = request.result() ## disable return when we know it isn't needed rsys.stdout.write('hello', _callSync='off') Additionally, values returned from a remote function call are automatically returned either by value (must be picklable) or by proxy. This behavior can be forced:: rnp = proc._import('numpy') arrProxy = rnp.array([1,2,3,4], _returnType='proxy') arrValue = rnp.array([1,2,3,4], _returnType='value') The default callSync and returnType behaviors (as well as others) can be set for each proxy individually using ObjectProxy._setProxyOptions() or globally using proc.setProxyOptions(). NcRtj|||jd<||jd<||jd<d|jd<ddddddd|jd<tj ||jd<|jdj |y) N _processId_typeStrrr _attributes)rrrrrr _proxyOptions_handler)objectr@__dict__rrFr)r=rrtrparents rr@zObjectProxy.__init__s&/ l#$+ j!$+ j!') m$    *  o&%7$A$A)$L j! j!//5r c |D]}||jvstd|z|jj|y)a Change the behavior of this proxy. For all options, a value of None will cause the proxy to instead use the default behavior defined by its parent Process. Options are: ============= ============================================================= callSync 'sync', 'async', 'off', or None. If 'async', then calling methods will return a Request object which can be used to inquire later about the result of the method call. If 'sync', then calling a method will block until the remote process has returned its result or the timeout has elapsed (in this case, a Request object is returned instead). If 'off', then the remote process is instructed _not_ to reply and the method call will return None immediately. returnType 'auto', 'proxy', 'value', or None. If 'proxy', then the value returned when calling a method will be a proxy to the object on the remote process. If 'value', then attempt to pickle the returned object and send it back. If 'auto', then the decision is made by consulting the 'noProxyTypes' option. autoProxy bool or None. If True, arguments to __call__ are automatically converted to proxy unless their type is listed in noProxyTypes (see below). If False, arguments are left untouched. Use proxy(obj) to manually convert arguments before sending. timeout float or None. Length of time to wait during synchronous requests before returning a Request object instead. deferGetattr True, False, or None. If False, all attribute requests will be sent to the remote process immediately and will block until a response is received (or timeout has elapsed). If True, requesting an attribute from the proxy returns a new proxy immediately. The remote process is _not_ contacted to make this request. This is faster, but it is possible to request an attribute that does not exist on the proxied object. In this case, AttributeError will not be raised until an attempt is made to look up the attribute on the remote process. noProxyTypes List of object types that should _not_ be proxied when sent to the remote process. ============= ============================================================= zUnrecognized proxy option '%s'N)r KeyErrorrQ)r=rRrs rrzObjectProxy._setProxyOptions1sK` EA***?!CDD E !!$'r c8|jj|S)zf Return the value of the proxied object (the remote object must be picklable) )r rirs r _getValuezObjectProxy._getValuefs }}((..r c^|j|}||jj|S|SrB)r r rO)r=rNvals r_getProxyOptionzObjectProxy._getProxyOptionms1  % ;==//4 4 r c tt|jDcgc]}||j|fc}Scc}wrB)r/r r)r=rs r_getProxyOptionszObjectProxy._getProxyOptionsss14;M;MNaa--a01NOONs5cjt|j|j|j|jffSrB)rrrrrrs rrzObjectProxy.__reduce__vs)#doot}}dmmUYUeUe%fggr cNd|j|j|jfzS)Nz.)rrrrs r__repr__zObjectProxy.__repr__ys&?4??TXTaTacgcpcpBqqqr c |j}|D]!}d|z|vs |jd|z||<#|ddur|j|S|jj||fi|S)aR Calls __getattr__ on the remote object and returns the attribute by value or by proxy depending on the options set (see ObjectProxy._setProxyOptions and RemoteEventHandler.setProxyOptions) If the option 'deferGetattr' is True for this proxy, then a new proxy object is returned _without_ asking the remote object whether the named attribute exists. This can save time when making multiple chained attribute requests, but may also defer a possible AttributeError until later, making them more difficult to debug. _rT)rr _deferredAttrr rc)r=rerRrrs rrzObjectProxy.__getattr__~s$$& *A1u}((3q5/Q *  4 '%%d+ +,4==++D$?$? ?r ct||SrB)DeferredObjectProxyr=res rrzObjectProxy._deferredAttrs"4..r c|j}|D]!}d|z|vs |jd|z||<#|jjd|||d|S)at Attempts to call the proxied object from the remote process. Accepts extra keyword arguments: _callSync 'off', 'sync', or 'async' _returnType 'value', 'proxy', or 'auto' If the remote call raises an exception on the remote process, it will be re-raised on the local process. rrr )rrr rf)r=rKrRrrs r__call__zObjectProxy.__call__sf$$& *A1u}((3q5/Q *%t}}$$LDtLtLLr c$|j|SrB)rrs r_getSpecialAttrzObjectProxy._getSpecialAttrs!!$''r c*|jd|S)N __getitem__r#r=rKs rr%zObjectProxy.__getitem__2t##M2D99r c0|jd|ddiS)N __setitem__ _callSyncrr&r's rr*zObjectProxy.__setitem__2t##M2DJEJJr c0|jd|ddiS)N __setattr__r+rr&r's rr.zObjectProxy.__setattr__r,r c0|jd|ddiS)N__str__ _returnTyperjr&r's rr0zObjectProxy.__str__s.t##I.J'JJr c*|jd|S)N__len__r&r's rr3zObjectProxy.__len__.t##I.55r c*|jd|S)N__add__r&r's rr6zObjectProxy.__add__r4r c*|jd|S)N__sub__r&r's rr8zObjectProxy.__sub__r4r c*|jd|S)N__div__r&r's rr:zObjectProxy.__div__r4r c*|jd|S)N __truediv__r&r's rr<zObjectProxy.__truediv__r(r c*|jd|S)N __floordiv__r&r's rr>zObjectProxy.__floordiv__3t##N3T::r c*|jd|S)N__mul__r&r's rrAzObjectProxy.__mul__r4r c*|jd|S)N__pow__r&r's rrCzObjectProxy.__pow__r4r c0|jd|ddiS)N__iadd__r+rr&r's rrEzObjectProxy.__iadd__/t##J/GGGr c0|jd|ddiS)N__isub__r+rr&r's rrHzObjectProxy.__isub__rFr c0|jd|ddiS)N__idiv__r+rr&r's rrJzObjectProxy.__idiv__rFr c0|jd|ddiS)N __itruediv__r+rr&r's rrLzObjectProxy.__itruediv__s3t##N3TKUKKr c0|jd|ddiS)N __ifloordiv__r+rr&r's rrNzObjectProxy.__ifloordiv__s4t##O4dLeLLr c0|jd|ddiS)N__imul__r+rr&r's rrPzObjectProxy.__imul__rFr c0|jd|ddiS)N__ipow__r+rr&r's rrRzObjectProxy.__ipow__rFr c*|jd|S)N __rshift__r&r's rrTzObjectProxy.__rshift__1t##L1488r c*|jd|S)N __lshift__r&r's rrWzObjectProxy.__lshift__rUr c0|jd|ddiS)N __irshift__r+rr&r's rrYzObjectProxy.__irshift__r,r c0|jd|ddiS)N __ilshift__r+rr&r's rr[zObjectProxy.__ilshift__r,r c*|jd|S)N__eq__r&r's rr]zObjectProxy.__eq__-t##H-t44r c*|jd|S)N__ne__r&r's rr`zObjectProxy.__ne__r^r c*|jd|S)N__lt__r&r's rrbzObjectProxy.__lt__r^r c*|jd|S)N__gt__r&r's rrdzObjectProxy.__gt__r^r c*|jd|S)N__le__r&r's rrfzObjectProxy.__le__r^r c*|jd|S)N__ge__r&r's rrhzObjectProxy.__ge__r^r c*|jd|S)N__and__r&r's rrjzObjectProxy.__and__r4r c*|jd|S)N__or__r&r's rrlzObjectProxy.__or__ r^r c*|jd|S)N__xor__r&r's rrnzObjectProxy.__xor__ r4r c0|jd|ddiS)N__iand__r+rr&r's rrpzObjectProxy.__iand__rFr c0|jd|ddiS)N__ior__r+rr&r's rrrzObjectProxy.__ior__s.t##I.FFFr c0|jd|ddiS)N__ixor__r+rr&r's rrtzObjectProxy.__ixor__rFr c*|jd|S)N__mod__r&r's rrvzObjectProxy.__mod__r4r c*|jd|S)N__radd__r&r's rrxzObjectProxy.__radd__/t##J/66r c*|jd|S)N__rsub__r&r's rr{zObjectProxy.__rsub__ryr c*|jd|S)N__rdiv__r&r's rr}zObjectProxy.__rdiv__"ryr c*|jd|S)N __rfloordiv__r&r's rrzObjectProxy.__rfloordiv__%s4t##O4d;;r c*|jd|S)N __rtruediv__r&r's rrzObjectProxy.__rtruediv__(r?r c*|jd|S)N__rmul__r&r's rrzObjectProxy.__rmul__+ryr c*|jd|S)N__rpow__r&r's rrzObjectProxy.__rpow__.ryr c*|jd|S)N __rrshift__r&r's rrzObjectProxy.__rrshift__1r(r c*|jd|S)N __rlshift__r&r's rrzObjectProxy.__rlshift__4r(r c*|jd|S)N__rand__r&r's rrzObjectProxy.__rand__7ryr c*|jd|SN__ror__r&r's rrzObjectProxy.__ror__:r4r c*|jd|Srr&r's r__rxor__zObjectProxy.__rxor__=r4r c*|jd|S)N__rmod__r&r's rrzObjectProxy.__rmod__@ryr ct|SrB)idrs r__hash__zObjectProxy.__hash__Cs $xr )rN)Arr r r r@rrrrrrrrr!r#r%r*r.r0r3r6r8r:r<r>rArCrErHrJrLrNrPrRrTrWrYr[r]r`rbrdrfrhrjrlrnrprrrtrvrxr{r}rrrrrrrrrrrr r rr1r1sN,Z6,3(j/ Phr @,/M*(:KKK6666:;66HHHLMHH99KK555555656HGH6777<;77::7667r r1c"eZdZdZdZdZdZy)ra This class represents an attribute (or sub-attribute) of a proxied object. It is used to speed up attribute requests. Take the following scenario:: rsys = proc._import('sys') rsys.stdout.write('hello') For this simple example, a total of 4 synchronous requests are made to the remote process: 1) import sys 2) getattr(sys, 'stdout') 3) getattr(stdout, 'write') 4) write('hello') This takes a lot longer than running the equivalent code locally. To speed things up, we can 'defer' the two attribute lookups so they are only carried out when neccessary:: rsys = proc._import('sys') rsys._setProxyOptions(deferGetattr=True) rsys.stdout.write('hello') This example only makes two requests to the remote process; the two attribute lookups immediately return DeferredObjectProxy instances immediately without contacting the remote process. When the call to write() is made, all attribute requests are processed at the same time. Note that if the attributes requested do not exist on the remote object, making the call to write() will raise an AttributeError. cdD]}t|||j|<||jd<|j|fz|jd<|jj |jd<y)N)rrrr _parentrr )rr rr r)r= parentProxy attributers rr@zDeferredObjectProxy.__init__gslC 7A&{A6DMM!  7#. i '2'>'>)'M m$)4)B)B)G)G)I o&r cjtj|dzdj|jzS)Nrr)r1rrrrs rrzDeferredObjectProxy.__repr__os,##D)C/#((4;K;K2LLLr cV|jj|jddS)zO Return a non-deferred ObjectProxy referencing the same object rHF) _deferGetattr)rrrrs r_undeferzDeferredObjectProxy._undeferrs)||''(8(8(JMSr r)NN)r9rXr#rrrrrr~numpyrutilrrrr UserWarningrr rrr0rlrr1rr r rrs    )  I  [ I %I %X8f8t6[v6[r  X&Xt /S+/Sr