Fix Deep Link Issue (#11202)

* Deep copy state

* add changeset

* Code

* Add code

* speed up

* add code

* fix component updates

* unit test

---------

Co-authored-by: gradio-pr-bot <gradio-pr-bot@users.noreply.github.com>
Co-authored-by: Abubakar Abid <abubakar@huggingface.co>

Author: 3 people

.changeset/stale-zebras-unite.md

@@ -0,0 +1,5 @@
+---
+"gradio": patch
+---
+
+fix:Fix Deep Link Issue

gradio/blocks.py

@@ -1813,7 +1813,7 @@ async def preprocess_data(
                         inputs_serialized = inputs_cached
                     if block._id not in state:
                         state[block._id] = block
-                    state[block._id].value = inputs_serialized
+                    state._update_value_in_config(block._id, inputs_serialized)
                     processed_input.append(block.preprocess(inputs_cached))
         else:
             processed_input = inputs
@@ -1927,11 +1927,16 @@ async def postprocess_data(
                     kwargs["render"] = False
 
                     state[block._id] = block.__class__(**kwargs)
+                    state._update_config(block._id)
                     prediction_value = postprocess_update_dict(
                         block=state[block._id],
                         update_dict=prediction_value,
                         postprocess=block_fn.postprocess,
                     )
+                    if "value" in prediction_value:
+                        state._update_value_in_config(
+                            block._id, prediction_value.get("value")
+                        )
                 elif block_fn.postprocess:
                     if not isinstance(block, components.Component):
                         raise InvalidComponentError(
@@ -1953,7 +1958,9 @@ async def postprocess_data(
                     )
                     if block._id not in state:
                         state[block._id] = block
-                    state[block._id].value = prediction_value_serialized
+                    state._update_value_in_config(
+                        block._id, prediction_value_serialized
+                    )
 
                 outputs_cached = await processing_utils.async_move_files_to_cache(
                     prediction_value,

gradio/state_holder.py

@@ -70,6 +70,13 @@ def delete_state(self, session_id: str, expired_only: bool = False):
 class SessionState:
     def __init__(self, blocks: Blocks):
         self.blocks_config = copy(blocks.default_config)
+        # Keep a separate deep copy of the config so we can recreate
+        # the state for deep links
+        self.config_values = {
+            k: self.blocks_config.config_for_block(k, [], v)
+            for k, v in self.blocks_config.blocks.items()
+            if k in blocks.blocks
+        }
         self.state_data: dict[int, Any] = {}
         self._state_ttl = {}
         self.is_closed = False
@@ -100,6 +107,24 @@ def __setitem__(self, key: int, value: Any):
             self.state_data[key] = value
         else:
             self.blocks_config.blocks[key] = value
+        if block:
+            self.config_values[key] = self.blocks_config.config_for_block(
+                key, [], block
+            )
+
+    def _update_config(self, key: int):
+        if self[key] is not None:
+            self.config_values[key] = self.blocks_config.config_for_block(
+                key, [], self[key]
+            )
+
+    def _update_value_in_config(self, key: int, value: Any):
+        if key not in self.config_values:
+            self.config_values[key] = self.blocks_config.config_for_block(
+                key, [], self.blocks_config.blocks[key]
+            )
+        if "props" in self.config_values[key]:
+            self.config_values[key]["props"]["value"] = value
 
     def __contains__(self, key: int):
         block = self.blocks_config.blocks.get(key)
@@ -112,10 +137,7 @@ def __contains__(self, key: int):
 
     @property
     def components(self) -> Iterator[dict]:
-        for id in self.blocks_config.blocks:
-            config = self.blocks_config.config_for_block(
-                id, [], self.blocks_config.blocks[id]
-            )
+        for _, config in self.config_values.items():
             if config:
                 yield config
 

test/test_routes.py

@@ -1837,3 +1837,42 @@ def test_get_request_origin_with_headers(headers, server, route_path, expected_o
     request = Request(scope)
     origin = get_request_origin(request, route_path)
     assert origin == expected_origin
+
+
+def test_deep_link_unique_per_session():
+    import requests
+    from gradio_client import Client
+
+    with gr.Blocks() as demo:
+        text = gr.Textbox()
+        out = gr.Textbox(label="output")
+        gr.DeepLinkButton()
+        text.submit(fn=lambda x: gr.Textbox(x, lines=int(x)), inputs=text, outputs=out)
+
+    _, url, _ = demo.launch(prevent_thread_lock=True)
+    client_1 = Client(url)
+    client_2 = Client(url)
+    _ = client_1.predict(x="9", api_name="/lambda_1")
+    _ = client_2.predict(x="6", api_name="/lambda_1")
+
+    link_1 = requests.get(
+        f"{url}/gradio_api/deep_link?session_hash={client_1.session_hash}"
+    ).text
+    link_2 = requests.get(
+        f"{url}/gradio_api/deep_link?session_hash={client_2.session_hash}"
+    ).text
+
+    config_1 = requests.get(f"{url}/config?deep_link={link_1[1:-1]}").json()
+    config_2 = requests.get(f"{url}/config?deep_link={link_2[1:-1]}").json()
+    verified_configs = [False, False]
+    for i, config in enumerate([config_1, config_2]):
+        for component in config["components"]:
+            if component["props"].get("label", "") == "output":
+                number = 9
+                if i == 1:
+                    number = 6
+                verified_configs[i] = component["props"][
+                    "lines"
+                ] == number and component["props"]["value"][0] == str(number)
+
+    assert all(verified_configs)