[WIP] Language Agnostic Typing in /info route

client/python/gradio_client/client.py

@@ -30,7 +30,12 @@
 from gradio_client import serializing, utils
 from gradio_client.documentation import document, set_documentation_group
 from gradio_client.serializing import Serializable
-from gradio_client.utils import Communicator, JobStatus, Status, StatusUpdate
+from gradio_client.utils import (
+    Communicator,
+    JobStatus,
+    Status,
+    StatusUpdate,
+)
 
 set_documentation_group("py-client")
 
@@ -402,14 +407,15 @@ def view_api(
         # Versions of Gradio older than 3.26 returned format of the API info
         # from the /info endpoint
         if (
-            version.parse(self.config.get("version", "2.0")) >= version.Version("3.26")
+            version.parse(self.config.get("version", "2.0")) > version.Version("3.28.1")
             and r.ok
         ):
             info = r.json()
         else:
             fetch = requests.post(
                 utils.SPACE_FETCHER_URL,
-                json={"serialize": self.serialize, "config": json.dumps(self.config)},
+                # Serialize has no effect
+                json={"config": json.dumps(self.config), "serialize": self.serialize},
             )
             if fetch.ok:
                 info = fetch.json()["api"]
@@ -449,7 +455,7 @@ def reset_session(self) -> None:
     def _render_endpoints_info(
         self,
         name_or_index: str | int,
-        endpoints_info: Dict[str, List[Dict[str, str]]],
+        endpoints_info: Dict[str, List[Dict[str, Any]]],
     ) -> str:
         parameter_names = [p["label"] for p in endpoints_info["parameters"]]
         parameter_names = [utils.sanitize_parameter_names(p) for p in parameter_names]
@@ -473,13 +479,25 @@ def _render_endpoints_info(
         human_info += "    Parameters:\n"
         if endpoints_info["parameters"]:
             for info in endpoints_info["parameters"]:
-                human_info += f"     - [{info['component']}] {utils.sanitize_parameter_names(info['label'])}: {info['type_python']} ({info['type_description']})\n"
+                desc = (
+                    f" ({info['python_type']['description']})"
+                    if info["python_type"].get("description")
+                    else ""
+                )
+                type_ = info["python_type"]["type"]
+                human_info += f"     - [{info['component']}] {utils.sanitize_parameter_names(info['label'])}: {type_}{desc} \n"
         else:
             human_info += "     - None\n"
         human_info += "    Returns:\n"
         if endpoints_info["returns"]:
             for info in endpoints_info["returns"]:
-                human_info += f"     - [{info['component']}] {utils.sanitize_parameter_names(info['label'])}: {info['type_python']} ({info['type_description']})\n"
+                desc = (
+                    f" ({info['python_type']['description']})"
+                    if info["python_type"].get("description")
+                    else ""
+                )
+                type_ = info["python_type"]["type"]
+                human_info += f"     - [{info['component']}] {utils.sanitize_parameter_names(info['label'])}: {type_}{desc} \n"
         else:
             human_info += "     - None\n"
 

client/python/gradio_client/serializing.py

@@ -9,8 +9,17 @@
 from gradio_client import media_data, utils
 from gradio_client.data_classes import FileData
 
+serializer_types = json.load(open(Path(__file__).parent / "types.json"))
+
 
 class Serializable:
+    def serialized_info(self):
+        """
+        The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
+        Keys of the dictionary are: raw_input, raw_output, serialized_input, serialized_output
+        """
+        return self.api_info()
+
     def api_info(self) -> Dict[str, List[str]]:
         """
         The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
@@ -57,12 +66,10 @@ def deserialize(
 class SimpleSerializable(Serializable):
     """General class that does not perform any serialization or deserialization."""
 
-    def api_info(self) -> Dict[str, str | List[str]]:
+    def api_info(self) -> Dict[str, Dict | bool]:
         return {
-            "raw_input": ["Any", ""],
-            "raw_output": ["Any", ""],
-            "serialized_input": ["Any", ""],
-            "serialized_output": ["Any", ""],
+            "info": serializer_types["SimpleSerializable"],
+            "serialized_info": False,
         }
 
     def example_inputs(self) -> Dict[str, Any]:
@@ -75,12 +82,10 @@ def example_inputs(self) -> Dict[str, Any]:
 class StringSerializable(Serializable):
     """Expects a string as input/output but performs no serialization."""
 
-    def api_info(self) -> Dict[str, List[str]]:
+    def api_info(self) -> Dict[str, Dict | bool]:
         return {
-            "raw_input": ["str", "string value"],
-            "raw_output": ["str", "string value"],
-            "serialized_input": ["str", "string value"],
-            "serialized_output": ["str", "string value"],
+            "info": serializer_types["StringSerializable"],
+            "serialized_info": False,
         }
 
     def example_inputs(self) -> Dict[str, Any]:
@@ -93,12 +98,10 @@ def example_inputs(self) -> Dict[str, Any]:
 class ListStringSerializable(Serializable):
     """Expects a list of strings as input/output but performs no serialization."""
 
-    def api_info(self) -> Dict[str, List[str]]:
+    def api_info(self) -> Dict[str, Dict | bool]:
         return {
-            "raw_input": ["List[str]", "list of string values"],
-            "raw_output": ["List[str]", "list of string values"],
-            "serialized_input": ["List[str]", "list of string values"],
-            "serialized_output": ["List[str]", "list of string values"],
+            "info": serializer_types["ListStringSerializable"],
+            "serialized_info": False,
         }
 
     def example_inputs(self) -> Dict[str, Any]:
@@ -111,15 +114,13 @@ def example_inputs(self) -> Dict[str, Any]:
 class BooleanSerializable(Serializable):
     """Expects a boolean as input/output but performs no serialization."""
 
-    def api_info(self) -> Dict[str, List[str]]:
+    def api_info(self) -> Dict[str, Dict | bool]:
         return {
-            "raw_input": ["bool", "boolean value"],
-            "raw_output": ["bool", "boolean value"],
-            "serialized_input": ["bool", "boolean value"],
-            "serialized_output": ["bool", "boolean value"],
+            "info": serializer_types["BooleanSerializable"],
+            "serialized_info": False,
         }
 
-    def example_inputs(self) -> Dict[str, Any]:
+    def example_inputs(self) -> Dict[str, Dict | bool]:
         return {
             "raw": True,
             "serialized": True,
@@ -129,12 +130,10 @@ def example_inputs(self) -> Dict[str, Any]:
 class NumberSerializable(Serializable):
     """Expects a number (int/float) as input/output but performs no serialization."""
 
-    def api_info(self) -> Dict[str, List[str]]:
+    def api_info(self) -> Dict[str, Dict | bool]:
         return {
-            "raw_input": ["int | float", "numeric value"],
-            "raw_output": ["int | float", "numeric value"],
-            "serialized_input": ["int | float", "numeric value"],
-            "serialized_output": ["int | float", "numeric value"],
+            "info": serializer_types["NumberSerializable"],
+            "serialized_info": False,
         }
 
     def example_inputs(self) -> Dict[str, Any]:
@@ -147,13 +146,11 @@ def example_inputs(self) -> Dict[str, Any]:
 class ImgSerializable(Serializable):
     """Expects a base64 string as input/output which is serialized to a filepath."""
 
-    def api_info(self) -> Dict[str, List[str]]:
-        return {
-            "raw_input": ["str", "base64 representation of image"],
-            "raw_output": ["str", "base64 representation of image"],
-            "serialized_input": ["str", "filepath or URL to image"],
-            "serialized_output": ["str", "filepath or URL to image"],
-        }
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath or URL to image"}
+
+    def api_info(self) -> Dict[str, Dict | bool]:
+        return {"info": serializer_types["ImgSerializable"], "serialized_info": True}
 
     def example_inputs(self) -> Dict[str, Any]:
         return {
@@ -204,19 +201,11 @@ def deserialize(
 class FileSerializable(Serializable):
     """Expects a dict with base64 representation of object as input/output which is serialized to a filepath."""
 
-    def api_info(self) -> Dict[str, List[str]]:
-        return {
-            "raw_input": [
-                "str | Dict",
-                "base64 string representation of file; or a dictionary-like object, the keys should be either: is_file (False), data (base64 representation of file) or is_file (True), name (str filename)",
-            ],
-            "raw_output": [
-                "Dict",
-                "dictionary-like object with keys: name (str filename), data (base64 representation of file), is_file (bool, set to False)",
-            ],
-            "serialized_input": ["str", "filepath or URL to file"],
-            "serialized_output": ["str", "filepath or URL to file"],
-        }
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath or URL to file"}
+
+    def api_info(self) -> Dict[str, Dict | bool]:
+        return {"info": serializer_types["FileSerializable"], "serialized_info": True}
 
     def example_inputs(self) -> Dict[str, Any]:
         return {
@@ -331,19 +320,11 @@ def deserialize(
 
 
 class VideoSerializable(FileSerializable):
-    def api_info(self) -> Dict[str, List[str]]:
-        return {
-            "raw_input": [
-                "str | Dict",
-                "base64 string representation of file; or a dictionary-like object, the keys should be either: is_file (False), data (base64 representation of file) or is_file (True), name (str filename)",
-            ],
-            "raw_output": [
-                "Tuple[Dict, Dict]",
-                "a tuple of 2 dictionary-like object with keys: name (str filename), data (base64 representation of file), is_file (bool, set to False). First dictionary is for the video, second dictionary is for the subtitles.",
-            ],
-            "serialized_input": ["str", "filepath or URL to file"],
-            "serialized_output": ["str", "filepath or URL to file"],
-        }
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath or URL to video file"}
+
+    def api_info(self) -> Dict[str, Dict | bool]:
+        return {"info": serializer_types["FileSerializable"], "serialized_info": True}
 
     def example_inputs(self) -> Dict[str, Any]:
         return {
@@ -378,13 +359,11 @@ def deserialize(
 
 
 class JSONSerializable(Serializable):
-    def api_info(self) -> Dict[str, List[str]]:
-        return {
-            "raw_input": ["str | Dict | List", "JSON-serializable object or a string"],
-            "raw_output": ["Dict | List", "dictionary- or list-like object"],
-            "serialized_input": ["str", "filepath to JSON file"],
-            "serialized_output": ["str", "filepath to JSON file"],
-        }
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath to JSON file"}
+
+    def api_info(self) -> Dict[str, Dict | bool]:
+        return {"info": serializer_types["JSONSerializable"], "serialized_info": True}
 
     def example_inputs(self) -> Dict[str, Any]:
         return {
@@ -430,24 +409,16 @@ def deserialize(
 
 
 class GallerySerializable(Serializable):
-    def api_info(self) -> Dict[str, List[str]]:
+    def serialized_info(self):
+        return {
+            "type": "string",
+            "description": "path to directory with images and a file associating images with captions called captions.json",
+        }
+
+    def api_info(self) -> Dict[str, Dict | bool]:
         return {
-            "raw_input": [
-                "List[List[str | None]]",
-                "List of lists. The inner lists should contain two elements: a base64 file representation and an optional caption, the outer list should contain one such list for each image in the gallery.",
-            ],
-            "raw_output": [
-                "List[List[str | None]]",
-                "List of lists. The inner lists should contain two elements: a base64 file representation and an optional caption, the outer list should contain one such list for each image in the gallery.",
-            ],
-            "serialized_input": [
-                "str",
-                "path to directory with images and a file associating images with captions called captions.json",
-            ],
-            "serialized_output": [
-                "str",
-                "path to directory with images and a file associating images with captions called captions.json",
-            ],
+            "info": serializer_types["GallerySerializable"],
+            "serialized_info": True,
         }
 
     def example_inputs(self) -> Dict[str, Any]: