Update main_app.py

main_app.py

@@ -1,6 +1,8 @@
+
+
 import marimo
 
-__generated_with = "0.11.16"
+__generated_with = "0.13.0"
 app = marimo.App(width="medium")
 
 
@@ -11,17 +13,15 @@ def _():
     return mo, os
 
 
-@app.cell
-def _():
-    def get_markdown_content(file_path):
-        with open(file_path, 'r', encoding='utf-8') as file:
-            content = file.read()
-        return content
-    return (get_markdown_content,)
+@app.function
+def get_markdown_content(file_path):
+    with open(file_path, 'r', encoding='utf-8') as file:
+        content = file.read()
+    return content
 
 
 @app.cell
-def _(get_markdown_content, mo):
+def _(mo):
     intro_text = get_markdown_content('intro_markdown/intro.md')
     intro_marimo = get_markdown_content('intro_markdown/intro_marimo.md')
     intro_notebook = get_markdown_content('intro_markdown/intro_notebook.md')
@@ -35,75 +35,130 @@ def _(get_markdown_content, mo):
     ])
 
     mo.accordion({"## Notebook Introduction":intro})
-    return intro, intro_comparison, intro_marimo, intro_notebook, intro_text
+    return
 
 
 @app.cell
 def _(os):
     ### Imports
-    from typing import (
-        Any, Dict, List, Optional, Pattern, Set, Union, Tuple
-    )
+    from typing import Any, Dict, List, Optional, Pattern, Set, Union, Tuple
+    from ibm_watsonx_ai import APIClient, Credentials
     from pathlib import Path
-    from urllib.request import urlopen
-    # from rich.markdown import Markdown as Markd
-    from rich.text import Text
-    from rich import print
-    from tqdm import tqdm
-    from enum import Enum
     import pandas as pd
-    import tempfile
+    import mimetypes
     import requests
-    import getpass
+    import zipfile
+    import polars
     import urllib3
+    import tempfile
     import base64
-    import time
-    import json
     import uuid
     import ssl
+    import time
+    import json
     import ast
+    import io
     import re
 
-    pd.set_option('display.max_columns', None)  
-    pd.set_option('display.max_rows', None)     
-    pd.set_option('display.max_colwidth', None) 
-    pd.set_option('display.width', None)     
-
     # Set explicit temporary directory
     os.environ['TMPDIR'] = '/tmp/notebook_functions'
 
     # Make sure Python's tempfile module also uses this directory
     tempfile.tempdir = '/tmp/notebook_functions'
+
+    def get_iam_token(api_key):
+        return requests.post(
+            'https://iam.cloud.ibm.com/identity/token',
+            headers={'Content-Type': 'application/x-www-form-urlencoded'},
+            data={'grant_type': 'urn:ibm:params:oauth:grant-type:apikey', 'apikey': api_key}
+        ).json()['access_token']
+
+    def setup_task_credentials(client):
+        # Get existing task credentials
+        existing_credentials = client.task_credentials.get_details()
+
+        # Delete existing credentials if any
+        if "resources" in existing_credentials and existing_credentials["resources"]:
+            for cred in existing_credentials["resources"]:
+                cred_id = client.task_credentials.get_id(cred)
+                client.task_credentials.delete(cred_id)
+
+        # Store new credentials
+        return client.task_credentials.store()
+
+    def get_cred_value(key, creds_var_name="baked_in_creds", default=""): ### Helper for working with preset credentials
+        """
+        Helper function to safely get a value from a credentials dictionary.
+
+        Args:
+            key: The key to look up in the credentials dictionary.
+            creds_var_name: The variable name of the credentials dictionary.
+            default: The default value to return if the key is not found.
+
+        Returns:
+            The value from the credentials dictionary if it exists and contains the key,
+            otherwise returns the default value.
+        """
+        # Check if the credentials variable exists in globals
+        if creds_var_name in globals():
+            creds_dict = globals()[creds_var_name]
+            if isinstance(creds_dict, dict) and key in creds_dict:
+                return creds_dict[key]
+        return default
     return (
-        Any,
-        Dict,
-        Enum,
-        List,
-        Optional,
-        Path,
-        Pattern,
-        Set,
-        Text,
-        Tuple,
-        Union,
+        APIClient,
+        Credentials,
         ast,
-        base64,
-        getpass,
+        get_iam_token,
         json,
         pd,
-        print,
-        re,
-        requests,
-        ssl,
+        setup_task_credentials,
         tempfile,
-        time,
-        tqdm,
-        urllib3,
-        urlopen,
         uuid,
     )
 
 
+@app.cell
+def _(client_instantiation_form, os):
+    if client_instantiation_form.value:
+        client_setup = client_instantiation_form.value
+    else:
+        client_setup = None
+
+    ### Extract Credential Variables:
+    if client_setup is not None:
+        wx_url = client_setup["wx_region"]
+        wx_api_key = client_setup["wx_api_key"]
+        os.environ["WATSONX_APIKEY"] = wx_api_key
+
+        if client_setup["project_id"] is not None:
+            project_id = client_setup["project_id"]
+        else:
+            project_id = None
+
+        if client_setup["space_id"] is not None:
+            space_id = client_setup["space_id"]
+        else:
+            space_id = None
+
+    else:
+        os.environ["WATSONX_APIKEY"] = ""
+        project_id = None
+        space_id = None
+        wx_api_key = None
+        wx_url = None
+    return client_setup, project_id, space_id, wx_api_key, wx_url
+
+
+@app.cell
+def _(client_setup, get_iam_token, wx_api_key):
+    if client_setup:
+        token = get_iam_token(wx_api_key)
+    else:
+        token = None
+    return
+
+
 @app.cell
 def _(mo):
     ### Credentials for the watsonx.ai SDK client
@@ -133,90 +188,97 @@ def _(mo):
         .batch(
             wx_region = mo.ui.dropdown(regions, label="Select your watsonx.ai region:", value="US", searchable=True),
             wx_api_key = mo.ui.text(placeholder="Add your IBM Cloud api-key...", label="IBM Cloud Api-key:", kind="password"),
-            # project_id = mo.ui.text(placeholder="Add your watsonx.ai project_id...", label="Project_ID:", kind="text"),
+            project_id = mo.ui.text(placeholder="Add your watsonx.ai project_id...", label="Project_ID:", kind="text"),
             space_id = mo.ui.text(placeholder="Add your watsonx.ai space_id...", label="Space_ID:", kind="text")
         ,)
         .form(show_clear_button=True, bordered=False)
     )
 
-
-    # client_instantiation_form
-    return client_instantiation_form, regions, wx_platform_url
+    return (client_instantiation_form,)
 
 
 @app.cell
-def _(client_instantiation_form, mo):
-    from ibm_watsonx_ai import APIClient, Credentials
-
-    def setup_task_credentials(deployment_client):
-        # Get existing task credentials
-        existing_credentials = deployment_client.task_credentials.get_details()
-
-        # Delete existing credentials if any
-        if "resources" in existing_credentials and existing_credentials["resources"]:
-            for cred in existing_credentials["resources"]:
-                cred_id = deployment_client.task_credentials.get_id(cred)
-                deployment_client.task_credentials.delete(cred_id)
-
-        # Store new credentials
-        return deployment_client.task_credentials.store()
-
-    if client_instantiation_form.value:
+def _(
+    APIClient,
+    Credentials,
+    client_setup,
+    project_id,
+    setup_task_credentials,
+    space_id,
+    wx_api_key,
+    wx_url,
+):
     ### Instantiate the watsonx.ai client
+    if client_setup:
         wx_credentials = Credentials(
-            url=client_instantiation_form.value["wx_region"],
-            api_key=client_instantiation_form.value["wx_api_key"]
+            url=wx_url,
+            api_key=wx_api_key
         )
 
-        # project_client = APIClient(credentials=wx_credentials, project_id=client_instantiation_form.value["project_id"])
-        deployment_client = APIClient(credentials=wx_credentials, space_id=client_instantiation_form.value["space_id"])
+        if project_id:
+            project_client = APIClient(credentials=wx_credentials, project_id=project_id)
+        else:
+            project_client = None
 
-        task_credentials_details = setup_task_credentials(deployment_client)
+        if space_id:
+            deployment_client = APIClient(credentials=wx_credentials, space_id=space_id)
+        else:
+            deployment_client = None
+
+        if project_client is not None:
+            task_credentials_details = setup_task_credentials(project_client)
+        else:
+            task_credentials_details = setup_task_credentials(deployment_client)
     else:
-        # project_client = None
+        wx_credentials = None
+        project_client = None
         deployment_client = None
         task_credentials_details = None
 
-    template_variant = mo.ui.dropdown(["Base","Stream Files to IBM COS [Example]"], label="Code Template:", value="Base")
-
-    if deployment_client is not None:
+    if project_client is not None or deployment_client is not None:
         client_callout_kind = "success"
     else:
         client_callout_kind = "neutral"
+    return client_callout_kind, deployment_client
 
-    client_callout = mo.callout(template_variant, kind=client_callout_kind)
 
-    # client_callout
-    return (
-        APIClient,
-        Credentials,
-        client_callout,
-        client_callout_kind,
-        deployment_client,
-        setup_task_credentials,
-        task_credentials_details,
-        template_variant,
-        wx_credentials,
-    )
+@app.cell
+def _(mo):
+    template_variants = [
+        "Base",
+        "Stream Files to IBM COS [Example]",
+    ]
+    template_variant = mo.ui.dropdown(template_variants, label="Code Template:", value="Base")
+    return (template_variant,)
+
+
+@app.cell
+def _(client_callout_kind, client_instantiation_form, mo, template_variant):
+    client_callout = mo.callout(template_variant, kind=client_callout_kind)
+    client_stack = mo.hstack([client_instantiation_form, client_callout], align="center", justify="space-around")
+    return (client_stack,)
 
 
 @app.cell
 def _(
-    client_callout,
-    client_instantiation_form,
+    client_stack,
     deploy_fnc,
     deployment_definition,
     fm,
     function_editor,
     hw_selection_table,
     mo,
+    package_analysis_stack,
+    package_meta,
     purge_tabs,
     sc_m,
     schema_editors,
     selection_table,
+    ss_asset_details,
     upload_func,
+    yaml_template,
 ):
-    s1 = mo.md(f'''
+    client_section = mo.md(f'''
         ###**Instantiate your watsonx.ai client:**
 
         1. Select a region from the dropdown menu
@@ -229,11 +291,7 @@ def _(
 
         ---
 
-        {client_instantiation_form}
-
-        ---
-
-        {client_callout}
+        {client_stack}
 
     ''')
 
@@ -246,7 +304,7 @@ def _(
         }
     )
 
-    s2 = mo.md(f'''###**Create your function from the template:**
+    function_section = mo.md(f'''###**Create your function from the template:**
 
         1. Use the code editor window to create a function to deploy
         <br>
@@ -285,7 +343,7 @@ def _(
 
     ''')
 
-    s3 = mo.md(f'''
+    upload_section = mo.md(f'''
         ###**Review and Upload your function**
 
         1. Review the function metadata specs JSON
@@ -306,7 +364,7 @@ def _(
 
     ''')
 
-    s4 = mo.md(f'''
+    deployment_section = mo.md(f'''
         ###**Deploy your function:**
 
         1. Select a hardware specification (vCPUs/GB) that you want your function deployed on
@@ -339,32 +397,113 @@ def _(
 
     ''')
 
-    s5 = mo.md(f'''
+    purging_section = mo.md(f'''
         ###**Helper Purge Functions:**
-        
+
         These functions help you retrieve, select and delete deployments, data assets or repository assets (functions, models, etc.) that you have in the deployment space. This is meant to support fast cleanup.
-        
+
         Select the tab based on what you want to delete, then click each of the buttons one by one after the previous gives a response.
-    
+
         ---
 
         {purge_tabs}
 
     ''')
 
-    sections = mo.accordion(
-        {
-            "Section 1: **watsonx.ai Credentials**": s1,
-            "Section 2: **Function Creation**": s2,
-            "Section 3: **Function Upload**": s3,
-            "Section 4: **Function Deployment**": s4,
-            "Section 5: **Helper Functions**": s5,
-        }, 
-        multiple=True
+
+    packages_section = mo.md(f'''
+        ###**If needed - Create a custom software-spec with added python packages**
+
+        1. Check to see if the python library you want to use is already available inside watsonx.ai's runtime environment base specs for deployed functions by adding them as a comma separated list, e.g. - plotly, ibm-watsonx-ai==1.3.6, etc. into the text area.
+
+        2. If you wish to see all the packages already present, check the box to return it alognside your validation results.
+
+        ---
+
+        {package_analysis_stack}
+
+        ---
+
+        3. If it isn't, you can create a custom software spec that adds a package_extension add-on to it. Use the template selector to see some examples, but when you are ready add your packages in the code editor after the "pip:" section.
+
+        {yaml_template}
+
+        4. Give your package extension and software spec names and descriptions and submit.
+
+        5. You will find it in the Function Upload table afterward.
+
+        ---
+
+        {package_meta}
+
+        ---
+
+        Results:
+
+        {ss_asset_details}
+
+    ''')
+    return (
+        client_section,
+        deployment_section,
+        function_section,
+        packages_section,
+        upload_section,
     )
 
-    sections
-    return s1, s2, s3, s4, s5, sc_tabs, sections
+
+@app.cell
+def _(client_section, mo):
+    ui_accordion_section_1 = mo.accordion(
+        {"Section 1: **watsonx.ai Credentials**": client_section}
+    ) 
+    ui_accordion_section_1
+    return
+
+
+@app.cell
+def _(function_section, mo):
+    ui_accordion_section_2 = mo.accordion(
+        {"Section 2: **Function Creation**": function_section}
+    ) 
+    ui_accordion_section_2
+    return
+
+
+@app.cell
+def _(mo, packages_section):
+    ui_accordion_section_3 = mo.accordion(
+        {"Section 3: **Create a Package Extension (Optional)**": packages_section}
+    ) 
+    ui_accordion_section_3
+    return
+
+
+@app.cell
+def _(mo, upload_section):
+    ui_accordion_section_4 = mo.accordion(
+        {"Section 4: **Function Upload**": upload_section}
+    ) 
+    ui_accordion_section_4
+    return
+
+
+@app.cell
+def _(deployment_section, mo):
+    ui_accordion_section_5 = mo.accordion(
+        {"Section 5: **Function Deployment**": deployment_section}
+    ) 
+    ui_accordion_section_5
+    return
+
+
+@app.cell
+def _(mo, packages_section):
+    ui_accordion_section_6 = mo.accordion(
+        {"Section 6: **Helper Functions**": packages_section}
+    ) 
+    ui_accordion_section_6
+    return
 
 
 @app.cell
@@ -394,7 +533,7 @@ def _(mo, template_variant):
 
         return score
 
-        score = your_function_name()
+    score = your_function_name()
             '''
 
     function_editor = (
@@ -405,17 +544,17 @@ def _(mo, template_variant):
 
         ''')
         .batch(
-            editor = mo.ui.code_editor(value=template, language="python", min_height=50)
+            editor = mo.ui.code_editor(value=template, language="python", min_height=200, show_copy_button=True, theme="dark")
         )
         .form(show_clear_button=True, bordered=False)
         )
 
     # function_editor
-    return file, function_editor, template
+    return (function_editor,)
 
 
 @app.cell
-def _(function_editor, mo, os, ast):
+def _(ast, function_editor, mo, os):
     function_name = None
     if function_editor.value:
         # Get the edited code from the function editor
@@ -429,12 +568,12 @@ def _(function_editor, mo, os, ast):
                 if isinstance(node, ast.FunctionDef):
                     function_name = node.name
                     break
-            
+
             if function_name is not None:
                 # Set deployable_function to None since we're not executing the code
                 deployable_function = None
                 mo.md(f"Found function: '{function_name}' (using file path approach)")
-                
+
                 # Create the directory if it doesn't exist
                 save_dir = "/tmp/notebook_functions"
                 os.makedirs(save_dir, exist_ok=True)
@@ -446,18 +585,238 @@ def _(function_editor, mo, os, ast):
                 mo.md("No function found in the editor code")
         except SyntaxError as e:
             mo.md(f"Syntax error in function code: {str(e)}")
-    return (
-        code,
-        parsed_ast,
-        deployable_function,
-        f,
-        file_path,
-        function_name,
-        name,
-        namespace,
-        obj,
-        save_dir,
+    return (function_name,)
+
+
+@app.cell
+def _():
+    yaml_templates = {
+        "empty": """dependencies:
+      - pip
+      - pip:
+        - <library_name>
+        - ...
+    """,
+        "llama_index_and_scikit": """dependencies:
+      - pip
+      - pip:
+        - scikit-learn==1.6.1
+        - scikit-llm==1.4.1
+        - plotly==6.0.1
+        - altair==5.5.0
+        - PyMuPDF==1.25.1
+        - llama-index==0.12.24
+        - llama-index-readers-file==0.4.6
+        - llama-index-readers-web==0.3.8
+    """,
+        "data_product_hub": """dependencies:
+      - pip
+      - pip:
+        - PyMuPDF==1.25.1
+        - llama-index==0.12.24
+        - llama-index-readers-file==0.4.6
+        - llama-index-readers-web==0.3.8
+        - plotly==6.0.1
+        - altair==5.5.0
+        - dask==2025.2.0
+        - dph-services==0.4.0
+    """,
+        "watsonx_data": """dependencies:
+      - pip
+      - pip:
+        - prestodb
+        - PyMuPDF==1.25.1
+        - llama-index==0.12.24
+        - llama-index-readers-file==0.4.6
+        - llama-index-readers-web==0.3.8
+        - ibm-watsonxdata==0.4.0
+    """
+    }
+    return (yaml_templates,)
+
+
+@app.cell
+def _(mo, yaml_templates):
+    yaml_template = mo.ui.dropdown(yaml_templates, searchable=True, label="**Select a template:**", value="empty")
+    return (yaml_template,)
+
+
+@app.cell
+def _(tempfile):
+    def create_yaml_tempfile(yaml_editor_value):
+        """Creates temporary YAML file and returns its path"""
+        temp_file = tempfile.NamedTemporaryFile(suffix='.yaml', delete=False)
+
+        # Access the actual YAML content within the dictionary structure
+        if isinstance(yaml_editor_value, dict) and 'yml_editor' in yaml_editor_value:
+            # Extract the YAML content string from the yml_editor key
+            yaml_content = yaml_editor_value['yml_editor']
+        else:
+            # Use as is if it's already a string or has unexpected structure
+            yaml_content = yaml_editor_value
+
+        # Write the content to the file
+        with open(temp_file.name, 'w') as f:
+            f.write(str(yaml_content))
+
+        return temp_file.name
+    return (create_yaml_tempfile,)
+
+
+@app.cell
+def _(mo, yaml_template):
+    pkg_types = {"Conda Yaml":"conda_yml","Custom user library":"custom_library"}
+
+    package_meta = (
+        mo.md('''**Create your Conda YAML by editing the template:**
+
+        {yml_editor}
+
+        {package_name}
+
+        {package_description}
+
+        {software_spec_name}
+
+        {software_spec_description}
+        ''')
+        .batch(
+            yml_editor = mo.ui.code_editor(value=yaml_template.value, language="yaml", min_height=100, theme="dark"),
+            package_name = mo.ui.text(placeholder="Python Package for...", 
+                                      label="Package Extension Name:", 
+                                      kind="text", 
+                                      value="Custom Python Package"),
+            software_spec_name = mo.ui.text(placeholder="Software Spec Name", 
+                                            label="Custom Software Spec Name:", 
+                                            kind="text", value="Extended Python Function Software Spec"),
+            package_description = mo.ui.text_area(placeholder="Write a description for your package.",
+                                                  label="Package Description:", 
+                                                  value=" "),
+            software_spec_description = mo.ui.text_area(placeholder="Write a description for your software spec.", 
+                                                        label="Software Spec Description:", 
+                                                        value=" "),
+            package_type = mo.ui.dropdown(pkg_types, 
+                                          label="Select your package type:", 
+                                          value="Conda Yaml")
+        )
+        .form(show_clear_button=True, bordered=False)
+        )
+    return (package_meta,)
+
+
+@app.cell
+def _(mo):
+    check_packages =(mo.md('''
+        **Check if a package you want to use is in the base software_specification already:**
+
+        {package_list}
+
+        {return_full_list}
+        ''')
+        .batch(
+            package_list = mo.ui.text_area(placeholder="Add packages as a comma separated list (with or without versions)."),
+            return_full_list = mo.ui.checkbox(value=False, label="Return a full list of packages in the base software specification.")
+        )
+        .form(show_clear_button=True, bordered=False)
     )
+    return (check_packages,)
+
+
+@app.cell
+def _(check_packages):
+    if check_packages.value is not None:
+        packages = check_packages.value['package_list']
+        verification_list = [item.strip() for item in packages.split(',')]
+        full_list_return = check_packages.value['return_full_list']
+    else:
+        packages = None
+        verification_list = None
+        full_list_return = None
+    return full_list_return, verification_list
+
+
+@app.cell
+def _(
+    analyze_software_spec,
+    base_software_spec,
+    full_list_return,
+    verification_list,
+    visualize_software_spec,
+):
+    if verification_list is not None:
+        pkg_analysis = analyze_software_spec(base_software_spec, verification_list, return_full_sw_package_list=full_list_return)
+        package_df = visualize_software_spec(pkg_analysis, verification_list)
+    else:
+        pkg_analysis = None
+        package_df = None
+    return (package_df,)
+
+
+@app.cell
+def _(check_packages, mo, package_df):
+    package_analysis_stack = mo.vstack([check_packages, package_df], justify="center")
+    return (package_analysis_stack,)
+
+
+@app.cell
+def _(deployment_client):
+    if deployment_client is not None:
+        base_sw_spec_id = "45f12dfe-aa78-5b8d-9f38-0ee223c47309"
+        base_software_spec = deployment_client.software_specifications.get_details(base_sw_spec_id)
+    else:
+        base_sw_spec_id = None
+        base_software_spec = None
+    return base_software_spec, base_sw_spec_id
+
+
+@app.cell
+def _(create_yaml_tempfile, deployment_client, package_meta):
+    if package_meta.value is not None and deployment_client is not None:
+        pe_metadata = {
+            deployment_client.package_extensions.ConfigurationMetaNames.NAME: package_meta.value['package_name'],
+            deployment_client.package_extensions.ConfigurationMetaNames.TYPE: package_meta.value['package_type'],
+    deployment_client.software_specifications.ConfigurationMetaNames.DESCRIPTION:package_meta.value['package_description']
+        }
+        yaml_file_path = create_yaml_tempfile(package_meta.value['yml_editor'])
+    else:
+        pe_metadata = {
+        }
+        yaml_file_path = None
+
+    return pe_metadata, yaml_file_path
+
+
+@app.cell
+def _(
+    base_sw_spec_id,
+    deployment_client,
+    package_meta,
+    pe_metadata,
+    yaml_file_path,
+):
+    if yaml_file_path is not None:
+        ### Stores the package extension
+        pe_asset_details = deployment_client.package_extensions.store(
+            meta_props=pe_metadata,
+            file_path=yaml_file_path
+        )
+        package_id = pe_asset_details["metadata"]["asset_id"]
+        ### Creates a custom software specification based on the standard python function spec_id - "45f12dfe-aa78-5b8d-9f38-0ee223c47309"
+        ss_metadata = {
+            deployment_client.software_specifications.ConfigurationMetaNames.NAME: package_meta.value['software_spec_name'],
+            deployment_client.software_specifications.ConfigurationMetaNames.DESCRIPTION: package_meta.value['software_spec_description'],
+            deployment_client.software_specifications.ConfigurationMetaNames.BASE_SOFTWARE_SPECIFICATION: {'guid': base_sw_spec_id},
+            deployment_client.software_specifications.ConfigurationMetaNames.PACKAGE_EXTENSIONS: [{'guid': package_id}]
+        }
+        ss_asset_details = deployment_client.software_specifications.store(meta_props=ss_metadata)
+    else:
+        pe_asset_details = None
+        package_id = None
+        ss_metadata = {}
+        ss_asset_details = None
+
+    # ss_asset_details
+    return (ss_asset_details,)
 
 
 @app.cell
@@ -538,29 +897,23 @@ def _(deployment_client, mo, pd):
             initial_selection=[0]
         )
 
-    return (
-        framework_mapping,
-        preferred_order,
-        sel_df,
-        selection_table,
-        supported_specs,
-    )
+    return (selection_table,)
 
 
 @app.cell
 def _(mo):
     input_schema_checkbox = mo.ui.checkbox(label="Add input schema (optional)")
     output_schema_checkbox = mo.ui.checkbox(label="Add output schema (optional)")
-    sample_input_checkbox = mo.ui.checkbox(label="Add sample input example (optional)")
-    return input_schema_checkbox, output_schema_checkbox, sample_input_checkbox
+    # sample_input_checkbox = mo.ui.checkbox(label="Add sample input example (optional)")
+    return input_schema_checkbox, output_schema_checkbox
 
 
 @app.cell
 def _(
+    function_name,
     input_schema_checkbox,
     mo,
     output_schema_checkbox,
-    sample_input_checkbox,
     selection_table,
     template_variant,
 ):
@@ -604,7 +957,7 @@ def _(
         schema_metadata=mo.hstack([
             input_schema_checkbox,
             output_schema_checkbox,
-            sample_input_checkbox
+            # sample_input_checkbox
         ],
             justify="center", gap=1, align="center", wrap=True
         )
@@ -625,10 +978,7 @@ def _(
     return (
         description_input,
         fm,
-        fnc_nm,
-        func_metadata,
         sc_m,
-        schema_metadata,
         software_spec,
         tags_editor,
         uploaded_function_name,
@@ -638,7 +988,7 @@ def _(
 @app.cell
 def _(json, mo, template_variant):
     if template_variant.value == "Stream Files to IBM COS [Example]":
-        from cos_stream_schema_examples import input_schema, output_schema, sample_input
+        from cos_stream_schema_examples import input_schema, output_schema
     else:
         input_schema = [
             {
@@ -676,40 +1026,20 @@ def _(json, mo, template_variant):
             }
         ]
 
-        sample_input = {
-            'input_data': [
-                {
-                    'fields': ['<variable name 1>', '<variable name 2>'],
-                    'values': [
-                        ['<sample input value for variable 1>', '<sample input value for variable 2>']
-                    ]
-                }
-            ]
-        }
 
 
-    input_schema_editor = mo.ui.code_editor(value=json.dumps(input_schema, indent=4), language="python", min_height=25)
-    output_schema_editor = mo.ui.code_editor(value=json.dumps(output_schema, indent=4), language="python", min_height=25)
-    sample_input_editor = mo.ui.code_editor(value=json.dumps(sample_input, indent=4), language="python", min_height=25)
+    input_schema_editor = mo.ui.code_editor(value=json.dumps(input_schema, indent=4), language="python", min_height=100,theme="dark")
+    output_schema_editor = mo.ui.code_editor(value=json.dumps(output_schema, indent=4), language="python", min_height=100,theme="dark")
 
     schema_editors = mo.accordion(
         {
             """**Input Schema Metadata Editor**""": input_schema_editor,
             """**Output Schema Metadata Editor**""": output_schema_editor,
-            """**Sample Input Metadata Editor**""": sample_input_editor
         }, multiple=True
     )
 
     # schema_editors
-    return (
-        input_schema,
-        input_schema_editor,
-        output_schema,
-        output_schema_editor,
-        sample_input,
-        sample_input_editor,
-        schema_editors,
-    )
+    return input_schema_editor, output_schema_editor, schema_editors
 
 
 @app.cell
@@ -725,8 +1055,6 @@ def _(
     os,
     output_schema_checkbox,
     output_schema_editor,
-    sample_input_checkbox,
-    sample_input_editor,
     selection_table,
     software_spec,
     tags_editor,
@@ -771,12 +1099,12 @@ def _(
                 function_meta[deployment_client.repository.FunctionMetaNames.OUTPUT_DATA_SCHEMAS] = ast.literal_eval(output_schema_editor.value)
 
         # Add sample input if checkbox is checked
-        if sample_input_checkbox.value:
-            try:
-                function_meta[deployment_client.repository.FunctionMetaNames.SAMPLE_SCORING_INPUT] = json.loads(sample_input_editor.value)
-            except json.JSONDecodeError:
-                # If JSON parsing fails, try Python literal evaluation as fallback
-                function_meta[deployment_client.repository.FunctionMetaNames.SAMPLE_SCORING_INPUT] = ast.literal_eval(sample_input_editor.value)
+        # if sample_input_checkbox.value:
+        #     try:
+        #         function_meta[deployment_client.repository.FunctionMetaNames.SAMPLE_SCORING_INPUT] = json.loads(sample_input_editor.value)
+        #     except json.JSONDecodeError:
+        #         # If JSON parsing fails, try Python literal evaluation as fallback
+        #         function_meta[deployment_client.repository.FunctionMetaNames.SAMPLE_SCORING_INPUT] = ast.literal_eval(sample_input_editor.value)
 
     def upload_function(function_meta, use_function_object=False):
         """
@@ -830,7 +1158,7 @@ def _(
                 # # Upload using the absolute file path
                 # abs_file_path = os.path.abspath(file_path)
                 # mo.md(f"Uploading function from file: {abs_file_path}")
-    
+
                 # # Using the absolute file path might help in some environments
                 # func_details = deployment_client.repository.store_function(abs_file_path, function_meta)
                 # Upload using the file path approach
@@ -838,15 +1166,15 @@ def _(
                 # Create a zip file of the Python module
                 import gzip
                 import shutil
-                
+
                 # Path for the gzipped file
                 gz_path = f"{save_dir}/{func_name}.py.gz"
-                
+
                 # Create gzip file
                 with open(file_path, 'rb') as f_in:
                     with gzip.open(gz_path, 'wb') as f_out:
                         shutil.copyfileobj(f_in, f_out)
-                
+
                 # Upload using the gzipped file path
                 mo.md(f"Uploading function from gzip: {gz_path}")
                 func_details = deployment_client.repository.store_function(gz_path, function_meta)
@@ -874,15 +1202,7 @@ def _(
     )
 
     # function_meta
-    return (
-        filtered_tags,
-        function_meta,
-        get_upload_status,
-        set_upload_status,
-        upload_button,
-        upload_function,
-        upload_status,
-    )
+    return get_upload_status, upload_button
 
 
 @app.cell
@@ -899,7 +1219,7 @@ def _(get_upload_status, mo, upload_button):
         upload_button,
         mo.md(f"**Status:** {get_upload_status()}")
     ], justify="space-around", align="center")
-    return artifact_id, upload_func, upload_result
+    return artifact_id, upload_func
 
 
 @app.cell
@@ -982,16 +1302,7 @@ def _(deployment_client, mo, pd, upload_button, uuid):
             initial_selection=[0]
         )
 
-    return (
-        deployment_name,
-        deployment_type,
-        hardware_specs,
-        hardware_specs_df,
-        hw_df,
-        hw_selection_table,
-        reorder_hardware_specifications,
-        uuid_suffix,
-    )
+    return deployment_name, deployment_type, hw_selection_table
 
 
 @app.cell
@@ -1003,7 +1314,6 @@ def _(
     deployment_type,
     hw_selection_table,
     mo,
-    print,
     upload_button,
 ):
     def deploy_function(artifact_id, deployment_type):
@@ -1082,15 +1392,7 @@ def _(
         ], justify="space-around")
 
     # deployment_definition
-    return (
-        deploy_button,
-        deploy_function,
-        deployment_definition,
-        deployment_status,
-        get_deployment_id,
-        get_deployment_info,
-        selected_hw_config,
-    )
+    return deploy_button, deployment_definition
 
 
 @app.cell
@@ -1106,7 +1408,7 @@ def _(deploy_button, deployment_definition, mo):
 
 
 @app.cell(hide_code=True)
-def _(deployment_client, mo):
+def _(deployment_client, mo, pd):
     ### Functions to List , Get ID's as a list and Purge of Assets
 
     def get_deployment_list():
@@ -1141,7 +1443,7 @@ def _(deployment_client, mo):
         return repository_list
 
     #----
-    
+
     def delete_with_progress(ids_list, delete_function, item_type="items"):
         """
         Generic wrapper that adds a progress bar to any deletion function
@@ -1188,7 +1490,6 @@ def _(deployment_client, mo):
         delete_data_assets,
         delete_deployments,
         delete_repository_items,
-        delete_with_progress,
         get_data_asset_ids,
         get_data_assets_list,
         get_deployment_ids,
@@ -1197,6 +1498,7 @@ def _(deployment_client, mo):
         get_repository_list,
     )
 
+
 @app.cell
 def _(get_data_assets_tab, get_deployments_tab, get_repository_tab, mo):
     if get_deployments_tab() is not None:
@@ -1213,47 +1515,54 @@ def _(get_data_assets_tab, get_deployments_tab, get_repository_tab, mo):
         data_assets_table = mo.ui.table(get_data_assets_tab())
     else:
         data_assets_table = mo.md("No Table Loaded")
-        
+
     return data_assets_table, deployments_table, repository_table
 
+
 @app.cell
-def _(get_deployment_id_list, get_deployments_button, mo, purge_deployments):
+def _(
+    deployments_table,
+    get_deployment_id_list,
+    get_deployments_button,
+    mo,
+    purge_deployments,
+):
     deployments_purge_stack = mo.hstack([get_deployments_button, get_deployment_id_list, purge_deployments])
     deployments_purge_stack_results = mo.vstack([deployments_table, get_deployment_id_list.value, purge_deployments.value])
 
     deployments_purge_tab = mo.vstack([deployments_purge_stack, deployments_purge_stack_results])
-    return (
-        deployments_purge_stack,
-        deployments_purge_stack_results,
-        deployments_purge_tab,
-    )
+    return (deployments_purge_tab,)
 
 
 @app.cell
-def _(get_repository_button, get_repository_id_list, mo, purge_repository):
+def _(
+    get_repository_button,
+    get_repository_id_list,
+    mo,
+    purge_repository,
+    repository_table,
+):
     repository_purge_stack = mo.hstack([get_repository_button, get_repository_id_list, purge_repository])
 
     repository_purge_stack_results = mo.vstack([repository_table, get_repository_id_list.value, purge_repository.value])
 
     repository_purge_tab = mo.vstack([repository_purge_stack, repository_purge_stack_results])
-    return (
-        repository_purge_stack,
-        repository_purge_stack_results,
-        repository_purge_tab,
-    )
+    return (repository_purge_tab,)
 
 
 @app.cell
-def _(get_data_asset_id_list, get_data_assets_button, mo, purge_data_assets):
+def _(
+    data_assets_table,
+    get_data_asset_id_list,
+    get_data_assets_button,
+    mo,
+    purge_data_assets,
+):
     data_assets_purge_stack = mo.hstack([get_data_assets_button, get_data_asset_id_list, purge_data_assets])
     data_assets_purge_stack_results = mo.vstack([data_assets_table, get_data_asset_id_list.value, purge_data_assets.value])
 
     data_assets_purge_tab = mo.vstack([data_assets_purge_stack, data_assets_purge_stack_results])
-    return (
-        data_assets_purge_stack,
-        data_assets_purge_stack_results,
-        data_assets_purge_tab,
-    )
+    return (data_assets_purge_tab,)
 
 
 @app.cell
@@ -1262,9 +1571,9 @@ def _(data_assets_purge_tab, deployments_purge_tab, mo, repository_purge_tab):
         {"Purge Deployments": deployments_purge_tab, "Purge Repository Assets": repository_purge_tab,"Purge Data Assets": data_assets_purge_tab }, lazy=False
     )
 
-    # asset_purge
     return (purge_tabs,)
 
+
 @app.cell
 def _(mo):
     get_deployments_tab, set_deployments_tab = mo.state(None)