a Df@sdZddlmZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z mZddlmZddlmZddlmZddlmZmZdd lmZmZmZmZmZmZmZmZ m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)dd l*m+Z+ddl,Z,dd l-m.Z.dd l/m0Z0ddl1m2Z3ddl4m5Z6ddl7m8Z8m9Z9ddlm:Z:m;Z;em?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZIddl4mJZJddlKmLZLddlMmNZNddlOmPZPddlQmRZRdd lSmTZTdd!lUmVZVdd"lWmXZXdd#lYmZZZdd$l[m\Z\e&d%Z]ed&d'd(d)Z^d&d*d+d,Z_Gd-d.d.Z`e'ejeejgejfe ejfZaGd/d0d0e,jbZcecZddS)1zH Various utilities for recording and embedding state in a rendered app. ) annotationsN)Counter defaultdict)Iterator)contextmanager) ContextVar)partialwraps) TYPE_CHECKINGAny AwaitableCallableClassVar CoroutineDictrListLiteralOptionalTupleTypeTypeVarUnion)urljoin)WeakKeyDictionary)Document)UnlockedDocumentProxy)curdoc) CommManager) decode_tokenparse_timedelta)LOG_SESSION_RENDERED LOG_USER_MSGz panel.state)Future)Model)ImportedStyleSheet)BokehSessionContext)Server) DisplayHandle)CommIOLoop) BaseTemplate)Viewable)BooleanIndicator BrowserInfoPeriodicCallbackLocationNotificationArea)StoppableThreadTrdocc cs6tj|}zdVWtj|ntj|0dSN)state_curdocsetreset)r;tokenrB[/nfs/NAS7/SABIOD/METHODE/ermites/ermites_venv/lib/python3.9/site-packages/panel/io/state.py set_curdoc?s rDreturncCs4z t}WntyYdS0t|tr0|j}|Sr<)r> RuntimeError isinstancerZ_docr:rBrBrC curdoc_lockedGs   rIc@s eZdZdS) _UndefinedN)__name__ __module__ __qualname__rBrBrBrCrJPrJc @sXeZdZUdZejddddZejddddZej idd Z ej d d d Z ejd dd dZ ej ddiddd Zej d dd Zejddd Zej idd Zedd dZdZded<eZded<d Zd ZeZded<d Zded<iZeZded<d Z d ed!<eZ!d"ed#<d Z"d$ed%<eZ#d&ed'<d Z$d(ed)<eZ%d*ed+<d Z&d,ed-<eZ'd.ed/<iZ(d0ed1<gZ)d2ed3<iZ*d4ed5<iZ+d6ed7<eZ,d8ed9<iZ-d:ed;<eZ.eZ/ded?<gZ1d>ed@<gZ2d>edA<eZ3dBedC<d Z4iZ5dDedE<eZ6dFedG<gZ7dHedI<gZ8ej e9e:dZ;iZdLedM<dNe?@iZAdOedP<iZBiZCe9e:ZDe9eEZFeZGdQedR<iZHeIZJdSdTdUdVZKeLdWdTdXdYZMeLdZd[ZNeLd\dTd]d^ZOeLd_dTd`daZPeLd_dTdbdcZQeLdddTdedfZReRjSdgdhdidjdfZRdkd_dldmdnZTejUdoddpdqdrZVejUdsddpdhdTdtduZWdvdwZXdxdyZYeLdzd{ZZdSd|d}d~Z[dkdhdlddZ\dddhdlddZ]ddSd_dhdddZ^ddZ_dddkdhdddZ`dhdTddZaddddZbddSddgddddZcdddgddgd_ddddZdddSd_dddZeddZfddZgddddhdddZhdSdddZidhdTddZjddSdSdhdddZkddd_dddZlddhdddZmddhdddZnddSdddhdddÄZoddńZpd dSddddd_dhdʜdd̄ZqddhdΜddЄZrd dd҄ZsddԄZteLd\dTddքZueLd\dTdd؄ZveLddTddۄZweLddTddބZxexjSdkdhdlddބZxeLddTddZyeLddTddZzeLd_dTddZ{eLddTddZ|eLddZ}eLddTddZ~eLd\dTddZeLddZeLddTddZeLddTddZeLd\dTddZeLddTddZd S( _statezw Holds global state associated with running apps, allowing running apps to indicate their state to a user. /Tz& Base URL for all server paths.)defaultreadonlyr;FzT Whether the application is currently busy processing a user callback.z Global location you can use to cache large datasets or expensive computation results across multiple client sessions for a given server.)rQr;Nz} Object with encrypt and decrypt methods to support encryption of secret variables including OAuth information.z Relative path from the current app being served to the root URL. If application is embedded in a different server via autoload.js this will instead reflect an absolute path.r)totallivesessionsz> Tracks information and statistics about user sessions.z> Selenium webdriver used to export bokeh models to pngs.z: Count of active callbacks current being processed.z1 A dictionary used by the cache decorator.r)rQzClassVar[bool]_holdz*ClassVar[WeakKeyDictionary[Document, int]] _thread_id_zClassVar[Type[_CommManager]] _comm_managerz$ClassVar[BokehSessionContext | None]_jupyter_kernel_contextz*ClassVar[WeakKeyDictionary[Document, Any]] _ipykernelszClassVar[BrowserInfo | None]_browserz2ClassVar[WeakKeyDictionary[Document, BrowserInfo]] _browserszClassVar[Location | None] _locationz/ClassVar[WeakKeyDictionary[Document, Location]] _locationsz!ClassVar[NotificationArea | None] _notificationz7ClassVar[WeakKeyDictionary[Document, NotificationArea]]_notificationszClassVar[BaseTemplate | None] _templatez3ClassVar[WeakKeyDictionary[Document, BaseTemplate]] _templateszBClassVar[Dict[str, Tuple[Viewable, Model, Document, Comm | None]]]_viewszClassVar[List[str]] _fake_rootszKClassVar[Dict[str, Tuple[Server, Viewable | BaseTemplate, List[Document]]]]_serversz$ClassVar[Dict[str, StoppableThread]]_threadsz0ClassVar[WeakKeyDictionary[Any, Dict[str, Any]]]_server_configz/ClassVar[Dict[str, [DisplayHandle, List[str]]]]_handlesz,ClassVar[Dict[Document, Callable[[], None]]]_onloadz3ClassVar[List[Callable[[BokehSessionContext], []]]]_on_session_created_on_session_created_internal_on_session_destroyedz+ClassVar[WeakKeyDictionary[Document, bool]]_loadedz=ClassVar[Dict[str, Tuple[Iterator[int], Callable[[], None]]]] _scheduledz=ClassVar[WeakKeyDictionary[Document, List[PeriodicCallback]]] _periodicz ClassVar[List[BooleanIndicator]] _indicatorszDClassVar[WeakKeyDictionary[Document, Dict[str, ImportedStyleSheet]]] _stylesheetsz0ClassVar[WeakKeyDictionary[Document, List[str]]] _extensions_mainz#ClassVar[Dict[str, threading.Lock]] _cache_locksz5ClassVar[WeakKeyDictionary[Document, Dict[str, Any]]]_session_outputsstrrEcCsNg}|jD]&\}}}|d|jp(d|j|q|s>dSdd|S)Nz{}:{:d} - {!r} localhostzstate(servers=[])zstate(servers=[ {} ])z, )rfvaluesappendformataddressportjoin)selfZ server_infoserverZpanelZ_docsrBrBrC__repr__sz_state.__repr__z'IOLoop'cCs&tjrtSddlm}|SdS)Nrr+)r= _is_pyodideasyncioZget_running_looptornado.ioloopr,current)rr,rBrBrC_ioloops z_state._ioloopcCs"|j}|r||jvsdS|j|Sr<)rrsrr;rBrBrC _extensionssz_state._extensionsz str | NonecCstSr<) threading get_identrrBrBrC_current_threadsz_state._current_threadboolcCs,|j}|r|jr|jjsdSt|jjj S)NF)rsession_contextserver_contextrrVrrrBrBrC _is_launchingsz_state._is_launchingcCs dtjvS)NZ_pyodide)sysmodulesrrBrBrCrsz_state._is_pyodidez int | NonecCs|jr|j|jSdSr<)rrXgetrrBrBrC _thread_idsz_state._thread_idintNone) thread_idrFcCs|jr||j|j<dSr<)rrX)rrrBrBrCr sr)r;rFcCs4||juo2|j|jdfvo2| p2|j p2|j|S)a Indicates whether Document events can be dispatched or have to scheduled on the event loop. Events can only be safely dispatched if: 1. The Document to be modified is the same one that the server is currently processing. 2. We are on the same thread that the Document was created on. 3. The application has fully loaded and the Websocket is open. N)rrrrrnrrrBrBrC _unblockeds z_state._unblocked _busy_counter)watchcCs|jdk|_dS)Nr!)rbusyrrBrBrC_update_busy_countersz_state._update_busy_counterrcCs|jD] }|j|_qdSr<)rqrvaluer indicatorrBrBrC _update_busy"s z_state._update_busycCs|jjs dSddlm}|jjj}|jd|i}|ddurFdS|tt|j|jdd7<| dt j i|jddS)Nr!)loggerrVrenderedrU session_info)rrrridrrinfor"updatedtdatetimenow timestampparamtrigger)reventr session_idrrBrBrC _init_session's  z_state._init_sessionc Cs|j}|jd}||vrl||ddurl||}|ddurN|jdd8<tj|d<|jd|j}||j vr|j |D]&}z| |Wqt yYq0q|j |=||j vrt j |}||t j |=||jvr|j|}||t j|=||jvr|j|=dS)NrVZendedrrUr!r)rrrrrrrr _documentrp_cleanup Exceptionr_r=Z_server_destroyrarc) rrrrVsessionr;cblocZ notificationrBrBrC_destroy_session6s4            z_state._destroy_sessioncCs>t}|j|d}|dur:ddlm}|}||j|<|S)Nr!)_Stack)rcurrent_thread_stacksrcacher)rrstackrrBrBrC_current_stackZs  z_state._current_stack)endpointcsifdd}|S)Nc sJ|d}|jdur|jn|j}jd}||vr8dSt|gfdd|DsbdStt|<|D]}t|vrqvzrz|jjfiWntyYn0Wt|vrfddt|D}|r|t|<n t|=qvt|vrBfddt|D}|r8|t|<n t|=0qvdS)Nrcs i|]}|jvr|j|jqSrB)namenew).0r)updatingrBrC ms z6_state._get_callback..link..csg|]}|vr|qSrBrB)rp)ryrBrC {rNz6_state._get_callback..link..) objcls_rest_endpointsrrlistrrr)eventsrrparameterizeds parameterizedZ not_updatedZ _updatingrr)rryrClinkfs6     z"_state._get_callback..linkrB)rrrrBrrC _get_callbackdsz_state._get_callbackcCs:|jr,|j|j|}|t|j|dn ||dS)Nr:) _thread_poolsubmit_on_loadadd_done_callbackr_handle_future_exception)rr;rfuturerBrBrC_schedule_on_loadsz_state._schedule_on_loadzOptional[Document]c Csp|p|j}||jvr"d|j|<dSddlm}ddlm}t| |rT||jvsZ|js||jvr|j |D]\}}|j ||rdnddqpqZd|j|<WddS||jH}||jvr|j |D]\}}|j ||rdnddqqWdn1s0Y|j j j }|j|d |jf|7<|jd Wdn1sX0Yd|j|<dS) NTrconfigr!) profile_ctxthreadFschedulez:on_load _profiles)rrjrnrprofilerrD _launchingZprofilerpopexecuterrequestpathrrr)rr;rrrthreadedrVrrBrBrCrs*          : ,z_state._on_load)rrrFc s||jvrdS|j|\}}z t|}WntyFd}|j|=Yn0|dur~tj}||}|jj|t |j |dz|j ||rdnddWn.ty}z| |WYd}~n d}~00dS)Ndelaycallbackrautor) ronextrrrrrr call_laterr _scheduled_cbr_handle_exception) rrrditerratrcall_time_secondserBrBrCrs    z_state._scheduled_cbcstfdd}|S)Nc sDz|i|WSty>}z|WYd}~n d}~00dSr<)rr)argskwrrrrBrCwrappersz1_state._handle_exception_wrapper..wrapper)r )rrrrBrrC_handle_exception_wrappersz _state._handle_exception_wrapperr$)rr;rFcCsJ|}|durdSt|||Wdn1s<0YdSr<) exceptionrDr)rrr;rrBrBrCrs  z_state._handle_future_exceptioncCsFddlm}|jr||n$t|tr.|n|jd|dddS)Nrrz"Exception of unknown type raised: error)level)rZexception_handlerrH BaseExceptionlog)rrrrBrBrCrs    z_state._handle_exceptionr')rcCs|jD]}|j|qdSr<)rmron_session_destroyed)rrrrBrBrC_register_session_destroyeds z"_state._register_session_destroyedzCallable[[], T]r9)keyfnttlrFc KsV|ftddt|D}|r0t|nd}|jd8||jvrV|j|}nt|j|<}Wdn1s|0Yz|r||jvr|j |\}}n t d}}|t us|dur|tkr|fi||f\}} |j|<Wdn1s0YW| sR||jvrR|j|=n | sP||jvrP|j|=0|S)a& Caches the return value of a function globally across user sessions, memoizing on the given key and supplied keyword arguments. Note: Keyword arguments must be hashable. Example: >>> def load_dataset(name): >>> # some slow operation that uses name to load a dataset.... >>> return dataset >>> penguins = pn.state.as_cached('dataset-penguins', load_dataset, name='penguins') Arguments --------- key: (str) The key to cache the return value under. fn: (callable) The function or callable whose return value will be cached. ttl: (int) The number of seconds to keep an item in the cache, or None if the cache should not expire. The default is None. **kwargs: dict Additional keyword arguments to supply to the function, which will be memoized over as well. Returns ------- Returns the value returned by the cache or the value in the cache. css|]\}}||fVqdSr<rBrkvrBrBrC rNz#_state.as_cached..Nrt) tuplesorteditemstime monotonicrurLockrrrJlocked) rrrrkwargsZ new_expirylockretZexpiry_rBrBrC as_cacheds$    0  B  z_state.as_cachedz.Callable[[], None] | Coroutine[Any, Any, None]z Optional[int]r3)rperiodcounttimeoutstartrFcCs\ddlm}|||||d}|r(||jrX|j|jvrFg|j|j<|j|j||S)a Schedules a periodic callback to be run at an interval set by the period. Returns a PeriodicCallback object with the option to stop and start the callback. Arguments --------- callback: callable Callable function to be executed at periodic interval. period: int Interval in milliseconds at which callback will be executed. count: int Maximum number of times callback will be invoked. timeout: int Timeout in seconds when the callback should be stopped. start: boolean (default=True) Whether to start callback immediately. Returns ------- Return a PeriodicCallback object with start and stop methods. r!r2)rrrr) callbacksr3rrrprz)rrrrrrr3rrBrBrCadd_periodic_callback s   z_state.add_periodic_callback)rwaitcCsD||jvrtd|d|r8d|j|df|j|<n|j|=dS)a Cancel a task scheduled using the `state.schedule_task` method by name. Arguments --------- name: str The name of the scheduled task. wait: boolean Whether to wait until after the next execution. zNo task with the name z has been scheduled.Nr!)roKeyError)rrrrBrBrC cancel_task1s z_state.cancel_taskc Cs^|jD]D}|t|dr |jzt|jWq t yLYq 0q |jdS)zE Clears caches generated by panel.io.cache function. directoryN) _memoize_cacheryclearhasattrrcloseshutilrmtreerOSError)rrrBrBrC clear_cachesCs   z_state.clear_cachescCsTt|8tj|r$tj|n|j|ddWdn1sF0YdS)NFr)rDrriscoroutinefunctionasync_executorr)rr;rrBrBrC_execute_on_threadQs  z_state._execute_on_threadrzCallable([], None)z bool | Literal['auto', 'thread'])rrrFc Cs|j}|dkr@tjstdtjt|j||}||jnt j |rZt j |np|r|j r|dks~|dkr||s|||n:z |Wn.ty}zt|WYd}~n d}~00dS)aR Executes both synchronous and asynchronous callbacks appropriately depending on the context the application is running in. When running on the server callbacks are scheduled on the event loop ensuring the Bokeh Document lock is acquired and models can be modified directly. Arguments --------- callback: Callable[[], None] Callback to execute schedule: boolean | Literal['auto', 'thread'] Whether to schedule the callback on the event loop, on a thread or execute them immediately. rz_Cannot execute callback on thread. Ensure you have enabled threading setting `config.nthreads`.TrN)rr=rrGrrr%rrrrr#r$rrZadd_next_tick_callbackrrr)rrrr;rrrBrBrCrXs  $ z_state.executercs0ddlm}|fddtjDddS)z Returns the requested profiling output. Arguments --------- profile: str The name of the profiling output to return. Returns ------- Profiling output wrapped in a pane. r!) get_profilescs&i|]\\}}}|kr||f|qSrBrB)rnrZpsr&rBrCrsz&_state.get_profile..r)rr'r=rr)rrr'rBr&rC get_profiles z_state.get_profilec Csh|jD]H}||jvr$|j|qz|j|dWqtyLYq0q|j|jdS)zI Stop all servers and clear them from the current state. rN)rfrgstopAssertionErrorr)rZ server_idrBrBrCkill_all_serverss    z_state.kill_all_serversr)msgrrFcCs@d}|jr"t|jf}tj|d}tt||g|RdS)z Logs user messages to the Panel logger. Arguments --------- msg: str Log message level: str Log level as a string, i.e. 'debug', 'info', 'warning' or 'error'. rB)r-N)rrr#r{getattr _state_loggerlower)rr-rrrBrBrCrs   z _state.logz@Callable[[], None | Awaitable[None]] | Coroutine[Any, Any, None])rrcCsp|jdus|js|jr>|jr,|j|ddn|j|dddS|j|jvrVg|j|j<|j|j||fdS)aC Callback that is triggered when a session has been served. Arguments --------- callback: Callable[[], None] | Coroutine[Any, Any, None] Callback that is executed when the application is loaded threaded: bool Whether the onload callback can be threaded NrrF)rrloadedrrrjrz)rrrrBrBrConloads   z _state.onloadz%Callable[[BokehSessionContext], None])rrFcCs&|jr|jjrtd|j|dS)zG Callback that is triggered when a session is created. zCannot register session creation callback from within a session. If running a Panel application from the CLI set up the callback in a --setup script, if starting a server dynamically set it up before starting the server.N)rrrGrkrz)rrrBrBrCon_session_createds z_state.on_session_createdcCs@|j}|r||n&|j|jvr0|j|j|j|dS)zI Callback that is triggered when a session is destroyed. N)rrrrkrzrm)rrr;rBrBrCrs   z_state.on_session_destroyedzparam.ParameterizedzOptional[List[str]])rr parametersrFcsdurt|j|dr(|dd}||jvr|j|\}}}tt|krZtdfdd|djD}|jjfi|| |n| |}|g|f|j|<|j |dS)a Publish parameters on a Parameterized object as a REST API. Arguments --------- endpoint: str The endpoint at which to serve the REST API. parameterized: param.Parameterized The Parameterized object to publish parameters from. parameters: list(str) or None A subset of parameters on the Parameterized to publish. NrPr!z.r) rr startswithrr? ValueErrorryrrrzrr)rrrr4rZold_parametersrryrBr5rCpublishs       z_state.publishcCs||jd|_|j|j|j|j|j|j |j durr|j j ddd|_ |j |j |j|jdS)zz Resets the state object killing running servers and clearing any other state held by the server. NF)r)r,rqrr^r_rcrdrnrrorshutdown _sessions_session_key_funcsrkrmrrBrBrCr@s            z _state.resetzCallable[[], None]Tatzstr | dt.timedeltaz Optional[str])rrrrcronrrFc s||jvr:||j|dur6|jd|d|ddSt|dddrTtd |durttrntfd d }|}n,d d l m } durt j n} | || }t j } zt|| } WntyYdS0||f|j|<|jj| t|j||ddS)ac Schedules a task at a specific time or on a schedule. By default the starting time is immediate but may be overridden with the `at` keyword argument. The scheduling may be declared using the `period` argument or a cron expression (which requires the `croniter` library). Note that the `at` time should be in local time but if a callable is provided it must return a UTC time. Note that the scheduled callback must not be defined within a script served using `panel serve` because the script and all its contents are cleaned up when the user session is destroyed. Therefore the callback must be imported from a separate module or should be scheduled from a setup script (provided to `panel serve` using the `--setup` argument). Note also that scheduling is idempotent, i.e. if a callback has already been scheduled under the same name subsequent calls will have no effect. This is ensured that even if you schedule a task from within your application code, the task is only scheduled once. Arguments --------- name: str Name of the scheduled task callback: callable Callback to schedule at: datetime.datetime, Iterator or callable Declares a time to schedule the task at. May be given as a datetime or an Iterator of datetimes in the local timezone declaring when to execute the task. Alternatively may also declare a callable which is given the current UTC time and must return a datetime also in UTC. period: str or datetime.timedelta The period between executions, may be expressed as a timedelta or a string: - Week: '1w' - Day: '1d' - Hour: '1h' - Minute: '1m' - Second: '1s' cron: str A cron expression (requires croniter to parse) threaded: bool Whether the callback should be run on a thread (requires config.nthreads to be set). r!z5A separate task was already scheduled under the name zk. The new task will be ignored. If you want to replace the existing task cancel it with `state.cancel_task(z7)` before adding adding a new task under the same name.NrLrS bokeh_app_zCannot schedule a task from within the context of an application. Either import the task callback from a separate module or schedule the task from a setup script that you provide to `panel serve` using the --setup commandline argument.c3sttr t}|Vq nVtr`tj}|durBt|j tj j d Vq(ndurvVtptj }|V|7}qdS)N)tzinfo)rHrrrcallablerrutcnow StopIterationreplacetimezoneutc astimezoner)rZnew_timerrrBrCdgen`s   z"_state.schedule_task..dgenr)croniterr)rorwarningr.r6rGrHrwr rIrrrrrrBrrrr) rrrrrr=rrHrrIbaserrrBrGrC schedule_tasks>7     z_state.schedule_taskr/)rrFcCs2t|jjtjstd||jvr.|j|dS)z Syncs the busy state with an indicator with a boolean value parameter. Arguments --------- indicator: An BooleanIndicator to sync with the busy property z:Busy indicator must have a value parameterof Boolean type.N)rHrrBooleanr7rqrzrrBrBrC sync_busys  z_state.sync_busycCsHddlm}ddlm}|j|}|dur0dS||j||}||S)Nrdecode_signed_valuerr) tornado.webrPrcookiesr cookie_secret_decrypt_cookie)rZ cookie_namecookierPrrBrBrC_decode_cookies   z_state._decode_cookiecCs&|jdur|dS|j|dS)Nutf-8) encryptiondecodeZdecrypt)rrUrBrBrCrTs  z_state._decrypt_cookiecCs|j|jvr,d|j|jvr,|j|jdS|d}|s>dSz t|}Wnty`|YS0|dtjtjj  krdS|S)z< Returns the OAuth access_token if enabled. access_tokenNexp) user_oauth_user_overridesrVrrrrrrDrEr)rrZ decoded_tokenrBrBrCrZs    z_state.access_tokencCs>|js dS|jjjjj}|dr.|ddn|}t|j|S)zN Returns the URL of the app that is currently being executed. NrPr!)rrrZapplication_contexturlr6rbase_url)rapp_urlrBrBrCras z_state.app_urlzBrowserInfo | NonecCsddlm}ddlm}|jrL|jrL|jjrL|j|jvrL|}|j|j<nB|jdurv|jdurn|jrn||_|j}n|jr|j|jnd}|S)Nrrr!r0) rbrowserr1 browser_inforrr]r\r)rrr1rbrBrBrCrcs    z_state.browser_infozDocument | NonecCsZ|j}|r|Sz.t}|jo(dtjv}|r>|js8|r>|WSWntyTYdS0dS)zH Returns the Document that is currently being executed. Zpyodide_kernelN)r>rrIrrrrr)rrr;Zpyodide_sessionrBrBrCrs   z _state.curdoccCs|j|dS)z1 Overrides the current Document. N)r>r?rrBrBrCrszDict[str, str]cCs|jr|jjr|jjjjSiS)z[ Returns the cookies associated with the request that started the session. )rrrrRrrBrBrCrRsz_state.cookieszDict[str, str | List[str]]cCs|jr|jjr|jjjjSiS)zZ Returns the header associated with the request that started the session. )rrrheadersrrBrBrCrdsz_state.headerscCs,|j}|r(||jvr|j|S|jr(dSdS)z@ Whether the application has been fully loaded. FT)rrnrrrBrBrCr1s  z _state.loadedzLocation | NonecCsz|jrL|j|jvrLddlm}|jjr8||jjj}n|}||j|j<n*|jdur^|j}n|jrr|j|jnd}|S)Nr!r4) rr_locationr5rZ from_requestrr^r)rr5rrBrBrCres  z_state.locationcCsddlm}|S)Nr!) log_terminal)Zadminrf)rrfrBrBrCrfs z_state.log_terminalzNotificationArea | NonecCsddlm}|jr|jr|jjr|j|jvrddlm}i}|jrTd|jdd|d<|jrjd |jd |d <||d |j|j<}|S|jdus|jjdur|jS|jr|j |jSdSdS) Nrrr!r6successi )typemessagedurationZdocument_readyr)rhriZconnection_lost) js_events) r notificationsrrrar7Zready_notificationZdisconnect_notificationr`r)rrr7rkrlrBrBrCrls   z_state.notificationscCs|j|jvr&d|jvr&|j|jdS|d}|s8dSz t|}WntyZ|YS0|dtjtjj  kr|dS|S)zK Returns the OAuth refresh_token if enabled and available. refresh_tokenNr[) r\r]rVrr7rrrrDrEr)rrmr^rBrBrCrm%s    z_state.refresh_tokencCs6ztdjjddWSty0YdS0dS)zx Whether we are currently inside a script or notebook that is being served using `panel serve`. r!rKr>FN)inspectrframe f_globalsr6rrrBrBrCserved7s z _state.servedzDict[str, List[bytes]]cCs|jr|jjr|jjjjSiS)ze Returns the request arguments associated with the request that started the session. )rrr argumentsrrBrBrC session_argsBsz_state.session_argszBaseTemplate | NonecCsjddlm}|j|jvr$|j|jS|jdur:|jr:|jS|j|jd}|jdurZ||_n ||j|j<|S)Nrr)theme)rrrcrbtemplatert)rrrurBrBrCruIs     z_state.templatecCsbddlm}ddlm}|jd}|r,dS|jd}|dusJ|jdurNdS||jd|d S) z4 Returns the OAuth user if enabled. rrOrris_guestguestr\NrW)rQrPrrRrrSrY)rrPrrvr\rBrBrCr\Ws    z _state.userzDict[str, Any] | NonecCs8|jd}|rdddS|d}|dur0dSt|S)z@ Returns the OAuth user information if enabled. rvrw)r\usernameid_tokenN)rRrrVr)rrvryrBrBrC user_infohs   z_state.user_info)N)F)N)N)rNNT)F)r)r)F)N)NNNF)N)rKrLrM__doc__rStringr`rMrrr ParameterrXrel_pathrZ webdriverZIntegerrrrr>rW__annotations__rrXrZ_admin_context _CommManagerrYrZZ_kernelsr[r\r]r^r_r`rarbrcrdrerfrgrhrirrjrkrlrmrnZ _setup_modulerorprqrrrrrrrrsrr rur:r;Z _cell_outputsdictZ _cell_layoutsrvr]rZ _active_usersrpropertyrrrrrrsetterrdependsrrrrrrrrrrrrrrrrr"r%rr)r,rr2r3rr8r@rLrNrVrTrZrarcrrRrdr1rerfrlrmrqrsrur\rzrBrBrBrCrOTs.                        $   6' '  m       rO)er{ __future__rrrrrnloggingrrrr collectionsrrcollections.abcr contextlibrZ contextvarsr functoolsrr typingr r r r rrrZ TIteratorrrrrrrr urllib.parserweakrefrrZbokeh.documentrZbokeh.document.lockingrZbokeh.iorr>Z pyviz_commsrrutilrr r"r# getLoggerr/concurrent.futuresr$Z bokeh.modelr%Z bokeh.modelsr&Zbokeh.server.contextsr'Zbokeh.server.serverr(ZIPython.displayr)r*rr,Z template.baser-Zviewabler.Zwidgets.indicatorsr/rbr1rr3rer5rlr7rr8r9rDrIrJr<Z ParameterizedrOr=rBrBrBrCst    D                        $)