Upload 5 files

Dockerfile

@@ -0,0 +1,31 @@
+FROM r8.im/fofr/expression-editor@sha256:bf913bc90e1c44ba288ba3942a538693b72e8cc7df576f3beebe56adc0a92b86
+RUN apt-get update && apt-get install -y netcat jq
+
+RUN useradd -m -u 1000 user
+RUN chown -R user:user / || true
+RUN chown -R user:user /src/
+RUN chown -R user:user /root/
+RUN chown -R user:user /var/
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONPATH=$HOME/app \
+    PYTHONUNBUFFERED=1 \
+    GRADIO_ALLOW_FLAGGING=never \
+    GRADIO_NUM_PORTS=1 \
+    GRADIO_SERVER_NAME=0.0.0.0 \
+    GRADIO_THEME=huggingface \
+    SYSTEM=spaces 
+
+WORKDIR $HOME/app
+COPY ./requirements.txt /code/requirements.txt
+
+# create virtual env for Gradio app
+RUN python -m venv $HOME/.venv && \
+    . $HOME/.venv/bin/activate && \ 
+    pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r /code/requirements.txt 
+
+COPY --chown=user . $HOME/app
+RUN chmod +x $HOME/app/run.sh
+CMD ["bash", "-c", "$HOME/app/run.sh"]

app.py

@@ -0,0 +1,161 @@
+import gradio as gr
+from urllib.parse import urlparse
+import requests
+import time
+import os
+
+from utils.gradio_helpers import parse_outputs, process_outputs
+
+inputs = []
+inputs.append(gr.Image(
+    label="Image", type="filepath"
+))
+
+inputs.append(gr.Slider(
+    label="Rotate Pitch", info='''Rotation pitch: Adjusts the up and down tilt of the face''', value=0,
+    minimum=-20, maximum=20
+))
+
+inputs.append(gr.Slider(
+    label="Rotate Yaw", info='''Rotation yaw: Adjusts the left and right turn of the face''', value=0,
+    minimum=-20, maximum=20
+))
+
+inputs.append(gr.Slider(
+    label="Rotate Roll", info='''Rotation roll: Adjusts the tilt of the face to the left or right''', value=0,
+    minimum=-20, maximum=20
+))
+
+inputs.append(gr.Slider(
+    label="Blink", info='''Blink: Controls the degree of eye closure''', value=0,
+    minimum=-20, maximum=5
+))
+
+inputs.append(gr.Slider(
+    label="Eyebrow", info='''Eyebrow: Adjusts the height and shape of the eyebrows''', value=0,
+    minimum=-10, maximum=15
+))
+
+inputs.append(gr.Number(
+    label="Wink", info='''Wink: Controls the degree of one eye closing''', value=0
+))
+
+inputs.append(gr.Slider(
+    label="Pupil X", info='''Pupil X: Adjusts the horizontal position of the pupils''', value=0,
+    minimum=-15, maximum=15
+))
+
+inputs.append(gr.Slider(
+    label="Pupil Y", info='''Pupil Y: Adjusts the vertical position of the pupils''', value=0,
+    minimum=-15, maximum=15
+))
+
+inputs.append(gr.Slider(
+    label="Aaa", info='''AAA: Controls the mouth opening for 'aaa' sound''', value=0,
+    minimum=-30, maximum=120
+))
+
+inputs.append(gr.Slider(
+    label="Eee", info='''EEE: Controls the mouth shape for 'eee' sound''', value=0,
+    minimum=-20, maximum=15
+))
+
+inputs.append(gr.Slider(
+    label="Woo", info='''WOO: Controls the mouth shape for 'woo' sound''', value=0,
+    minimum=-20, maximum=15
+))
+
+inputs.append(gr.Slider(
+    label="Smile", info='''Smile: Adjusts the degree of smiling''', value=0,
+    minimum=-0.3, maximum=1.3
+))
+
+inputs.append(gr.Number(
+    label="Src Ratio", info='''Source ratio''', value=1
+))
+
+inputs.append(gr.Slider(
+    label="Sample Ratio", info='''Sample ratio''', value=1,
+    minimum=-0.2, maximum=1.2
+))
+
+inputs.append(gr.Slider(
+    label="Crop Factor", info='''Crop factor''', value=1.7,
+    minimum=1.5, maximum=2.5
+))
+
+inputs.append(gr.Dropdown(
+    choices=['webp', 'jpg', 'png'], label="output_format", info='''Format of the output images''', value="webp"
+))
+
+inputs.append(gr.Number(
+    label="Output Quality", info='''Quality of the output images, from 0 to 100. 100 is best quality, 0 is lowest quality.''', value=95
+))
+
+names = ['image', 'rotate_pitch', 'rotate_yaw', 'rotate_roll', 'blink', 'eyebrow', 'wink', 'pupil_x', 'pupil_y', 'aaa', 'eee', 'woo', 'smile', 'src_ratio', 'sample_ratio', 'crop_factor', 'output_format', 'output_quality']
+
+outputs = []
+outputs.append(gr.Image())
+
+expected_outputs = len(outputs)
+def predict(request: gr.Request, *args, progress=gr.Progress(track_tqdm=True)):
+    headers = {'Content-Type': 'application/json'}
+
+    payload = {"input": {}}
+    
+    
+    parsed_url = urlparse(str(request.url))
+    base_url = parsed_url.scheme + "://" + parsed_url.netloc
+    for i, key in enumerate(names):
+        value = args[i]
+        if value and (os.path.exists(str(value))):
+            value = f"{base_url}/file=" + value
+        if value is not None and value != "":
+            payload["input"][key] = value
+
+    response = requests.post("http://0.0.0.0:5000/predictions", headers=headers, json=payload)
+
+    
+    if response.status_code == 201:
+        follow_up_url = response.json()["urls"]["get"]
+        response = requests.get(follow_up_url, headers=headers)
+        while response.json()["status"] != "succeeded":
+            if response.json()["status"] == "failed":
+                raise gr.Error("The submission failed!")
+            response = requests.get(follow_up_url, headers=headers)
+            time.sleep(1)
+    if response.status_code == 200:
+        json_response = response.json()
+        #If the output component is JSON return the entire output response 
+        if(outputs[0].get_config()["name"] == "json"):
+            return json_response["output"]
+        predict_outputs = parse_outputs(json_response["output"])
+        processed_outputs = process_outputs(predict_outputs)
+        difference_outputs = expected_outputs - len(processed_outputs)
+        # If less outputs than expected, hide the extra ones
+        if difference_outputs > 0:
+            extra_outputs = [gr.update(visible=False)] * difference_outputs
+            processed_outputs.extend(extra_outputs)
+        # If more outputs than expected, cap the outputs to the expected number
+        elif difference_outputs < 0:
+            processed_outputs = processed_outputs[:difference_outputs]
+        
+        return tuple(processed_outputs) if len(processed_outputs) > 1 else processed_outputs[0]
+    else:
+        if(response.status_code == 409):
+            raise gr.Error(f"Sorry, the Cog image is still processing. Try again in a bit.")
+        raise gr.Error(f"The submission failed! Error: {response.status_code}")
+
+title = "Demo for expression-editor cog image by fofr"
+model_description = "None"
+
+app = gr.Interface(
+    fn=predict,
+    inputs=inputs,
+    outputs=outputs,
+    title=title,
+    description=model_description,
+    allow_flagging="never",
+)
+app.launch(share=True)
+

requirements.txt

@@ -0,0 +1,2 @@
+gradio==4.18.0
+prance

run.sh

@@ -0,0 +1,44 @@
+# Start the cog server in the background - Ensure correct path to cog
+cd /src && python3 -m cog.server.http --threads=10 &
+
+# Initialize counter for the first loop
+counter1=0
+
+# Continuous loop for reliably checking cog server's readiness on port 5000
+while true; do
+  if nc -z localhost 5000; then
+    echo "Cog server is running on port 5000."
+    break  # Exit the loop when the server is up
+  fi
+  echo "Waiting for cog server to start on port 5000..."
+  sleep 5
+  ((counter1++))
+  if [ $counter1 -ge 250 ]; then
+    echo "Error: Cog server did not start on port 5000 after 250 attempts."
+    exit 1  # Exit the script with an error status
+  fi
+done
+
+# Initialize counter for the second loop
+counter2=0
+
+# New check: Waiting for the cog server to be fully ready
+while true; do
+  response=$(curl -s http://localhost:5000/health-check) # Replace localhost:5000 with actual hostname and port if necessary
+  status=$(echo $response | jq -r '.status') # Parse status from JSON response
+  if [ "$status" = "READY" ]; then
+    echo "Cog server is fully ready."
+    break # Exit the loop when the server is fully ready
+  else
+    echo "Waiting for cog server (models loading) on port 5000..."
+    sleep 5
+  fi
+  ((counter2++))
+  if [ $counter2 -ge 250 ]; then
+    echo "Error: Cog server did not become fully ready after 250 attempts."
+    exit 1  # Exit the script with an error status
+  fi
+done
+
+# Run the application - only when cog server is fully ready
+cd $HOME/app && . $HOME/.venv/bin/activate && python app.py

utils/gradio_helpers.py

@@ -0,0 +1,469 @@
+import gradio as gr
+from urllib.parse import urlparse
+import requests
+import time
+from PIL import Image
+import base64
+import io
+import uuid
+import os
+
+
+def extract_property_info(prop):
+    combined_prop = {}
+    merge_keywords = ["allOf", "anyOf", "oneOf"]
+
+    for keyword in merge_keywords:
+        if keyword in prop:
+            for subprop in prop[keyword]:
+                combined_prop.update(subprop)
+            del prop[keyword]
+
+    if not combined_prop:
+        combined_prop = prop.copy()
+
+    for key in ["description", "default"]:
+        if key in prop:
+            combined_prop[key] = prop[key]
+
+    return combined_prop
+
+
+def detect_file_type(filename):
+    audio_extensions = [".mp3", ".wav", ".flac", ".aac", ".ogg", ".m4a"]
+    image_extensions = [
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".gif",
+        ".bmp",
+        ".tiff",
+        ".svg",
+        ".webp",
+    ]
+    video_extensions = [
+        ".mp4",
+        ".mov",
+        ".wmv",
+        ".flv",
+        ".avi",
+        ".avchd",
+        ".mkv",
+        ".webm",
+    ]
+
+    # Extract the file extension
+    if isinstance(filename, str):
+        extension = filename[filename.rfind(".") :].lower()
+
+        # Check the extension against each list
+        if extension in audio_extensions:
+            return "audio"
+        elif extension in image_extensions:
+            return "image"
+        elif extension in video_extensions:
+            return "video"
+        else:
+            return "string"
+    elif isinstance(filename, list):
+        return "list"
+
+
+def build_gradio_inputs(ordered_input_schema, example_inputs=None):
+    inputs = []
+    input_field_strings = """inputs = []\n"""
+    names = []
+    for index, (name, prop) in enumerate(ordered_input_schema):
+        names.append(name)
+        prop = extract_property_info(prop)
+        if "enum" in prop:
+            input_field = gr.Dropdown(
+                choices=prop["enum"],
+                label=prop.get("title"),
+                info=prop.get("description"),
+                value=prop.get("default"),
+            )
+            input_field_string = f"""inputs.append(gr.Dropdown(
+    choices={prop["enum"]}, label="{prop.get("title")}", info={"'''"+prop.get("description")+"'''" if prop.get("description") else 'None'}, value="{prop.get("default")}"
+))\n"""
+        elif prop["type"] == "integer":
+            if prop.get("minimum") and prop.get("maximum"):
+                input_field = gr.Slider(
+                    label=prop.get("title"),
+                    info=prop.get("description"),
+                    value=prop.get("default"),
+                    minimum=prop.get("minimum"),
+                    maximum=prop.get("maximum"),
+                    step=1,
+                )
+                input_field_string = f"""inputs.append(gr.Slider(
+    label="{prop.get("title")}", info={"'''"+prop.get("description")+"'''" if prop.get("description") else 'None'}, value={prop.get("default")},
+    minimum={prop.get("minimum")}, maximum={prop.get("maximum")}, step=1,
+))\n"""
+            else:
+                input_field = gr.Number(
+                    label=prop.get("title"),
+                    info=prop.get("description"),
+                    value=prop.get("default"),
+                )
+                input_field_string = f"""inputs.append(gr.Number(
+    label="{prop.get("title")}", info={"'''"+prop.get("description")+"'''" if prop.get("description") else 'None'}, value={prop.get("default")}
+))\n"""
+        elif prop["type"] == "number":
+            if prop.get("minimum") and prop.get("maximum"):
+                input_field = gr.Slider(
+                    label=prop.get("title"),
+                    info=prop.get("description"),
+                    value=prop.get("default"),
+                    minimum=prop.get("minimum"),
+                    maximum=prop.get("maximum"),
+                )
+                input_field_string = f"""inputs.append(gr.Slider(
+    label="{prop.get("title")}", info={"'''"+prop.get("description")+"'''" if prop.get("description") else 'None'}, value={prop.get("default")},
+    minimum={prop.get("minimum")}, maximum={prop.get("maximum")}
+))\n"""
+            else:
+                input_field = gr.Number(
+                    label=prop.get("title"),
+                    info=prop.get("description"),
+                    value=prop.get("default"),
+                )
+                input_field_string = f"""inputs.append(gr.Number(
+    label="{prop.get("title")}", info={"'''"+prop.get("description")+"'''" if prop.get("description") else 'None'}, value={prop.get("default")}
+))\n"""
+        elif prop["type"] == "boolean":
+            input_field = gr.Checkbox(
+                label=prop.get("title"),
+                info=prop.get("description"),
+                value=prop.get("default"),
+            )
+            input_field_string = f"""inputs.append(gr.Checkbox(
+    label="{prop.get("title")}", info={"'''"+prop.get("description")+"'''" if prop.get("description") else 'None'}, value={prop.get("default")}
+))\n"""
+        elif (
+            prop["type"] == "string" and prop.get("format") == "uri" and example_inputs
+        ):
+            input_type_example = example_inputs.get(name, None)
+            if input_type_example:
+                input_type = detect_file_type(input_type_example)
+            else:
+                input_type = None
+            if input_type == "image":
+                input_field = gr.Image(label=prop.get("title"), type="filepath")
+                input_field_string = f"""inputs.append(gr.Image(
+    label="{prop.get("title")}", type="filepath"
+))\n"""
+            elif input_type == "audio":
+                input_field = gr.Audio(label=prop.get("title"), type="filepath")
+                input_field_string = f"""inputs.append(gr.Audio(
+    label="{prop.get("title")}", type="filepath"
+))\n"""
+            elif input_type == "video":
+                input_field = gr.Video(label=prop.get("title"))
+                input_field_string = f"""inputs.append(gr.Video(
+    label="{prop.get("title")}"
+))\n"""
+            else:
+                input_field = gr.File(label=prop.get("title"))
+                input_field_string = f"""inputs.append(gr.File(
+    label="{prop.get("title")}"
+))\n"""
+        else:
+            input_field = gr.Textbox(
+                label=prop.get("title"),
+                info=prop.get("description"),
+            )
+            input_field_string = f"""inputs.append(gr.Textbox(
+    label="{prop.get("title")}", info={"'''"+prop.get("description")+"'''" if prop.get("description") else 'None'}
+))\n"""
+        inputs.append(input_field)
+        input_field_strings += f"{input_field_string}\n"
+
+    input_field_strings += f"names = {names}\n"
+
+    return inputs, input_field_strings, names
+
+
+def build_gradio_outputs_replicate(output_types):
+    outputs = []
+    output_field_strings = """outputs = []\n"""
+    if output_types:
+        for output in output_types:
+            if output == "image":
+                output_field = gr.Image()
+                output_field_string = "outputs.append(gr.Image())"
+            elif output == "audio":
+                output_field = gr.Audio(type="filepath")
+                output_field_string = "outputs.append(gr.Audio(type='filepath'))"
+            elif output == "video":
+                output_field = gr.Video()
+                output_field_string = "outputs.append(gr.Video())"
+            elif output == "string":
+                output_field = gr.Textbox()
+                output_field_string = "outputs.append(gr.Textbox())"
+            elif output == "json":
+                output_field = gr.JSON()
+                output_field_string = "outputs.append(gr.JSON())"
+            elif output == "list":
+                output_field = gr.JSON()
+                output_field_string = "outputs.append(gr.JSON())"
+            outputs.append(output_field)
+            output_field_strings += f"{output_field_string}\n"
+    else:
+        output_field = gr.JSON()
+        output_field_string = "outputs.append(gr.JSON())"
+        outputs.append(output_field)
+
+    return outputs, output_field_strings
+
+
+def build_gradio_outputs_cog():
+    pass
+
+
+def process_outputs(outputs):
+    output_values = []
+    for output in outputs:
+        if not output:
+            continue
+        if isinstance(output, str):
+            if output.startswith("data:image"):
+                base64_data = output.split(",", 1)[1]
+                image_data = base64.b64decode(base64_data)
+                image_stream = io.BytesIO(image_data)
+                image = Image.open(image_stream)
+                output_values.append(image)
+            elif output.startswith("data:audio"):
+                base64_data = output.split(",", 1)[1]
+                audio_data = base64.b64decode(base64_data)
+                audio_stream = io.BytesIO(audio_data)
+                filename = f"{uuid.uuid4()}.wav"  # Change format as needed
+                with open(filename, "wb") as audio_file:
+                    audio_file.write(audio_stream.getbuffer())
+                output_values.append(filename)
+            elif output.startswith("data:video"):
+                base64_data = output.split(",", 1)[1]
+                video_data = base64.b64decode(base64_data)
+                video_stream = io.BytesIO(video_data)
+                # Here you can save the audio or return the stream for further processing
+                filename = f"{uuid.uuid4()}.mp4"  # Change format as needed
+                with open(filename, "wb") as video_file:
+                    video_file.write(video_stream.getbuffer())
+                output_values.append(filename)
+            else:
+                output_values.append(output)
+        else:
+            output_values.append(output)
+    return output_values
+
+
+def parse_outputs(data):
+    if isinstance(data, dict):
+        # Handle case where data is an object
+        dict_values = []
+        for value in data.values():
+            extracted_values = parse_outputs(value)
+            # For dict, we append instead of extend to maintain list structure within objects
+            if isinstance(value, list):
+                dict_values += [extracted_values]
+            else:
+                dict_values += extracted_values
+        return dict_values
+    elif isinstance(data, list):
+        # Handle case where data is an array
+        list_values = []
+        for item in data:
+            # Here we extend to flatten the list since we're already in an array context
+            list_values += parse_outputs(item)
+        return list_values
+    else:
+        # Handle primitive data types directly
+        return [data]
+
+
+def create_dynamic_gradio_app(
+    inputs,
+    outputs,
+    api_url,
+    api_id=None,
+    replicate_token=None,
+    title="",
+    model_description="",
+    names=[],
+    local_base=False,
+    hostname="0.0.0.0",
+):
+    expected_outputs = len(outputs)
+
+    def predict(request: gr.Request, *args, progress=gr.Progress(track_tqdm=True)):
+        payload = {"input": {}}
+        if api_id:
+            payload["version"] = api_id
+        parsed_url = urlparse(str(request.url))
+        if local_base:
+            base_url = f"http://{hostname}:7860"
+        else:
+            base_url = parsed_url.scheme + "://" + parsed_url.netloc
+        for i, key in enumerate(names):
+            value = args[i]
+            if value and (os.path.exists(str(value))):
+                value = f"{base_url}/file=" + value
+            if value is not None and value != "":
+                payload["input"][key] = value
+        print(payload)
+        headers = {"Content-Type": "application/json"}
+        if replicate_token:
+            headers["Authorization"] = f"Token {replicate_token}"
+        print(headers)
+        response = requests.post(api_url, headers=headers, json=payload)
+        if response.status_code == 201:
+            follow_up_url = response.json()["urls"]["get"]
+            response = requests.get(follow_up_url, headers=headers)
+            while response.json()["status"] != "succeeded":
+                if response.json()["status"] == "failed":
+                    raise gr.Error("The submission failed!")
+                response = requests.get(follow_up_url, headers=headers)
+                time.sleep(1)
+                # TODO: Add a failing mechanism if the API gets stuck
+        if response.status_code == 200:
+            json_response = response.json()
+            # If the output component is JSON return the entire output response
+            if outputs[0].get_config()["name"] == "json":
+                return json_response["output"]
+            predict_outputs = parse_outputs(json_response["output"])
+            processed_outputs = process_outputs(predict_outputs)
+            difference_outputs = expected_outputs - len(processed_outputs)
+            # If less outputs than expected, hide the extra ones
+            if difference_outputs > 0:
+                extra_outputs = [gr.update(visible=False)] * difference_outputs
+                processed_outputs.extend(extra_outputs)
+            # If more outputs than expected, cap the outputs to the expected number if
+            elif difference_outputs < 0:
+                processed_outputs = processed_outputs[:difference_outputs]
+
+            return (
+                tuple(processed_outputs)
+                if len(processed_outputs) > 1
+                else processed_outputs[0]
+            )
+
+        else:
+            if response.status_code == 409:
+                raise gr.Error(
+                    f"Sorry, the Cog image is still processing. Try again in a bit."
+                )
+            raise gr.Error(f"The submission failed! Error: {response.status_code}")
+
+    app = gr.Interface(
+        fn=predict,
+        inputs=inputs,
+        outputs=outputs,
+        title=title,
+        description=model_description,
+        allow_flagging="never",
+    )
+    return app
+
+
+def create_gradio_app_script(
+    inputs_string,
+    outputs_string,
+    api_url,
+    api_id=None,
+    replicate_token=None,
+    title="",
+    model_description="",
+    local_base=False,
+    hostname="0.0.0.0"
+):
+    headers = {"Content-Type": "application/json"}
+    if replicate_token:
+        headers["Authorization"] = f"Token {replicate_token}"
+
+    if local_base:
+        base_url = f'base_url = "http://{hostname}:7860"'
+    else:
+        base_url = """parsed_url = urlparse(str(request.url))
+    base_url = parsed_url.scheme + "://" + parsed_url.netloc"""
+    headers_string = f"""headers = {headers}\n"""
+    api_id_value = f'payload["version"] = "{api_id}"' if api_id is not None else ""
+    definition_string = """expected_outputs = len(outputs)
+def predict(request: gr.Request, *args, progress=gr.Progress(track_tqdm=True)):"""
+    payload_string = f"""payload = {{"input": {{}}}}
+    {api_id_value}
+    
+    {base_url}
+    for i, key in enumerate(names):
+        value = args[i]
+        if value and (os.path.exists(str(value))):
+            value = f"{{base_url}}/file=" + value
+        if value is not None and value != "":
+            payload["input"][key] = value\n"""
+
+    request_string = (
+        f"""response = requests.post("{api_url}", headers=headers, json=payload)\n"""
+    )
+
+    result_string = f"""
+    if response.status_code == 201:
+        follow_up_url = response.json()["urls"]["get"]
+        response = requests.get(follow_up_url, headers=headers)
+        while response.json()["status"] != "succeeded":
+            if response.json()["status"] == "failed":
+                raise gr.Error("The submission failed!")
+            response = requests.get(follow_up_url, headers=headers)
+            time.sleep(1)
+    if response.status_code == 200:
+        json_response = response.json()
+        #If the output component is JSON return the entire output response 
+        if(outputs[0].get_config()["name"] == "json"):
+            return json_response["output"]
+        predict_outputs = parse_outputs(json_response["output"])
+        processed_outputs = process_outputs(predict_outputs)
+        difference_outputs = expected_outputs - len(processed_outputs)
+        # If less outputs than expected, hide the extra ones
+        if difference_outputs > 0:
+            extra_outputs = [gr.update(visible=False)] * difference_outputs
+            processed_outputs.extend(extra_outputs)
+        # If more outputs than expected, cap the outputs to the expected number
+        elif difference_outputs < 0:
+            processed_outputs = processed_outputs[:difference_outputs]
+        
+        return tuple(processed_outputs) if len(processed_outputs) > 1 else processed_outputs[0]
+    else:
+        if(response.status_code == 409):
+            raise gr.Error(f"Sorry, the Cog image is still processing. Try again in a bit.")
+        raise gr.Error(f"The submission failed! Error: {{response.status_code}}")\n"""
+
+    interface_string = f"""title = "{title}"
+model_description = "{model_description}"
+
+app = gr.Interface(
+    fn=predict,
+    inputs=inputs,
+    outputs=outputs,
+    title=title,
+    description=model_description,
+    allow_flagging="never",
+)
+app.launch(share=True)
+"""
+
+    app_string = f"""import gradio as gr
+from urllib.parse import urlparse
+import requests
+import time
+import os
+
+from utils.gradio_helpers import parse_outputs, process_outputs
+
+{inputs_string}
+{outputs_string}
+{definition_string}
+    {headers_string}
+    {payload_string}
+    {request_string}
+    {result_string}
+{interface_string}
+"""
+    return app_string