o e@sUddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZddlmZddlmZddlmZddlmZmZmZmZmZmZddlZddlZddlmZdd lm Z dd lm!Z"dd l#m$Z$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m!Z!m1Z1ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9m:Z:ddl;mZ>m?Z?ddl@mAZBddl@mCZDddlEmFZFmGZGmHZHmIZImJZJddlKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSzddlTZTWn eUydZTYnwe%derddlVmWZWddlXmYZYdde0Ze0Ae0[e0\e0]fDZ^de_d<GdddZ`Gdd d e`ZaGd!d"d"Zbdd0d1ZddPsr=zdict[str, Theme]BUILT_IN_THEMESc@seZdZddddddddEddZddZddZdFddZdGddZ               dHdId:d;Zd|g}|durJ|sJt|||tjdurVt|d|durb|d krbtd |rq| rqtd |d |d |r{|r{t ||}n|rtd|rt |nd\}}}tjj t |||||||du| dur| durt| ddtjjD}| |krtd| d||} |dur|du}id| s|jgngd|ddd|Dddd|Dd|dud| d|durdn| d| dtrdn|d|d |d!| d"|d#|pgd$t|t|p%t|d%d&|d'|d(|i}tjj ||ttjjd)fS)*aU Adds an event to the component's dependencies. Parameters: event_name: event name fn: Callable function inputs: input list outputs: output list preprocess: whether to run the preprocess methods of components postprocess: whether to run the postprocess methods of components scroll_to_output: whether to scroll to output of dependency on trigger show_progress: whether to show progress animation while running. api_name: defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name. js: Experimental parameter (API may change): Optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components no_target: if True, sets "targets" to [], used for Blocks "load" event queue: If True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app. batch: whether this function takes in a batch of inputs max_batch_size: the maximum batch size to send to the function cancels: a list of other events to cancel when this event is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. every: Run this event 'every' number of seconds while the client connection is open. Interpreted in seconds. Queue must be enabled. collects_event_data: whether to collect event data for this event trigger_after: if set, this event will be triggered after 'trigger_after' function index trigger_only_on_success: if True, this event will only be triggered if the previous event was successful (only applies if `trigger_after` is set) Returns: dependency information, dependency index TcS|jSrmrNxr8r8r<z)Block.set_event_trigger..)keyFNcSrrmrrr8r8r<rrz?() and other events can only be called within a Blocks context.rz(Parameter every must be positive or Nonez Cannot run z event in a batch and every zA seconds. Either batch is True or every is non-zero but not both.z.Cannot set a value for `every` without a `fn`.NNNcSg|]}|dqSr|r8r:depr8r8r< z+Block.set_event_trigger.. api_name  already exists, using targetstriggerrtcSg|]}|jqSr8rr:r\r8r8r<rrvcSrr8rrr8r8r<rr backend_fnr~rr|rzr{rrrrtypes)Z continuous generatorrrrrI)rOsetsortedlistr/rr[AttributeErrorrdr4r%fnsr` BlockFunctionrappend_unique_suffix dependencieswarningswarnrN get_spacerFinspectisgeneratorfunctionlen)rWrqrrrtrvrxryrzr{r|r~rrrrrrrrrinputs_as_dict_progress_indexZevent_data_index api_name_ dependencyr8r8r<set_event_triggers /              zBlock.set_event_triggercCs|j|j|j|jdS)NrCrArBrDrrar8r8r< get_config5s zBlock.get_configdictcKsiSrmr8rKr8r8r<update=sz Block.updategeneric_updatedict[str, Any]cCs"|}|d=|jdi|}|S)N__type__r8)copyr)clsrZspecific_updater8r8r<get_specific_updateBszBlock.get_specific_update) r@rFrArGrBrHrCrFrDrGrErF)rgrP)rgrl)TTFroNNFNFrpNNNNF)(rqrPrrrsrtrurvrwrxrFryrFrzrFr{rPr|r}r~rGrrFrrrrFrrrrrrrrrrrrFrgr)rgr)rrrgr)rV __module__ __qualname__rXr@rfrkrnrr staticmethodrr classmethodrr8r8r8r<r?\sF     r?c@sTeZdZ  ddddZdd d Zd d Zdd dZddZddddZddZ dS) BlockContextTrCrFr@cKs"g|_tj|f||d|dS)z Parameters: visible: If False, this will be hidden but included in the Blocks config file (its visibility can later be updated). render: If False, this will not be included in the Blocks config file at all. )rCr@N)rbr?rX)rWrCr@rLr8r8r<rXKs zBlockContext.__init__childr?cCs|j|dSrm)rbr`rWrr8r8r< add_childYszBlockContext.add_childcCstj|_|t_|Srm)rr\rSrar8r8r< __enter__\szBlockContext.__enter__cCs||_|j|dSrm)rSrbr`rr8r8r<r]aszBlockContext.addcCsg}d}|jD]C}|}|rt||rd}||q|dur+t||r+||n|dd}||_||||tjrG|tjj|j <||_q||_dS)NF)r@) rbrnrOr`rrSrr[r5rN)rWrbZ pseudo_parentrZexpected_parentr8r8r<fill_expected_parentses&        z"BlockContext.fill_expected_parentsNexc_typetype[BaseException] | NonecGs0|jt_|dur dSt|ddr|dSdS)NZallow_expected_parentsT)rSrr\getattrrrWrargsr8r8r<__exit__|s   zBlockContext.__exit__cCs|S)zO Any postprocessing needed to be performed on a block context. r8)rWyr8r8r<ryszBlockContext.postprocess)TT)rCrFr@rF)rr?rmrr) rVrrrXrrr]rrryr8r8r8r<rJs    rc@s2eZdZ ddd d ZddZddZddZdS)rFrrrsrtlist[Component]rvrxrFryrtracks_progresscCs\||_||_||_||_||_||_d|_d|_||_|dur%t |ddnd|_ | dS)NrrVrr) rrrtrvrxryr total_runtime total_runsrrr9spaces_auto_wrap)rWrrrtrvrxryrrr8r8r<rXs  zBlockFunction.__init__cCs.tdurdStdurdSt|j|_dSrm)spacesrrZgradio_auto_wraprrrar8r8r<rs  zBlockFunction.spaces_auto_wrapcCst|j|j|jdS)N)rrrxry)rPr9rxryrar8r8r<__str__s zBlockFunction.__str__cCst|Srm)rPrar8r8r<__repr__zBlockFunction.__repr__N)F)rrrsrtrrvrrxrFryrFrrFrrF)rVrrrXrrrr8r8r8r<rs   rTr\ update_dictrryrFcCs|dddkr ||}|dtjjur|d|dd}|dur-|r)dnd|d <t|d d }d|vrQ|rQt|tjsHJd |j d | |d|d<|S)a Converts a dictionary of updates into a format that can be sent to the frontend. E.g. {"__type__": "generic_update", "value": "2", "interactive": False} Into -> {"__type__": "update", "value": 2.0, "mode": "static"} Parameters: block: The Block that is being updated with this update dictionary. update_dict: The original update dictionary postprocess: Whether to postprocess the "value" key of the update dictionary. rrvalue interactiveNZdynamicZstaticmodeT)Z skip_valuez Component z does not support value) getrr _KeywordsZNO_VALUEpopr2rOr^rUry)r\rryrprediction_valuer8r8r<postprocess_update_dicts       r outputs_ids list[int] predictionsrg list | dictcCsdd|D}t|r9dd|D}|D]\}}|j|vr'td|d||j}|||<qt|}|St|rAtd|S)a} Converts a dictionary of component updates into a list of updates in the order of the outputs_ids and including every output component. Leaves other types of dictionaries unchanged. E.g. {"textbox": "hello", "number": {"__type__": "generic_update", "value": "2"}} Into -> ["hello", {"__type__": "generic_update"}, {"__type__": "generic_update", "value": "2"}] cSsg|]}t|tqSr8)rOr?)r:rr8r8r<rsz2convert_component_dict_to_list..cSsg|]}tqSr8)r$)r:rr8r8r<rrzReturned component z% not specified as output of function.zReturned dictionary included some keys as Components. Either all keys must be Components to assign Component values, or return a List of values to assign output values in order.)allitemsrNrdindexrresolve_singletonany)rrZkeys_are_blocksZreordered_predictions componentrZ output_indexr8r8r<convert_component_dict_to_lists"      rconfig serializec Csiid}|dd}t|ddtdk}t|dD]\}}ggd}d }|d } | D]} |d D] } | d | krAnq7d }n| d} | tjvrPq1| ds^| tjvr^d }n| tjvrdq1| ddd| } tj| }| dr|r| d}| dd}nt |tj sJ| }| d}|d}|r|dr| }t |tjr| ddddkr|}t|}tj| j}|d| |d||ddd| ||dq1|d }|D]}|d D] } | d |krnqd }n| d} | tjvrq| ds| tjvrd }n| ddd!|} tj| }| dr;|r;| d}| dd}nt |tj sDJ| }| d}|d}|rt|drt| }t |tjrt| ddddkrt|}t|}tj| j}|d"| |d||ddd| |d#q|d$sd }|rq|d%dur|d%d ur||d&d'|d%<q|d%d us|d(ks|d)krq||d*t|<q|S)+a Gets the information needed to generate the API docs from a Blocks config. Parameters: config: a Blocks config dictionary serialize: If True, returns the serialized version of the typed information. If False, returns the raw version. )named_endpointsunnamed_endpointsrNrz2.0z3.28.3r) parametersreturnsFrtrrMTtype serializerpropslabelZ parameter_api_infoexample_inputsZ serializedrawinfoserialized_infoZ file_countsingler descriptionr)rr)rr python_typerZ example_inputrrvZvalue_r)rrrrrrr|r/Z interfaceZtabbed_interfacer)rrparseVersion enumerate client_utilsZSKIP_COMPONENTSrZCOMPONENT_MAPPINGrO SerializablerrrZFileSerializableZ_multiple_file_serialized_infoZjson_schema_to_python_typerVr` capitalizerP)rrrrZafter_new_formatdrZdependency_infoZ skip_endpointrtirrrrrZexampleZ python_inforZserializer_namervor8r8r< get_api_infos                            rlaunchr integrateloadcseZdZdZ     ddƇfdd ZeddZedddZddZ ddZ eddZ d d!Z ddd&d'Z d"dd(dd*d+Z    ddd5d6Zdd8d9Zdd;d<Zdd=d>ZddAdBZddEdFZddHdIZddOdPZ     dddUdVZdWdXZdYdZZd[d\Zd]d^Zddׇfdadb Z      c d  c e f f  ddddddgdd|d}Zd~dZee   f ddddZ!ddZ"  c  c    c c   c      f c f     f ddddZ#   ddddZ$ddddZ%dddZ&ddZ'dd„Z(dddĄZ)Z*S)Blocksa Blocks is Gradio's low-level API that allows you to create more custom web applications and demos than Interfaces (yet still entirely in Python). Compared to the Interface class, Blocks offers more flexibility and control over: (1) the layout of components (2) the events that trigger the execution of functions (3) data flows (e.g. inputs can trigger outputs, which can trigger the next level of outputs). Blocks also offers ways to group together related demos such as with tabs. The basic usage of Blocks is as follows: create a Blocks object, then use it as a context (with the "with" statement), and then define layouts, components, or events within the Blocks context. Finally, call the launch() method to launch the demo. Example: import gradio as gr def update(name): return f"Welcome to Gradio, {name}!" with gr.Blocks() as demo: gr.Markdown("Start typing below and then click **Run** to see the output.") with gr.Row(): inp = gr.Textbox(placeholder="What is your name?") out = gr.Textbox() btn = gr.Button("Run") btn.click(fn=update, inputs=inp, outputs=out) demo.launch() Demos: blocks_hello, blocks_flipper, blocks_speech_text_sentiment, generate_english_german, sound_alert Guides: blocks-and-event-listeners, controlling-layout, state-in-blocks, custom-CSS-and-JS, custom-interpretations-with-blocks, using-blocks-like-functions Nr5GradiothemeTheme | str | Noneanalytics_enabledrrrPtitlecssrGc sd_|dur t}n|_?d_@d_Ad_Bd_Cd_Dd_Ed_Fd_Gg_Hg_Itj&Jdd_KtL_MjrWtNfddtOD } j,jduj jP| tQd} tR| dSdS)a Parameters: theme: a Theme object or a string representing a theme. If a string, will look for a built-in theme with that name (e.g. "soft" or "default"), or will attempt to load a theme from the HF Hub (e.g. "gradio/monochrome"). If None, will use the Default theme. analytics_enabled: whether to allow basic telemetry. If None, will use GRADIO_ANALYTICS_ENABLED environment variable or default to True. mode: a human-friendly name for the kind of Blocks or Interface being created. title: The tab title to display when this is opened in a browser window. css: custom css or path to custom css file to apply to entire Blocks Nz Cannot load z. Caught Exception: z1Theme should be a class loaded from gradio.themesF(T)targetTrueZHF_HUB_DISABLE_TELEMETRYr@ZGRADIO_WATCH_DIRS@GRADIO_ROOT_PATHrc3s"|] }j|kVqdSrm)rto_dict)r:Zbuilt_in_themerar8r<   z"Blocks.__init__..)rZ custom_cssris_custom_themerr8)Slimiter DefaultThemerOrPrjr>ThemeZfrom_hub ExceptionrrrZ_get_theme_cssZ theme_cssZ _stylesheets stylesheetsencryptshare enable_queue max_threadsrrpending_streams show_errorospathexistsopenreadrrrrIS_WASM threadingThreadZ version_checkstartenvironsuperrXr5rrr is_running local_url share_urlwidthheightapi_openrrspace_id favicon_pathauthrFgetenvdev_moderandom getrandbitsapp_idr_rshow_apipredictinput_componentsoutput_componentsrVapi_modeprogress_tracking ssl_verify allowed_paths blocked_pathsr root_pathr root_urlsrvaluesr9r-Zinitiated_analytics) rWrrrrrrLeZcss_filer;r#datarUrar<rXs             zBlocks.__init__cCsddlm}t|ddS)Nr) reload_threadZrunning_reloadF)Z gradio.reloadrWr)rWrWr8r8r<_is_running_in_reload_thread s  z#Blocks._is_running_in_reload_threadrrrlist[Callable]rDrgcst|}|dD]}d|dvr#|d|dd|dd=q |dd}ihd(fd d fd d dg}t|d}tjpM|d<|ddd}t|d|D]m\} } | ddkrlqa|D]} | | dqn| d} | d} | d| ddfdd| dD| d<fdd| dD| d<| ddd | d!<d | d"<| D]}|j d)| | d#| d} |dur| }qqa|rtjr|dg|_ d$d|dD|_ d%d|dD|_ d&|_ d'|_Wdn1swY|_|S)*a Factory method that creates a Blocks from a config and list of functions. Used internally by the gradio.external.load() method. Parameters: config: a dictionary containing the configuration of the Blocks. fns: a list of functions that are used in the Blocks. Must be in the same order as the dependencies in the config. root_url: an external url to use as a root URL when serving files for components in the Blocks. rstylerrdefaultrMrrgr?csD] }|d|kr nqtd|t|d}|ddd|ddd|dddur=d|dd<n |dd|d i|ddd i}|S) NrMzCannot find block with id rrr9rDrrETr8)rdr0rrr])rM block_configrr\)components_configrDrRr8r<get_block_instance+s  z.Blocks.from_config..get_block_instancec s~|D]:}|d}|}||<|d}|dur.iterate_over_childrenr)rrlayoutrbNrrZ fake_eventrrZ documentationcg|]}|qSr8r8r:rr`r8r<rgz&Blocks.from_config..rtcrbr8r8r:rrdr8r<rjrervZstatus_trackerFrxry)rqrrcSg|]}tjj|qSr8rr[r5rcr8r8r<r{ cSrgr8rhrfr8r8r<r~riZ InterfaceT)rMrrgr?r8)rdeepcopyrrrrr[ziprrrIrJrKrVrLrR)rrrrDZcomponent_configrZderived_fieldsr5Zfirst_dependencyrrrfieldrrrr8)r]r^r_r`rDrRr< from_configsz                4zBlocks.from_configcCs|Srm)rrar8r8r<rrzBlocks.__str__cCstdd|jD}d|d}|ddt|7}t|jD]=\}}|dr]|d|7}|d 7}|d D]}|j|}|d |7}q7|d 7}|d D]}|j|}|d |7}qNq |S)NcSsg|]}|dr|qS)rr8)r:r r8r8r<rsz#Blocks.__repr__..zGradio Blocks instance: z backend functions -rz fn_index=z inputs:rtz |-z outputs:rv)rrr r5)rWZnum_backend_fnsreprr rinput_idr\ output_idr8r8r<rs      zBlocks.__repr__cCstdd|jDS)z>Return whether the app expects user to authenticate via OAuth.css"|] }t|tjtjfVqdSrm)rOrZ LoginButtonZ LogoutButtonrr8r8r<r!r"z'Blocks.expects_oauth..)rr5rSrar8r8r< expects_oauthszBlocks.expects_oauthc stjdur|jtjjvrtd|jdttjj|j}|D]}t|j|tj s0tdq!tjj |jtjj |j t tjjt|jD]u\}}|d}|dur||dur|t|ddtjjD}||kr|td|d |||d<fd d|d D|d <|d dur|d 7<|d rd d|d D}tt|dggddd}|tjj |<tjj|qLtjj |jtjj |jtjdurtjj |j|S)NrYrZz.rrcsg|]}|qSr8r8)r:cZdependency_offsetr8r<rrerrcSrgr8)rr[rrcr8r8r<rs rT)rr[rNr5rr intersectionrOrStaterrextendrrr rrrrrrr3r`r_rRr\rb) rWZoverlapping_idsrMrrr|rZupdated_cancelsZnew_fnr8rur<r@sf       z Blocks.renderrfn_indexrrFcCs|j|}|j|}t|jrdSt|jrdS|dD]}|j|}t|ddr.dSq|dD]}|j|}t|ddrCdSq3dS)zVChecks if a particular Blocks function is callable (i.e. not stateful or a generator).FrtstatefulrvT)rrrisasyncgenfunctionrrrr5r)rWryblock_fnrrqr\rrr8r8r< is_callables"          zBlocks.is_callable)ryr|r|c sdur tfddt|jDd}|durtd|}||s)tdt|}|||}|j|d}|rCdd|D}tj |j ||did }|d }|r[d d|D}| ||}t |}|S) a Allows Blocks objects to be called as functions. Supply the parameters to the function as positional arguments. To choose which function to call, use the fn_index parameter, which must be a keyword argument. Parameters: *inputs: the parameters to pass to the function fn_index: the index of the function to call (defaults to 0, which for Interfaces, is the default prediction function) api_name: The api_name of the dependency to call. Will take precedence over fn_index. Nc3s&|]\}}|dkr|VqdS)r|N)r)r:rr rr8r<r!sz"Blocks.__call__..z%Cannot find a function with api_name zThis function is not callable because it is either stateful or is a generator. Please use the .launch() method instead to create an interactive user interface.rcSsg|]}|gqSr8r8r:inpr8r8r<rrz#Blocks.__call__..)ryrtrequeststaterUcSrrr8)r:outr8r8r<r r)nextr rr r}rdrserialize_datar Zsynchronize_async process_apideserialize_datarr) rWryr|rtZinferred_fn_indexZprocessed_inputsrrvZprocessed_outputsr8rr<__call__sD      zBlocks.__call__processed_input list[Any]iteratorAsyncIterator[Any] | Nonerequests,routes.Request | list[routes.Request] | Noneevent_id event_dataEventData | Nonecs|j|}|jsJd|dd}t|tr|dn|} t} t|j||} |dur|jr:tt |j |g}t |j|| |\}} } | durM|| nd}|dure| duret ||| |j \}} ||| <t| rr| |IdH}ntjj| g|Rd|jiIdH}nd}t| st| r|jstdz#|durttt|}t|rt||j}t|IdH}d}Wn$tyt|j |!d }|d krt"j#j$nt"j#j$f|}d}Ynwt| }||||d S) a Calls function with given index and preprocessed input, and measures process time. Parameters: fn_index: index of function to call processed_input: preprocessed input to pass to function iterator: iterator to use if function is a generator requests: requests to pass to function event_id: id of event in queue event_data: data associated with event trigger zfunction with index z not defined.FrNr$z'Need to enable queue to use generators.TrvrI) predictionduration is_generatingr)%rrrrOrtimerZget_function_with_localsrrrkrtr%r#Z track_tqdmriscoroutinefunctionanyio to_threadZrun_syncr$rr{r+rdr r r isgeneratorZSyncToAsyncIteratorZasync_iterationStopAsyncIterationrrrrrFINISHED_ITERATING)rWryrrrrrr|rrr7rrrrZprogress_trackerrZ n_outputsrr8r8r< call_function'sl         zBlocks.call_functionrtc Cs|j|}g}t|dD]C\}}z|j|}Wnty2}ztd|d|dd|d}~wwt|tjsDJ|jd|d| ||} | | q |S)NrtInput component with id used in rz() event is not defined in this gr.Blocks context. You are allowed to nest gr.Blocks contexts, but there must be a gr.Blocks context that contains all components and events. Component with id  not a valid input component.) rr r5rer!rOrr^rUrr`) rWryrtrrrrqr\rTZserialized_inputr8r8r<rws*  zBlocks.serialize_datarvc Cs|j|}g}t|dD]J\}}z|j|}Wnty2}ztd|d|dd|d}~wwt|tjsDJ|jd|d|j |||j |j t j d} || q |S) NrvOutput component with id rr() event not found in this gr.Blocks context. You are allowed to nest gr.Blocks contexts, but there must be a gr.Blocks context that contains all components and events.r not a valid output component.)save_dirrDhf_token)rr r5rer!rOrr^rUZ deserializeZDEFAULT_TEMP_DIRrDrrr`) rWryrvrrrrrr\rTZ deserializedr8r8r<rs4  zBlocks.deserialize_datac Cs|j|}|j|}|d}t|t|krw|jr%|jdkr%d|jdnd}g}g}|D]} |j| } |t| q-|D]} t| trKd| dnt| } || q>d|} d|}t d|d t|d t|d | d |d dS)Nrt ()r", An event handlerz- didn't receive enough input values (needed: z, got: zz). Check if the event handler calls a Javascript function, and make sure its return value is correct. Wanted inputs: [z] Received inputs: []) rrrr9r5r`rPrOjoinrd)rWryrtr|rZ dep_inputsr9 wanted_args received_argsrqr\rvwantedreceivedr8r8r<validate_inputss8       zBlocks.validate_inputsrdict[int, Any]c Cs|j|}|j|}||||jrng}t|dD]P\}}z|j|} Wnty@} ztd|d|dd| d} ~ wwt| t j sRJ| j d|dt | dd ra| ||q| | ||q|S|}|S) NrtrrrrrrrzF)rrrrxr r5rer!rOrr7rUrr`r) rWryrtrr|rrrrqr\rTr8r8r<preprocess_datas6    zBlocks.preprocess_datarAny | list[Any]c Cs|j|}|j|}|d}t|turt|tur|g}t|t|kr|jr4|jdkr4d|jdnd}g}g}|D]} |j| } |t | q<|D]} t | t rZd| dnt | } || qMd |} d |}t d|d t|d t|d | d |d dS)Nrvrrrrrrrz. didn't receive enough output values (needed: z , received: z). Wanted outputs: [z] Received outputs: [r) rrrrtuplerr9r5r`rPrOrrd)rWryrr|rZ dep_outputsr9rrrrr\predrrrr8r8r<validate_outputss<       zBlocks.validate_outputsrc Cs|j|}|j|}|d}t|tur!t|dkr!t|d|}t|ddkr.|s.|g}|||g}t|dD]\}} z||tj j urP| dWq\}}|j|} t| |rl| jrl||v} | |||d|d|| \} } | r\g||<|j||| | | ||<q.|S)Nr)StreamableOutputrvr) r- gradio.eventsrr rr5rOZ streamingZ stream_outputr`) rWryrUrrZ stream_runrrrrr\Z first_chunkZ binary_dataZ output_datar8r8r<handle_streaming_outputsBs&  zBlocks.handle_streaming_outputsr iteratorsdict[int, Any] | Nonerc sj} jd} | rjd} dd|D} | dt| js-t| jr1tdtfdd| DsDtd | d | krStd d | d fddt|D} t t|d|||IdH} | d}fddt|D}t t|}d\}}nN|r| dnd}|rg}n |}|du} |||||IdH}  | d}| d| d}}|s|rۈj|||rt|nt|d}| j| d7_| jd7_|||| d| j| jdS)a  Processes API calls from the frontend. First preprocesses the data, then runs the relevant function, then postprocesses the output. Parameters: fn_index: Index of function to run. inputs: input data received from the frontend state: data stored from stateful components for session (key is input block id) request: the gr.Request object containing information about the network request (e.g. IP address, headers, query parameters, username) iterators: the in-progress iterators for each generator function (key is function index) event_id: id of event that triggered this API call event_data: data associated with the event trigger itself Returns: None rrcSsg|]}t|qSr8)rr~r8r8r<r{rz&Blocks.process_api..rz1Gradio does not support generators in batch mode.c3s|]}|kVqdSrmr8)r:r) batch_sizer8r<r!sz%Blocks.process_api..zQAll inputs to a batch function must have the same length but instead have sizes: .z Batch size (z0) exceeds the max_batch_size for this function (rcg|] }t|qSr8)rrrcryrWrr8r<rNrcrr8)rrrfrr8r<rr)NNrr)rrrrI)rUrrrZaverage_duration)rrrr{rrrrdrrkrrrrrrrMrr)rWryrtrrrrrrr|rrZ batch_sizesresultpredsrUrrZ old_iteratorZwas_generatingr8)rryrWrr<r^sp        zBlocks.process_apics(|jdkr d|_dSt|jd|_dS)Nr)Z total_tokens)r,r r$rar8r8r<create_limiters   zBlocks.create_limitercCsddiS)Nrcolumnr8rar8r8r<rrzBlocks.get_configcstj|j|j|j|jg|j|jpd|jt |ddt |dd|j t |j |jjd}fdd||d<|jD]@\}}t|d rH|ni}||t |d }t |}|rtt|tjsdJ||d <||d <||d <|d|q;|j|d<|S)Nrr+Fr.)rrrGrDrrrrr@r+r.rHis_colabr(rcs>t|ts d|jiSg}|jD] }||q|j|dS)NrM)rMrb)rOrrNrbr`)r\Zchildren_layoutr get_layoutr8r<rs    z*Blocks.get_config_file..get_layoutrar)rMrrrrrrr)rVERSIONrrGrDrrrr@rrHr colab_checkr(rr9r5rrhrrkr2Zget_serializer_namerOrr rrr`r)rWrrNr\rr\rr8rr<get_config_filesB        zBlocks.get_config_filecCs(tjdur|t_tj|_|t_d|_|S)NF)rr\r[rSexitedrar8r8r<rs zBlocks.__enter__rrcs|dur dt_dt_dSt|jt_||jdur"dt_n|jj|j| |_ t j ||_tdd|jD|_d|_dS)Ncss|]}|jVqdSrm)r)r:r|r8r8r<r!sz"Blocks.__exit__..T)rr\r[r9rrSattach_load_eventsrbrxrrrApp create_appapprrrMrrrVr8r<rs    zBlocks.__exit__FrorpT)r9srcapi_keyaliasrW Blocks | Nonerrrslist[Component] | Noner}rzr{rrrxryrr_jsr9rrrBlocks | dict[str, Any] | NonecKs|durtd|durtdtjd ||||d|Sddlm}|jd||||| | ||| ||| | dd \}}|||||S) a For reverse compatibility reasons, this is both a class method and an instance method, the two of which, confusingly, do two completely different things. Class method: loads a demo from a Hugging Face Spaces repo and creates it locally and returns a block instance. Warning: this method will be deprecated. Use the equivalent `gradio.load()` instead. Instance method: adds event that runs as soon as the demo loads in the browser. Example usage below. Parameters: name: Class Method - the name of the model (e.g. "gpt2" or "facebook/bart-base") or space (e.g. "flax-community/spanish-gpt2"), can include the `src` as prefix (e.g. "models/facebook/bart-base") src: Class Method - the source of the model: `models` or `spaces` (or leave empty if source is provided as a prefix in `name`) api_key: Class Method - optional access token for loading private Hugging Face Hub models or spaces. Find your token here: https://huggingface.co/settings/tokens. Warning: only provide this if you are loading a trusted private Space as it can be read by the Space you are loading. alias: Class Method - optional string used as the name of the loaded model instead of the default name (only applies if loading a Space running Gradio 2.x) fn: Instance Method - the function to wrap an interface around. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component. inputs: Instance Method - List of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list. outputs: Instance Method - List of gradio.components to use as inputs. If the function returns no outputs, this should be an empty list. api_name: Instance Method - Defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name. scroll_to_output: Instance Method - If True, will scroll to output component on completion show_progress: Instance Method - If True, will show progress animation while pending queue: Instance Method - If True, will place the request on the queue, if the queue exists batch: Instance Method - If True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component. max_batch_size: Instance Method - Maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True) preprocess: Instance Method - If False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component). postprocess: Instance Method - If False, will not run postprocessing of component data before returning 'fn' output to the browser. every: Instance Method - Run this event 'every' number of seconds. Interpreted in seconds. Queue must be enabled. Example: import gradio as gr import datetime with gr.Blocks() as demo: def get_time(): return datetime.datetime.now().time() dt = gr.Textbox(label="Current time") demo.load(get_time, inputs=None, outputs=dt) demo.launch() Nz;gr.Blocks.load() will be deprecated. Use gr.load() instead.z>Blocks.load() requires passing parameters as keyword arguments)r9rrrr) DependencyrT)rqrrrtrvr|rxryrzr{r~rrrrrr8)rrdrrrrr)rWrrrtrvr|rzr{rrrrxryrrr9rrrrLrrZ dep_indexr8r8r<rs@8  z Blocks.loadcCsi|_g|_g|_g|_|S)z'Resets the layout of the Blocks object.)r5rrrbrar8r8r<clear_s z Blocks.clearrIautoconcurrency_countstatus_update_ratefloat | Literal['auto']client_position_to_load_datadefault_enabledr?max_sizecCs|durtdd|_||_|durtdtr%|j}|dur#dn|}tj|dk||dkr1|nd||jd|_ | |_ t j ||_|S)a By enabling the queue you can control the rate of processed requests, let users know their position in the queue, and set a limit on maximum number of events allowed. Parameters: concurrency_count: Number of worker threads that will be processing requests from the queue concurrently. Increasing this number will increase the rate at which requests are processed, but will also increase the memory usage of the queue. status_update_rate: If "auto", Queue will send status estimations to all clients whenever a job is finished. Otherwise Queue will send status at regular intervals set by this parameter as the number of seconds. client_position_to_load_data: DEPRECATED. This parameter is deprecated and has no effect. default_enabled: Deprecated and has no effect. api_open: If True, the REST routes of the backend will be open, allowing requests made directly to those endpoints to skip the queue. max_size: The maximum number of events the queue will store at any given moment. If the queue is full, new events will not be added and a user will receive a message saying that the queue is full. If None, the queue size will be unlimited. Example: (Blocks) with gr.Blocks() as demo: button = gr.Button(label="Generate Image") button.click(fn=image_generator, inputs=gr.Textbox(), outputs=gr.Image()) demo.queue(max_size=10) demo.launch() Example: (Interface) demo = gr.Interface(image_generator, gr.Textbox(), gr.Image()) demo.queue(max_size=20) demo.launch() NzgThe default_enabled parameter of queue has no effect and will be removed in a future version of gradio.Tz9The client_position_to_load_data parameter is deprecated.rIr)Z live_updatesrZupdate_intervalsrZblocks_dependencies)rr+r?rZis_zero_gpu_spacer,rQueuer_queuerrrrrr)rWrrrrr?rr8r8r<rgs. z Blocks.queuecCs|js |jr tdt|jD]C\}}|js+||r+td|dr%|dn|d|dD] }||s:tdq/|drR|dd usN|ddurR|jsRtd qdS) Nz1Progress tracking requires queuing to be enabled.zThe queue is enabled for event r|z but the queue has not been enabled for the app. Please call .queue() on your app. Consult https://gradio.app/docs/#blocks-queue for information on how to configure the queue.ra!Queue needs to be enabled! You may get this error by either 1) passing a function that uses the yield keyword into an interface without enabling the queue or 2) defining an event that cancels another event without enabling the queue. Both can be solved by calling .queue() before .launch()rrFz4In order to use batching, the queue must be enabled.)r+rMrdr rqueue_enabled_for_fn)rWryrrr8r8r<validate_queue_settingss&    zBlocks.validate_queue_settingsr100%inline inbrowserr*debugr+r,rB9Callable | tuple[str, str] | list[tuple[str, str]] | None auth_messageprevent_thread_lockr. server_name server_port show_tipsr>r= int | strr)rA ssl_keyfile ssl_certfilessl_keyfile_passwordrNquietrHfile_directorieslist[str] | NonerOrPrQ _frontend app_kwargsdict[str, Any] | Nonetuple[FastAPI, str, str]c* Cs|jrdS|js ||r%t|s%t|dts%t|dts%|g|_n||_||_| |_ | |_ ||_ ||_ ||_ ||_|durJtjdd|_n||_|durX||_td|dur`td|jrj|jdu|_n|jd u|_|jr|t|d s||||_|durtd |dur|}|pg|_|pg|_t|jtstd t|jtstd |||_t|jr|j j!nd||_"|j#rt|j$t%sJd|j$|st&dnt'j(rd} d} d}d}ddl)m*} | j+||d}!t',|!nt-j.|| | ||||d\} } }}!}| |_/||_$| |_0|!|_1||_2d |_#t34|_5t36|_7|j$8ds/|j5r1dnd|_9t'j(sK|j5sKt&t:j;d<|j9|j/|j0|jrV|j =|j1t'j(sft>j|j$d|dn t3?t3@|_A|dur|j5r|jr|st&dd |_Bn%|j7r|st&dd |_Bn|jAr|st&dd |_Bnd|_Bn||_B|rt'j(st-C|j$s|jBstd|j5r|s|rt&t:j;dnt&t:j;d|jBst&t:j;d<|j0|jr|jBstd |jBrm|jrtDd!t'j(r tDd"z(|jEdurt-F|j/|j0|jG|_Et&t:j;d#<|jE|s2t&t:j;d$WnJtDt>jHjIfyl|jJrHtKLd%d|_Ed|_BtMtNOr]t&t:j;d&n t&t:j;d' 1min) to prevent timeout. The default option in HuggingFace Spaces is True. The default option elsewhere is False. max_threads: the maximum number of total threads that the Gradio app can generate in parallel. The default is inherited from the starlette library (currently 40). Applies whether the queue is enabled or not. But if queuing is enabled, this parameter is increaseed to be at least the concurrency_count of the queue. width: The width in pixels of the iframe element containing the interface (used if inline=True) height: The height in pixels of the iframe element containing the interface (used if inline=True) encrypt: DEPRECATED. Has no effect. favicon_path: If a path to a file (.png, .gif, or .ico) is provided, it will be used as the favicon for the web page. ssl_keyfile: If a path to a file is provided, will use this as the private key file to create a local server running on https. ssl_certfile: If a path to a file is provided, will use this as the signed certificate for https. Needs to be provided if ssl_keyfile is provided. ssl_keyfile_password: If a password is provided, will use this with the ssl certificate for https. ssl_verify: If False, skips certificate validation which allows self-signed certificates to be used. quiet: If True, suppresses most print statements. show_api: If True, shows the api docs in the footer of the app. Default True. file_directories: This parameter has been renamed to `allowed_paths`. It will be removed in a future version. allowed_paths: List of complete filepaths or parent directories that gradio is allowed to serve (in addition to the directory containing the gradio python file). Must be absolute paths. Warning: if you provide directories, any files in these directories or their subdirectories are accessible to all users of your app. blocked_paths: List of complete filepaths or parent directories that gradio is not allowed to serve (i.e. users of your app are not allowed to access). Must be absolute paths. Warning: takes precedence over `allowed_paths` and all other directories exposed by Gradio by default. root_path: The root path (or "mount point") of the application, if it's not served from the root ("/") of the domain. Often used when the application is behind a reverse proxy that forwards requests to the application. For example, if the application is served at "https://example.com/myapp", the `root_path` should be set to "/myapp". Can be set by environment variable GRADIO_ROOT_PATH. Defaults to "". app_kwargs: Additional keyword arguments to pass to the underlying FastAPI app as a dictionary of parameter keys and argument values. For example, `{"docs_url": "/docs"}` Returns: app: FastAPI app object that is running the demo local_url: Locally accessible link to the demo share_url: Publicly accessible link to the demo (if share=True, otherwise None) Example: (Blocks) import gradio as gr def reverse(text): return text[::-1] with gr.Blocks() as demo: button = gr.Button(value="Reverse") button.click(reverse, gr.Textbox(), gr.Textbox()) demo.launch(share=True, auth=("username", "password")) Example: (Interface) import gradio as gr def reverse(text): return text[::-1] demo = gr.Interface(reverse, "text", "text") demo.launch(share=True, auth=("username", "password")) rrNrrz[The `enable_queue` parameter has been deprecated. Please use the `.queue()` method instead.z>The `encrypt` parameter has been deprecated and has no effect.FTrz^The `file_directories` parameter has been renamed to `allowed_paths`. Please use that instead.z.`allowed_paths` must be a list of directories.z.`blocked_paths` must be a list of directories.zInvalid local_url: z[Rerunning server... use `close()` to stop if you need to change `launch()` parameters. ----Zxxxi)r)rhttpshttpZRUNNING_LOCALLY_SEPARATEDzstartup-events)verifyzSetting queue=True in a Colab notebook requires sharing enabled. Setting `share=True` (you can turn this off by setting `share=False` in `launch()` explicitly). zKaggle notebooks require sharing enabled. Setting `share=True` (you can turn this off by setting `share=False` in `launch()` explicitly). zSagemaker notebooks may require sharing enabled. Setting `share=True` (you can turn this off by setting `share=False` in `launch()` explicitly). zWhen localhost is not accessible, a shareable link must be created. Please set share=True or check your proxy settings to allow access to localhost.ZCOLAB_DEBUG_TRUEZCOLAB_DEBUG_FALSEZ COLAB_WARNINGzVWhen using queueing in Colab, a shareable link must be created. Please set share=True.z-Share is not supported when you are in Spacesz.Share is not supported in the Wasm environmentZSHARE_LINK_DISPLAYZSHARE_LINK_MESSAGEzNot able to set up tunnelZCOULD_NOT_GET_SHARE_LINKZ%COULD_NOT_GET_SHARE_LINK_MISSING_FILEZPUBLIC_SHARE_TRUE)HTML Javascriptdisplayg?z
aW(async (port, path, width, height, cache, element) => { if (!google.colab.kernel.accessAllowed && !cache) { return; } element.appendChild(document.createTextNode('')); const url = await google.colab.kernel.proxyPort(port, {cache}); const external_link = document.createElement('div'); external_link.innerHTML = ` `; element.appendChild(external_link); const iframe = document.createElement('iframe'); iframe.src = new URL(path, url).toString(); iframe.height = height; iframe.allow = "autoplay; camera; microphone; clipboard-read; clipboard-write;" iframe.width = width; iframe.style.border = 0; element.appendChild(iframe); })z<({port}, {path}, {width}, {height}, {cache}, window.element)r)portr0r=r>cacherZbrowserr) Z launch_methodZis_google_colabZ is_sharing_onr<r+rrrZis_spacerZ GRADIO_DEBUGrIps1)lrXrrcallablerOrrrBrrr.r>r=rArNr/r8rrQr+rr@rhrrHrOrPrdrrrmaxrZmax_thread_countr,r:r;rPprintrr4Z gradio.routesrrZ register_appr start_serverrrZ server_appserverrrrZ kaggle_checkZ is_kaggle startswithprotocolrenformatZset_server_apprZlaunch_counterZsagemaker_checkZ is_sagemakerr*Zurl_ok RuntimeErrorr<Z setup_tunnelrR exceptionsConnectionErrorrrZerror_analyticsrr*r1r+r(r) webbrowserr2Z ipython_checkIPython.displayrrrrsleepjsondumpsartifact ImportErrorrrZlaunched_analyticsZshow_tiprrC block_threadrFsysflagsrr.)*rWrrr*rr+r,rBrrr.rrrr>r=r)rArrrrNrrHrrOrPrQrrr;rrrlinkrrrrcoderUZis_in_interactive_moder8r8r<rsT                                   $z Blocks.launchwandbModuleType | NonemlflowNonecCs"d}|dur6d}|dd|jdur!|d|j|n|jr2|d|j|ntd|durcd}|jdur_|d |d |jd t|j d t|j d int d|dur}d}|jdurv| d|jn| d|j|j r|rd|i}t|dSdSdS)a A catch-all method for integrating with other libraries. This method should be run after launch() Parameters: comet_ml: If a comet_ml Experiment object is provided, will integrate with the experiment and appear on Comet dashboard wandb: If the wandb module is provided, will integrate with it and appear on WandB dashboard mlflow: If the mlflow module is provided, will integrate with the experiment and appear on ML Flow dashboard rNZCometMLz Created fromrzgradio: zPlease run `launch()` first.ZWandBz Gradio panelz zAThe WandB integration requires you to `launch(share=True)` first.ZMLFlowzGradio Interface Share LinkzGradio Interface Local LinkZ integration)Z log_otherr<Zlog_textendr;rdlogZHtmlrPr=r>rZ log_paramrrZintegration_analytics)rWZcomet_mlr&r(Zanalytics_integrationrUr8r8r<rQsX        zBlocks.integrateverbosec Cshz'|jr |j|jr|jd|_d|j_|r%td|jWdSWdSt t fy3YdSw)zL Closes the Interface that was launched and frees the port. Fz Closing server running on port: N) r+rcloserr:rZstartup_events_triggeredrrrOSError)rWr,r8r8r<r-s  z Blocks.closec CsRz tdqttfy(td|jr|jtD]}|qYdSw)z,Block main thread until interrupted by user.Tg?z7Keyboard interruption in main thread... closing server.N) rrKeyboardInterruptr.rrr-r,kill)rWZtunnelr8r8r<r!s   zBlocks.block_threadc Csjtjr1tjjD])}t|tjr0|jr0|j\}}|jd|d|d|dur&dnd|dd}||_ q dSdS)zNAdd a load event for every component whose initial value should be randomized.rNTF)rrrr) rr[r5rSrOrr^Zload_event_to_attachrZ load_event)rWrZload_fnrrr8r8r<rs,    zBlocks.attach_load_eventscCs0|jrt|jj|jd|j_t|jdS)zGEvents that should be run when the app containing this block starts up.FN)r+rZrun_coro_in_backgroundrr7rNstoppedrrar8r8r<startup_eventsszBlocks.startup_eventscCs&|j|ddur |jS|j|dS)Nr)rr+)rWryr8r8r<rszBlocks.queue_enabled_for_fn)NNr5rN) rrrrrrPrrPrrG)rrrrYrDrPrgrr)ryrrgrF)ryrr|rG)NNNN) ryrrrrrrrrrGrr)ryrrtrrgr)ryrrvrrgr)ryrrtr)ryrrtrrr)ryrrr)ryrrrrr) ryrrUrrrGrrrgr)NNNNN)ryrrtrrrrrrrrrGrrGrrrgrrmr)NNNNNFroNFrpTTNN)$rWrrrrsrtrrvrr|r}rzrFr{rPrrFrrrxrFryrFrrrrGr9rGrrGrrGrrGrgr)rIrNNTN) rrrrrrrrr?rFrr)NFNFNrNNFFNNFrrNNNNNTFTNNNNTN)rr=rr)rrArGrrGrrGrrGrNrFrrFrHrFrrrOrrPrrQrGrrFrrrgrr)r&r'r(r'rgr)T)r,rFrgr))rgr))ryr)+rVrr__doc__rXpropertyrXrrmrrrsr@r}rrrrrrrrrrrrrrrrrr1rrrrrr-r!rr2r __classcell__r8r8rVr<rxs$n  v  ;9 P   &  $ <! V.Y6  8  rr3)r\r?rrryrF)rrrrrgr)rrrrF)g __future__rrrrr/rErQr"r5rrrabcr collectionsrpathlibrrrtypingrrr r r r rrr Z gradio_clientrrr Zgradio_client.documentationrr packagingrZgradiorrrrrrrrrZgradio.contextrZgradio.deprecationrrZgradio.exceptionsrr r!Zgradio.helpersr"r#r$r%Z gradio.themesr&r%r'r&Zgradio.tunnelingr(r)r*r+r,Z gradio.utilsr-r.r/r0r1r2r3r4rr'Zfastapi.applicationsr6Zgradio.componentsr7ZBaseZ MonochromeZSoftZGlassr>__annotations__r?rrrrrrr8r8r8r<sx         0   (     o@ +