dQje]zdZddlZddlZddlZddlZddlmZmZddlmZm Z ddl m Z m Z m Z mZmZmZmZmZmZmZddlZddlmZddlmZddlmZdd lmZdd lmZm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'ejPe)Z*eGd dZ+ejXZ-de+fdZ.dZ/ddZ0ddZ1de!de!fdZ2Gdde3Z4GddZ5 ddl6m7Z7e7jpe5_9e5jpe7_8eee&e fZ?ee?Z@e e?ZAeeAe@fZBGddeZCy#e:$re*jwdY?wxYw)uUServer-Sent Events response for Starlette / FastAPI. Intentional divergence from ``starlette.responses.StreamingResponse`` -------------------------------------------------------------------- ``EventSourceResponse`` is modelled on Starlette's ``StreamingResponse`` and re-syncs most of its behaviour (WebSocket denial, ``collapse_excgroups()`` around the task group, ``memoryview`` chunk handling). The following points are deliberate divergences — DO NOT "fix" them without reading the rationale: 1. ASGI ``spec_version >= 2.4`` fast path is NOT adopted. Upstream short-circuits to ``await stream_response(send)`` and converts ``OSError`` into ``ClientDisconnect``, skipping ``listen_for_disconnect``. We keep ``_listen_for_disconnect`` running because it (a) invokes ``client_close_handler_callable`` on disconnect, (b) flips ``self.active = False`` so ``_ping`` and the cooperative shutdown grace loop exit promptly. Adopting the upstream fast path would regress both features. 2. ``_wrap_websocket_denial_send`` is inlined in this module rather than inherited from ``starlette.responses.Response``. The helper landed on Starlette ``main`` after our minimum pin (``starlette>=0.41.3``); inline until the floor moves past the release that contains it. 3. ``collapse_excgroups()`` is vendored in ``sse_starlette._utils`` rather than imported from ``starlette._utils`` (private module). 4. HEAD is answered with headers and an empty body; the stream never starts (Issue #218). Upstream ``StreamingResponse`` streams on HEAD too, which is harmless for finite bodies but never completes for an endless SSE generator, wedging keep-alive connections. Same contract as Starlette's ``FileResponse``: headers match GET, the background task still runs, and neither the iterator nor ``data_sender_callable`` is touched. N) dataclassfield)datetimetimezone) Any AsyncIterable AwaitableCallable CoroutineIteratorMappingOptionalSetUnion)BackgroundTask)iterate_in_threadpool)MutableHeaders)Response)ReceiveScopeSendMessage)collapse_excgroups)ServerSentEvent ensure_bytescVeZdZUdZeeZeeje d<dZ e e d<y)_ShutdownStatezPer-thread state for shutdown coordination. Issue #152 fix: Uses threading.local() instead of ContextVar to ensure one watcher per thread rather than one per async context. )default_factoryeventsFwatcher_startedN) __name__ __module__ __qualname____doc__rsetrranyioEvent__annotations__r boolV/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/sse_starlette/sse.pyrrEs+ %S9FC 9!OT!r+rreturncVttdd}|t}|t_|S)z4Get or create shutdown state for the current thread.shutdown_stateN)getattr _thread_staterr/)states r,_get_shutdown_stater3Us+ M#3T :E } ', $ Lr+c tjtj}t|dr|j}t|dr|Sy#t $rYywxYw)am Try to get uvicorn Server instance via signal handler introspection. When uvicorn registers signal handlers, they're bound methods on the Server instance. We can retrieve the Server from the handler's __self__ attribute. Returns None if: - Not running under uvicorn - Signal handler isn't a bound method - Any introspection fails __self__ should_exitN)signal getsignalSIGTERMhasattrr5 Exception)handlerservers r,_get_uvicorn_serverr>^s[ ""6>>2 7J '%%Fv}-      sAA AAcTKt} t}tjrn=tjr| |jrnt j dd{Xt|jD]}|j d|_ y78#d|_ wxYww)ag Poll for shutdown and broadcast to all events in this context. One watcher runs per thread (event loop). Checks two shutdown sources: 1. AppStatus.should_exit - set when our monkey-patch works 2. uvicorn Server.should_exit - via signal handler introspection (Issue #132 fix) When either becomes True, signals all registered events. Ng?F) r3r> AppStatusr6enable_automatic_graceful_drainr&sleeplistrr%r )r2uvicorn_serverevents r,_shutdown_watcherrFus !E&12N$$ 99"."..++c" " "#(%,,' E IIK !& #!&s/ B(AB!B"/BB(B B%%B(ct}|js6d|_ tj}|j t yy#t $r d|_YywxYw)zDEnsure the shutdown watcher is running for this thread (event loop).TFN)r3r asyncioget_running_loop create_taskrF RuntimeError)r2loops r,$_ensure_watcher_started_on_this_looprMs^  !E  $ *++-D   .0 1 !  *$)E ! *s-AA! A!sendc$dtddffd }|S)a;Mirror of ``starlette.responses.Response._wrap_websocket_denial_send``. Divergence #2 (see module docstring): inlined because the helper landed on Starlette ``main`` (commit 9ee9519) after our minimum pin ``starlette>=0.41.3``. Drop this once the floor moves past the release that contains it. messager-NcZK|d}|dvr i|dd|zi}|d{y7w)Ntype>http.response.bodyhttp.response.startz websocket.r*)rP message_typerNs r,wrappedz,_wrap_websocket_denial_send..wrappeds<v H HFF&,*EFG7ms +)+)r)rNrVs` r,_wrap_websocket_denial_sendrWsw4 Nr+c eZdZy)SendTimeoutErrorN)r!r"r#r*r+r,rYrYsr+rYc^eZdZUdZdZdZdZeee d<e dZ e dZ e dZ y) r@z\Helper to capture a shutdown signal from Uvicorn so we can gracefully terminate SSE streams.FTNoriginal_handlercdt_y)aJ Prevent automatic SSE stream termination on server shutdown. WARNING: When disabled, you MUST set AppStatus.should_exit = True at some point during shutdown, or streams will never close and the server will hang indefinitely (or until uvicorn's graceful shutdown timeout expires). FNr@rAr*r+r, disable_automatic_graceful_drainz*AppStatus.disable_automatic_graceful_drains 5: 1r+cdt_y)a Re-enable automatic SSE stream termination on server shutdown. This restores the default behavior where SIGTERM triggers immediate stream draining. Call this to undo a previous call to disable_automatic_graceful_drain(). TNr]r*r+r,$enable_automatic_graceful_drain_modez.AppStatus.enable_automatic_graceful_drain_modes 59 1r+ctjr dt_tjtj|i|yy)NT)r@rAr6r[)argskwargss r, handle_exitzAppStatus.handle_exits7  4 4$(I !  % % 1  & & 7 7 2r+)r!r"r#r$r6rAr[rr r( staticmethodr^r`rdr*r+r,r@r@sZfK&*#+/hx(/ : :9988r+r@)ServerzHUvicorn not installed. Graceful shutdown on server termination disabled.ceZdZdZdZdZ d%dededee e e fde d ee d ee ee fd ee d eegefd eegedfdee deeegedfdeej(de ddfdZede ee ffdZej0de ee fddfdZd&deddfdZdededdfdZdeddfdZdeddfdZe d'd Z!d'd!Z"deddfd"Z#d#e$dededdfd$Z%y)(EventSourceResponseaStreaming response implementing the SSE (Server-Sent Events) specification. Args: content: Async iterable or sync iterator yielding SSE event data. status_code: HTTP status code. Default: 200. headers: Additional HTTP headers. media_type: Response media type. Default: "text/event-stream". background: Background task to run after response completes. ping: Ping interval in seconds. Default: 15. Set to 0 to disable keep-alive pings entirely (no ping task is started). sep: Line separator for SSE messages ("\r\n", "\r", or "\n"). ping_message_factory: Callable returning custom ping ServerSentEvent. data_sender_callable: Async callable for push-based data sending. send_timeout: Timeout in seconds for individual data or heartbeat sends. client_close_handler_callable: Async callback on client disconnect. shutdown_event: Optional ``anyio.Event`` set by the library when server shutdown is detected. Generators can watch this event to send farewell messages and exit cooperatively instead of receiving CancelledError. shutdown_grace_period: Seconds to wait after setting ``shutdown_event`` before force-cancelling the generator. Must be >= 0. Should be less than your ASGI server's graceful shutdown timeout. Default: 0 (immediate cancel, identical to pre-v3.3.0 behavior).  Ncontent status_codeheaders media_type backgroundpingsepping_message_factorydata_sender_callable)NNN send_timeoutclient_close_handler_callableshutdown_eventshutdown_grace_periodr-cZ|dvrtd||xs |j|_t|tr||_nt ||_||_| |jn||_||_ | |_ | |_ t}||j||jddd|d<d|d<|j|| |j n||_||_| |_| d kr td | |_| |_d |_t/j0|_y) N)Nrj  z'sep must be one of: \r\n, \r, \n, got: z Cache-Controlzno-storez keep-alive ConnectionnozX-Accel-Bufferingrz"shutdown_grace_period must be >= 0T) ValueErrorDEFAULT_SEPARATORrq isinstancer body_iteratorrrlrnrorsrtrupdate setdefault init_headersDEFAULT_PING_INTERVAL ping_intervalrrru_shutdown_event_shutdown_grace_periodactiver&Lock _send_lock)selfrkrlrmrnrorprqrrrsrtrurvrw_headerss r,__init__zEventSourceResponse.__init__s3* 0 0J3%PQ Q0$00 g} -!(D !6w!?D &-7-?$//Z$$8!("#   OOG $ OZ8!-(,$% (#;?= 0 (0 disables ping))rintfloat TypeErrorr}r)rrs r,rz!EventSourceResponse.ping_interval_s7%#u.@A A 19KL L#r+forcectd)Nz-Compression is not supported for SSE streams.)NotImplementedError)rrs r,enable_compressionz&EventSourceResponse.enable_compressiongs!"QRRr+rNrPcKtj|j5}||d{dddr|jr t yy7&#1swY%xYww)z@Send one ASGI message, applying the response's per-send timeout.N)r& move_on_afterrt cancel_calledrY)rrNrP cancel_scopes r,_send_with_timeoutz&EventSourceResponse._send_with_timeoutjs`  !2!2 3 |w-    L66"$ $7<   s+ A# AAA"A#AA A#cK|d|j|jdd{|j23d{}t||j}t j d| |j|d|ddd{U7e7R7 #t$r}t|jdd}|btjd 5 |d{7n$#t$rt jd YnwxYwddd#1swYxYwwxYw6|j4d{7d |_|dd d dd{7dddd{7y#1d{7swYyxYww) zHSend out SSE data to the client as it becomes available in the iterator.rTrRstatusrmNz chunk: %srSTrRbody more_bodyaclose)shieldz2Error closing body iterator after interrupted sendFr+)rl raw_headersrrrqloggerdebugr BaseExceptionr0r& CancelScoper; exceptionrr)rrNdatachunkrs r,_stream_responsez$EventSourceResponse._stream_responsers}-**++    ,,  $ txx0E LLe , --15tT  ! !!3!3XtD%**$7"((NN(",, T -,?? X XDK 4cPUVW W W X X X X Xs$E5B E5DBD-E5-BBB E5DB8D D  CC CD C> ;D =C> >D  D D  DE5,D/-E51E E  E  E5EE5 E2&E) 'E2.E5receivecK|jrg|d{}|ddk(rBd|_tjd|jr|j|d{y|jrfyy7]7w)uqWatch for a disconnect message from the client. Divergence #1 (see module docstring): kept unconditionally instead of adopting Starlette's ASGI 2.4 ``OSError → ClientDisconnect`` fast path, because this loop drives ``client_close_handler_callable`` and flips ``self.active = False`` for ``_ping`` and the shutdown grace loop. NrRzhttp.disconnectFz+Got event: http.disconnect. Stop streaming.)rrrru)rrrPs r,_listen_for_disconnectz*EventSourceResponse._listen_for_disconnectslkk#IoGv"33#  JK55<.cancel_on_finish,s'&LL++224!s 0. 0c&jSr)rrrNsr,z.EventSourceResponse.__call__..1sd.C.CD.Ir+rc&jSr)rrsr,rz.EventSourceResponse.__call__..5sDJJtDTr+c&jSr)r)rrsr,rz.EventSourceResponse.__call__..?sd.I.I'.Rr+)rWupperrrlrrorr&create_task_groupr r start_soonrrrs)rrrrNrrs` `` @r,__call__zEventSourceResponse.__call__s =K '.t4D =F "uX'<'<'>&'H))1"..#//  ))3SuU  *oo'''   ! ..0  J5"io:M1N5%%$&I&&*))*:rFrMrW TimeoutErrorrYr@ uvicorn.mainrfrdr[ ImportErrorrrbytesdictContentSyncContentStreamAsyncContentStreamrrhr*r+r,rs^!F ('    /73(993=   8 $ "" " ! ^.%&P *dt$ | #8#8L#!'!3!3I"..F UD/36 7W%"7+(*;;< M$(M$ LLRs(D!!D:9D: