Update main_app.py

main_app.py

@@ -19,7 +19,10 @@ with app.setup:
     from ibm_watsonx_ai import APIClient, Credentials
     from ibmcloudant.cloudant_v1 import CloudantV1, Document
     from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
-    from cloudant_helper_functions import cloudant_retrieve_documents, ensure_database_exists
+    from cloudant_helper_functions import (
+        cloudant_retrieve_documents,
+        ensure_database_exists,
+    )
     import marimo as mo
     import pandas as pd
     import requests
@@ -28,41 +31,42 @@ with app.setup:
     load_dotenv()
 
 
-
 @app.function
 def get_markdown_content(file_path):
-    with open(file_path, 'r', encoding='utf-8') as file:
+    with open(file_path, "r", encoding="utf-8") as file:
         content = file.read()
     return content
 
 
 @app.cell
 def _(mo, get_markdown_content):
-    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')
-    intro_comparison = get_markdown_content('intro_markdown/intro_comparison.md')
-    
-    intro = mo.carousel([
-        mo.md(f"{intro_text}"),
-        mo.md(f"{intro_marimo}"),
-        mo.md(f"{intro_notebook}"),
-        mo.md(f"{intro_comparison}"),
-    ])
-    
-    mo.accordion({"## Notebook Introduction":intro})
+    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")
+    intro_comparison = get_markdown_content("intro_markdown/intro_comparison.md")
+
+    intro = mo.carousel(
+        [
+            mo.md(f"{intro_text}"),
+            mo.md(f"{intro_marimo}"),
+            mo.md(f"{intro_notebook}"),
+            mo.md(f"{intro_comparison}"),
+        ]
+    )
+
+    mo.accordion({"## Notebook Introduction": intro})
 
 
 @app.cell
 def _(os):
     # Set explicit temporary directory
-    os.environ['TMPDIR'] = '/tmp/notebook_functions'
+    os.environ["TMPDIR"] = "/tmp/notebook_functions"
 
     # Create the directory if it doesn't exist
-    os.makedirs('/tmp/notebook_functions', exist_ok=True)
+    os.makedirs("/tmp/notebook_functions", exist_ok=True)
 
     # Make sure Python's tempfile module also uses this directory
-    tempfile.tempdir = '/tmp/notebook_functions'
+    tempfile.tempdir = "/tmp/notebook_functions"
 
     def setup_task_credentials(client):
         # Get existing task credentials
@@ -114,6 +118,7 @@ def _(client_instantiation_form, os):
         wx_url = None
     return client_setup, project_id, space_id, wx_api_key, wx_url
 
+
 @app.cell
 def _(mo):
     ### Credentials for the watsonx.ai SDK client
@@ -126,12 +131,13 @@ def _(mo):
         "GB": "https://eu-gb.ml.cloud.ibm.com",
         "JP": "https://jp-tok.ml.cloud.ibm.com",
         "AU": "https://au-syd.ml.cloud.ibm.com",
-        "CA": "https://ca-tor.ml.cloud.ibm.com"
+        "CA": "https://ca-tor.ml.cloud.ibm.com",
     }
 
     # Create a form with multiple elements
     client_instantiation_form = (
-        mo.md('''
+        mo.md(
+            """
         ###**watsonx.ai credentials:**
 
         {wx_region}
@@ -139,13 +145,32 @@ def _(mo):
         {wx_api_key}
 
         {space_id}
-    ''').style(max_height="300px", overflow="auto", border_color="blue")
+    """
+        )
+        .style(max_height="300px", overflow="auto", border_color="blue")
         .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"),
-            space_id = mo.ui.text(placeholder="Add your watsonx.ai space_id...", label="Space_ID:", kind="text")
-        ,)
+            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",
+            ),
+            space_id=mo.ui.text(
+                placeholder="Add your watsonx.ai space_id...",
+                label="Space_ID:",
+                kind="text",
+            ),
+        )
         .form(show_clear_button=True, bordered=False)
     )
 
@@ -165,13 +190,12 @@ def _(
 ):
     ### Instantiate the watsonx.ai client
     if client_setup:
-        wx_credentials = Credentials(
-            url=wx_url,
-            api_key=wx_api_key
-        )
+        wx_credentials = Credentials(url=wx_url, api_key=wx_api_key)
 
         if project_id:
-            project_client = APIClient(credentials=wx_credentials, project_id=project_id)
+            project_client = APIClient(
+                credentials=wx_credentials, project_id=project_id
+            )
         else:
             project_client = None
 
@@ -190,7 +214,6 @@ def _(
             task_credentials_details = setup_task_credentials(project_client)
         else:
             task_credentials_details = None
-            
 
     else:
         wx_credentials = None
@@ -224,6 +247,7 @@ def _():
     os.environ["REQUESTS_CA_BUNDLE"] = certifi.where()
     return (cloudant,)
 
+
 @app.cell
 def _(cloudant, cloudant_db):
     variant_selectors = cloudant_retrieve_documents(
@@ -233,20 +257,76 @@ def _(cloudant, cloudant_db):
         fields=["category"],
     )
 
-    variant_selectors_list = [
-        item["category"] for item in variant_selectors["docs"]
-    ]
-    # variant_selectors_list
-    return (variant_selectors_list,)
+    variant_selectors_list = [item["category"] for item in variant_selectors["docs"]]
+    return variant_selectors_list
+
 
 @app.cell
-def _(mo):
+def _(mo, variant_selectors_list):
     template_variants = variant_selectors_list
-    template_variant = mo.ui.dropdown(template_variants, label="Code Template:", value="Base")
+    template_variant = mo.ui.dropdown(
+        template_variants, label="Code Template:", value=template_variants[0]
+    )
     return (template_variant,)
 
+
 @app.cell
 def _(cloudant, cloudant_db, template_variant):
+    fallback_template = {
+        "function_name": "deployable_function",
+        "function_code": """def your_function_name():
+        import subprocess
+        subprocess.check_output('pip install gensim', shell=True)
+        import gensim
+        def score(input_data):
+            message_from_input_payload = payload.get("input_data")[0].get("values")[0][0]
+            response_message = "Received message - {0}".format(message_from_input_payload)
+            # Score using the pre-defined model
+            score_response = {
+                'predictions': [{'fields': ['Response_message_field', 'installed_lib_version'],
+                                'values': [[response_message, gensim.__version__]]
+                                }]
+            }
+            return score_response
+        return score
+    score = your_function_name()""",
+        "use_cases": ["add_tags"],
+        "input_schema": [
+            {
+                "id": "1",
+                "type": "struct",
+                "fields": [
+                    {
+                        "name": "<variable name 1>",
+                        "type": "string",
+                        "nullable": False,
+                        "metadata": {},
+                    },
+                    {
+                        "name": "<variable name 2>",
+                        "type": "string",
+                        "nullable": False,
+                        "metadata": {},
+                    },
+                ],
+            }
+        ],
+        "output_schema": [
+            {
+                "id": "1",
+                "type": "struct",
+                "fields": [
+                    {
+                        "name": "<output return name>",
+                        "type": "string",
+                        "nullable": False,
+                        "metadata": {},
+                    }
+                ],
+            }
+        ],
+        "dependencies": ["<library_to_add>"],
+    }
     retrieved_template = (
         cloudant_retrieve_documents(
             client=cloudant,
@@ -257,19 +337,27 @@ def _(cloudant, cloudant_db, template_variant):
         if template_variant.value
         else None
     )
-    template = retrieved_template["docs"][0] if retrieved_template else None
+    template = (
+        retrieved_template["docs"][0] if retrieved_template else fallback_template
+    )
     return (template,)
 
+
 @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")
+    client_stack = mo.hstack(
+        [client_instantiation_form, client_callout],
+        align="center",
+        justify="space-around",
+    )
     return (client_stack,)
 
 
 @app.cell
 def _(client_stack, mo):
-    client_section = mo.md(f'''
+    client_section = mo.md(
+        f"""
         ###**Instantiate your watsonx.ai client:**
 
         1. Select a region from the dropdown menu
@@ -284,7 +372,8 @@ def _(client_stack, mo):
 
         {client_stack}
 
-    ''')
+    """
+    )
     return (client_section,)
 
 
@@ -293,9 +382,11 @@ def _(mo, sc_m, schema_editors):
     sc_tabs = mo.ui.tabs(
         {
             "Schema Option Selection": sc_m,
-            "Schema Definition": mo.md(f"""
+            "Schema Definition": mo.md(
+                f"""
             ####**Edit the schema definitions you selected in the previous tab.**<br>
-                                       {schema_editors}"""),
+                                        {schema_editors}"""
+            ),
         }
     )
     return (sc_tabs,)
@@ -303,7 +394,8 @@ def _(mo, sc_m, schema_editors):
 
 @app.cell
 def _(fm, function_editor, mo, sc_tabs):
-    function_section = 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>
@@ -340,13 +432,15 @@ def _(fm, function_editor, mo, sc_tabs):
 
         {fm}
 
-    ''')
+    """
+    )
     return (function_section,)
 
 
 @app.cell
 def _(mo, selection_table, upload_func):
-    upload_section = mo.md(f'''
+    upload_section = mo.md(
+        f"""
         ###**Review and Upload your function**
 
         1. Review the function metadata specs JSON
@@ -365,13 +459,15 @@ def _(mo, selection_table, upload_func):
 
         {upload_func}
 
-    ''')
+    """
+    )
     return (upload_section,)
 
 
 @app.cell
 def _(deploy_fnc, deployment_definition, hw_selection_table, mo):
-    deployment_section = 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
@@ -402,13 +498,15 @@ def _(deploy_fnc, deployment_definition, hw_selection_table, mo):
 
         {deploy_fnc}
 
-    ''')
+    """
+    )
     return (deployment_section,)
 
 
 @app.cell
 def _(mo, purge_tabs):
-    purging_section = 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.
@@ -419,7 +517,8 @@ def _(mo, purge_tabs):
 
         {purge_tabs}
 
-    ''')
+    """
+    )
 
     return (purging_section,)
 
@@ -433,7 +532,8 @@ def _(
     ss_asset_response,
     yaml_template,
 ):
-    packages_section = mo.md(f'''
+    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.
@@ -464,7 +564,8 @@ def _(
     ```json
     {json.dumps(ss_asset_response, indent=2)}
     ```
-    ''')
+    """
+    )
     return (packages_section,)
 
 
@@ -472,7 +573,7 @@ def _(
 def _(client_section, mo):
     ui_accordion_section_1 = mo.accordion(
         {"Section 1: **watsonx.ai Credentials**": client_section}
-    ) 
+    )
     ui_accordion_section_1
     return
 
@@ -481,7 +582,7 @@ def _(client_section, mo):
 def _(function_section, mo):
     ui_accordion_section_2 = mo.accordion(
         {"Section 2: **Function Creation**": function_section}
-    ) 
+    )
     ui_accordion_section_2
     return
 
@@ -490,7 +591,7 @@ def _(function_section, mo):
 def _(mo, packages_section):
     ui_accordion_section_3 = mo.accordion(
         {"Section 3: **Create a Package Extension (Optional)**": packages_section}
-    ) 
+    )
     ui_accordion_section_3
     return
 
@@ -499,7 +600,7 @@ def _(mo, packages_section):
 def _(mo, upload_section):
     ui_accordion_section_4 = mo.accordion(
         {"Section 4: **Function Upload**": upload_section}
-    ) 
+    )
     ui_accordion_section_4
     return
 
@@ -508,7 +609,7 @@ def _(mo, upload_section):
 def _(deployment_section, mo):
     ui_accordion_section_5 = mo.accordion(
         {"Section 5: **Function Deployment**": deployment_section}
-    ) 
+    )
     ui_accordion_section_5
     return
 
@@ -517,25 +618,32 @@ def _(deployment_section, mo):
 def _(mo, purging_section):
     ui_accordion_section_6 = mo.accordion(
         {"Section 6: **Helper Functions**": purging_section}
-    ) 
+    )
     ui_accordion_section_6
     return
 
 
 @app.cell
-def _(mo, template_variant):
+def _(mo, template, template_variant):
     function_editor = (
-        mo.md('''
+        mo.md(
+            """
         #### **Create your function by editing the template:**
 
         {editor}
 
-        ''')
+        """
+        )
         .batch(
-            editor = mo.ui.code_editor(value=template["function_code"], language="python", min_height=200, theme="dark")
+            editor=mo.ui.code_editor(
+                value=template["function_code"],
+                language="python",
+                min_height=200,
+                theme="dark",
+            )
         )
         .form(show_clear_button=True, bordered=False)
-        )
+    )
 
     # function_editor
     return (function_editor,)
@@ -546,7 +654,7 @@ def _(ast, function_editor, mo, os):
     function_name = None
     if function_editor.value:
         # Get the edited code from the function editor
-        code = function_editor.value['editor']
+        code = function_editor.value["editor"]
         # Extract function name using AST without executing the code
 
         try:
@@ -577,14 +685,14 @@ def _(ast, function_editor, mo, os):
 
 
 @app.cell
-def _():
+def _(template):
     dependencies = template["dependencies"]
     yaml_template = f"""dependencies:
           - pip
           - pip:
     {'\n'.join(f'        - {dep}' for dep in dependencies)}
     """
-    
+
     yaml_templates = {
         "empty": """dependencies:
       - pip
@@ -597,12 +705,17 @@ def _():
     dependency_pack_name = template["function_name"] + "_dependencies"
     # After the yaml_template definition, add:
     yaml_templates[dependency_pack_name] = yaml_template
-    return (yaml_templates,)
+    return (yaml_templates, dependency_pack_name)
 
 
 @app.cell
-def _(mo, yaml_templates):
-    yaml_template = mo.ui.dropdown(yaml_templates, searchable=True, label="**Select a template:**", value=dependency_pack_name)
+def _(mo, yaml_templates, dependency_pack_name):
+    yaml_template = mo.ui.dropdown(
+        yaml_templates,
+        searchable=True,
+        label="**Select a template:**",
+        value=dependency_pack_name,
+    )
     return (yaml_template,)
 
 
@@ -610,19 +723,21 @@ def _(mo, yaml_templates):
 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)
-        with open(temp_file.name, 'w') as f:
+        temp_file = tempfile.NamedTemporaryFile(suffix=".yaml", delete=False)
+        with open(temp_file.name, "w") as f:
             f.write(str(yaml_editor_value))
         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"}
+def _(mo, yaml_template, dependency_pack_name):
+    pkg_types = {"Conda Yaml": "conda_yml", "Custom user library": "custom_library"}
 
     package_meta = (
-        mo.md('''**Create your Conda YAML by editing the template:**
+        mo.md(
+            """**Create your Conda YAML by editing the template:**
 
         {yml_editor}
 
@@ -633,43 +748,63 @@ def _(mo, yaml_template):
         {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=f"Custom Python Package: {dependency_pack_name}"),
-            software_spec_name = mo.ui.text(placeholder="Software Spec Name", 
-                                            label="Custom Software Spec Name:", 
-                                            kind="text", value=f"Extended Python Function Software Spec - {dependency_pack_name}"),
-            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")
+            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=f"Custom Python Package: {dependency_pack_name}",
+            ),
+            software_spec_name=mo.ui.text(
+                placeholder="Software Spec Name",
+                label="Custom Software Spec Name:",
+                kind="text",
+                value=f"Extended Python Function Software Spec - {dependency_pack_name}",
+            ),
+            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_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.")
+            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)
     )
@@ -679,9 +814,9 @@ def _(mo):
 @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']
+        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
@@ -698,7 +833,11 @@ def _(
     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)
+        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
@@ -727,16 +866,19 @@ def _(client):
 def _(client, create_yaml_tempfile, package_meta, uuid):
     if package_meta.value is not None and client is not None:
         pack_suffix = str(uuid.uuid4())[:4]
-        pack_name = package_meta.value['package_name']
+        pack_name = package_meta.value["package_name"]
         pe_metadata = {
             client.package_extensions.ConfigurationMetaNames.NAME: f"{pack_name}_{pack_suffix}",
-            client.package_extensions.ConfigurationMetaNames.TYPE: package_meta.value['package_type'],
-    client.software_specifications.ConfigurationMetaNames.DESCRIPTION:package_meta.value['package_description']
+            client.package_extensions.ConfigurationMetaNames.TYPE: package_meta.value[
+                "package_type"
+            ],
+            client.software_specifications.ConfigurationMetaNames.DESCRIPTION: package_meta.value[
+                "package_description"
+            ],
         }
-        yaml_file_path = create_yaml_tempfile(package_meta.value['yml_editor'])
+        yaml_file_path = create_yaml_tempfile(package_meta.value["yml_editor"])
     else:
-        pe_metadata = {
-        }
+        pe_metadata = {}
         yaml_file_path = None
 
     return pe_metadata, yaml_file_path
@@ -747,8 +889,7 @@ def _(client, pe_metadata, yaml_file_path):
     if yaml_file_path is not None:
         ### Stores the package extension
         pe_asset_details = client.package_extensions.store(
-            meta_props=pe_metadata,
-            file_path=yaml_file_path
+            meta_props=pe_metadata, file_path=yaml_file_path
         )
         package_id = pe_asset_details["metadata"]["asset_id"]
     else:
@@ -760,7 +901,9 @@ def _(client, pe_metadata, yaml_file_path):
 @app.cell
 def _():
     ### Helper function for checking if a python library is in the standard software spec.
-    def analyze_software_spec(sw_spec_response, required_libraries, return_full_sw_package_list=False):
+    def analyze_software_spec(
+        sw_spec_response, required_libraries, return_full_sw_package_list=False
+    ):
         """
         Analyzes a software specification against a list of required libraries.
 
@@ -776,18 +919,16 @@ def _():
                 - present: Dict of libraries that are present with matching versions
                 - sw_packages: (Optional) Complete dict of all packages in the software spec
         """
-        result = {
-            "present": {},
-            "not_present": {},
-            "version_mismatch": {}
-        }
+        result = {"present": {}, "not_present": {}, "version_mismatch": {}}
 
         # Extract all packages from the software specification
         sw_packages = {}
 
         try:
             # Extract packages from included_packages in the software specification
-            included_packages = sw_spec_response["entity"]["software_specification"]["software_configuration"]["included_packages"]
+            included_packages = sw_spec_response["entity"]["software_specification"][
+                "software_configuration"
+            ]["included_packages"]
 
             # Create a dictionary of all packages in the software specification
             for package in included_packages:
@@ -812,14 +953,20 @@ def _():
                 result["not_present"][lib_name] = None
             elif lib_version is not None and lib_version != sw_packages[lib_name]:
                 # Check version mismatch
-                result["version_mismatch"][lib_name] = [sw_packages[lib_name], lib_version]
+                result["version_mismatch"][lib_name] = [
+                    sw_packages[lib_name],
+                    lib_version,
+                ]
             else:
                 # Library is present with matching version (or no specific version required)
                 result["present"][lib_name] = sw_packages[lib_name]
 
         if return_full_sw_package_list:
             # Extract just the library names from required_libraries
-            req_libs_names = [lib.split("==")[0].strip() if "==" in lib else lib.strip() for lib in required_libraries]
+            req_libs_names = [
+                lib.split("==")[0].strip() if "==" in lib else lib.strip()
+                for lib in required_libraries
+            ]
 
             def sort_key(pkg_name):
                 if pkg_name in result["not_present"]:
@@ -832,13 +979,14 @@ def _():
                     return (3, pkg_name)  # All other packages last
 
             # Sort sw_packages using the custom sorting key
-            result["sw_packages"] = {k: sw_packages[k] for k in sorted(sw_packages.keys(), key=sort_key)}
+            result["sw_packages"] = {
+                k: sw_packages[k] for k in sorted(sw_packages.keys(), key=sort_key)
+            }
 
             # Add missing packages to the top of sw_packages
             for pkg in result["not_present"]:
                 result["sw_packages"] = {pkg: None, **result["sw_packages"]}
 
-
         return result
 
     def visualize_software_spec(analysis_result, required_libraries=None):
@@ -893,23 +1041,31 @@ def _():
                     status = "Other"
                     priority = 3  # Lowest priority
 
-                rows.append({
-                    "Package": package,
-                    "Version": version if version is not None else "Not Present",
-                    "Status": status,
-                    "_priority": priority  # Temporary field for sorting
-                })
+                rows.append(
+                    {
+                        "Package": package,
+                        "Version": version if version is not None else "Not Present",
+                        "Status": status,
+                        "_priority": priority,  # Temporary field for sorting
+                    }
+                )
 
             df = pd.DataFrame(rows)
 
             # Sort by priority and then package name
-            df = df.sort_values(by=["_priority", "Package"]).drop("_priority", axis=1).reset_index(drop=True)
+            df = (
+                df.sort_values(by=["_priority", "Package"])
+                .drop("_priority", axis=1)
+                .reset_index(drop=True)
+            )
 
         else:
             # Only use the packages mentioned in required_libraries
-            packages = set(list(analysis_result.get("not_present", {}).keys()) + 
-                          list(analysis_result.get("version_mismatch", {}).keys()) + 
-                          list(analysis_result.get("present", {}).keys()))
+            packages = set(
+                list(analysis_result.get("not_present", {}).keys())
+                + list(analysis_result.get("version_mismatch", {}).keys())
+                + list(analysis_result.get("present", {}).keys())
+            )
 
             # Create dataframe rows
             rows = []
@@ -919,7 +1075,9 @@ def _():
                     status = "❌ Missing"
                     priority = 0  # Top priority
                 elif package in analysis_result.get("version_mismatch", {}):
-                    version = analysis_result["version_mismatch"][package][0]  # sw_spec version
+                    version = analysis_result["version_mismatch"][package][
+                        0
+                    ]  # sw_spec version
                     status = "⚠️ Version Mismatch"
                     priority = 1  # Second priority
                 else:
@@ -927,37 +1085,57 @@ def _():
                     status = "✅ Present"
                     priority = 2  # Third priority
 
-                rows.append({
-                    "Package": package, 
-                    "Version": version, 
-                    "Status": status,
-                    "_priority": priority  # Temporary field for sorting
-                })
+                rows.append(
+                    {
+                        "Package": package,
+                        "Version": version,
+                        "Status": status,
+                        "_priority": priority,  # Temporary field for sorting
+                    }
+                )
 
             df = pd.DataFrame(rows)
 
             # Sort by priority and then package name
-            df = df.sort_values(by=["_priority", "Package"]).drop("_priority", axis=1).reset_index(drop=True)
+            df = (
+                df.sort_values(by=["_priority", "Package"])
+                .drop("_priority", axis=1)
+                .reset_index(drop=True)
+            )
 
         return df
+
     return analyze_software_spec, visualize_software_spec
 
 
 @app.cell
-def _(base_sw_spec_id, client, package_id, package_meta, uuid):
+def _(
+    base_sw_spec_id,
+    client,
+    get_selection_table_status,
+    set_selection_table_status,
+    package_id,
+    package_meta,
+    uuid,
+):
     if package_id is not None:
         ### Creates a custom software specification based on the standard python function spec_id - "45f12dfe-aa78-5b8d-9f38-0ee223c47309"
         ss_suffix = str(uuid.uuid4())[:4]
-        ss_name = package_meta.value['software_spec_name']
+        ss_name = package_meta.value["software_spec_name"]
 
         ss_metadata = {
             client.software_specifications.ConfigurationMetaNames.NAME: f"{ss_name}_{ss_suffix}",
-            client.software_specifications.ConfigurationMetaNames.DESCRIPTION: package_meta.value['software_spec_description'],
-            client.software_specifications.ConfigurationMetaNames.BASE_SOFTWARE_SPECIFICATION: {'guid': base_sw_spec_id},
-            client.software_specifications.ConfigurationMetaNames.PACKAGE_EXTENSIONS: [{'guid': package_id}]
+            client.software_specifications.ConfigurationMetaNames.DESCRIPTION: package_meta.value[
+                "software_spec_description"
+            ],
+            client.software_specifications.ConfigurationMetaNames.BASE_SOFTWARE_SPECIFICATION: {
+                "guid": base_sw_spec_id
+            },
+            client.software_specifications.ConfigurationMetaNames.PACKAGE_EXTENSIONS: [
+                {"guid": package_id}
+            ],
         }
 
-
         ss_asset_details = client.software_specifications.store(meta_props=ss_metadata)
 
         current_status = get_selection_table_status()
@@ -983,8 +1161,9 @@ def _(mo):
     get_selection_table_status, set_selection_table_status = mo.state(None)
     return get_selection_table_status, set_selection_table_status
 
+
 @app.cell
-def _(mo, client):
+def _(mo, client, get_selection_table_status):
     if client:
         # First, get all specs data once
         specs_df = client.software_specifications.list()
@@ -1002,13 +1181,15 @@ def _(client, mo, pd, specs_df):
     if client:
         # Filter the specs into two groups
         base_specs = specs_df[
-            (specs_df['STATE'] == 'supported') & 
-            (specs_df['NAME'].isin(['runtime-24.1-py3.11', 'runtime-24.1-py3.11-cuda']))
+            (specs_df["STATE"] == "supported")
+            & (
+                specs_df["NAME"].isin(
+                    ["runtime-24.1-py3.11", "runtime-24.1-py3.11-cuda"]
+                )
+            )
         ]
 
-        derived_specs = specs_df[
-            (specs_df['TYPE'] == 'derived')
-        ]
+        derived_specs = specs_df[(specs_df["TYPE"] == "derived")]
 
         # Concatenate with base specs first, then derived specs
         supported_specs = pd.concat([base_specs, derived_specs]).reset_index(drop=True)
@@ -1024,7 +1205,7 @@ def _(client, mo, pd, specs_df):
             "runtime-24.1-py3.11-cuda": "CUDA-enabled (GPU) Python Runtime",
             "runtime-24.1-r4.3": "R Runtime 4.3",
             "spark-mllib_3.4": "Apache Spark 3.4",
-            "autoai-rag_rt24.1-py3.11": "AutoAI RAG"
+            "autoai-rag_rt24.1-py3.11": "AutoAI RAG",
         }
 
         # Define the preferred order for items to appear at the top
@@ -1043,42 +1224,51 @@ def _(client, mo, pd, specs_df):
         ]
 
         # Create a new column for sorting
-        supported_specs['SORT_ORDER'] = supported_specs['NAME'].apply(
-            lambda x: preferred_order.index(x) if x in preferred_order else len(preferred_order)
+        supported_specs["SORT_ORDER"] = supported_specs["NAME"].apply(
+            lambda x: (
+                preferred_order.index(x)
+                if x in preferred_order
+                else len(preferred_order)
+            )
         )
 
         # Sort the DataFrame by the new column
-        supported_specs = supported_specs.sort_values('SORT_ORDER').reset_index(drop=True)
+        supported_specs = supported_specs.sort_values("SORT_ORDER").reset_index(
+            drop=True
+        )
 
         # Drop the sorting column as it's no longer needed
-        supported_specs = supported_specs.drop(columns=['SORT_ORDER'])
+        supported_specs = supported_specs.drop(columns=["SORT_ORDER"])
 
         # Drop the REPLACEMENT column if it exists and add NOTES column
-        if 'REPLACEMENT' in supported_specs.columns:
-            supported_specs = supported_specs.drop(columns=['REPLACEMENT'])
+        if "REPLACEMENT" in supported_specs.columns:
+            supported_specs = supported_specs.drop(columns=["REPLACEMENT"])
 
         # Add NOTES column with framework information
-        supported_specs['NOTES'] = supported_specs['NAME'].map(framework_mapping).fillna("Other")
+        supported_specs["NOTES"] = (
+            supported_specs["NAME"].map(framework_mapping).fillna("Other")
+        )
 
         # Create a table with single-row selection
         selection_table = mo.ui.table(
             supported_specs,
             selection="single",  # Only allow selecting one row
             label="#### **Select a supported software_spec runtime for your function asset** (For Python Functions select - *'runtime-24.1-py3.11'* ):",
-            initial_selection=[0],  # Now selecting the first row, which should be runtime-24.1-py3.11
-            page_size=6
+            initial_selection=[
+                0
+            ],  # Now selecting the first row, which should be runtime-24.1-py3.11
+            page_size=6,
         )
     else:
         sel_df = pd.DataFrame(
-        data=[["ID", "Activate client."]], 
-        columns=["ID", "VALUE"]
+            data=[["ID", "Activate client."]], columns=["ID", "VALUE"]
         )
 
         selection_table = mo.ui.table(
             sel_df,
             selection="single",  # Only allow selecting one row
             label="You haven't activated the client",
-            initial_selection=[0]
+            initial_selection=[0],
         )
 
     return (selection_table,)
@@ -1093,7 +1283,7 @@ def _(mo):
 @app.cell
 def _(selection_table, set_selected_sw_spec):
     if selection_table.value is not None:
-        set_selected_sw_spec(selection_table.value['ID'].iloc[0])
+        set_selected_sw_spec(selection_table.value["ID"].iloc[0])
     return
 
 
@@ -1106,7 +1296,7 @@ def _(mo):
 @app.cell
 def _(hw_selection_table, set_selected_hw_spec):
     if hw_selection_table.value is not None:
-        set_selected_hw_spec(hw_selection_table.value['ID'].iloc[0])
+        set_selected_hw_spec(hw_selection_table.value["ID"].iloc[0])
     return
 
 
@@ -1126,6 +1316,7 @@ def _(
     output_schema_checkbox,
     selection_table,
     template_variant,
+    template,
 ):
     if selection_table.value is not None:
         # Create the input fields
@@ -1134,11 +1325,23 @@ def _(
         else:
             fnc_nm = "custom_pythoN_functin"
 
-        uploaded_function_name = mo.ui.text(placeholder="<Must be the same as the name in editor>", label="Function Name:", kind="text", value=f"{fnc_nm}", full_width=False)
+        uploaded_function_name = mo.ui.text(
+            placeholder="<Must be the same as the name in editor>",
+            label="Function Name:",
+            kind="text",
+            value=f"{fnc_nm}",
+            full_width=False,
+        )
         tags_editor = mo.ui.array(
-           [mo.ui.text(placeholder="Metadata Tags...", value=use_case) for use_case in template["use_cases"]] +
-           [mo.ui.text(placeholder="Metadata Tags...") for _ in range(max(0, 4 - len(template["use_cases"])))],
-           label="Optional Metadata Tags"
+            [
+                mo.ui.text(placeholder="Metadata Tags...", value=use_case)
+                for use_case in template["use_cases"]
+            ]
+            + [
+                mo.ui.text(placeholder="Metadata Tags...")
+                for _ in range(max(0, 4 - len(template["use_cases"])))
+            ],
+            label="Optional Metadata Tags",
         )
         software_spec = get_selected_sw_spec()
 
@@ -1147,9 +1350,9 @@ def _(
             label="Description",
             max_length=256,
             rows=5,
-            full_width=True
+            full_width=True,
         )
-        
+
     return (
         description_input,
         software_spec,
@@ -1157,125 +1360,167 @@ def _(
         uploaded_function_name,
     )
 
+
 @app.cell
 def _(mo, selection_table, description_input, uploaded_function_name, tags_editor):
     if selection_table.value is not None:
-        func_metadata=mo.hstack([
-            description_input,
-            mo.hstack([
-                uploaded_function_name,
-                tags_editor,
-            ], justify="start", gap=1, align="start", wrap=True)
-        ],
-            widths=[0.6,0.4],
-            gap=2.75
+        func_metadata = mo.hstack(
+            [
+                description_input,
+                mo.hstack(
+                    [
+                        uploaded_function_name,
+                        tags_editor,
+                    ],
+                    justify="start",
+                    gap=1,
+                    align="start",
+                    wrap=True,
+                ),
+            ],
+            widths=[0.6, 0.4],
+            gap=2.75,
         )
     return func_metadata
 
+
 @app.cell
 def _(mo, selection_table, input_schema_checkbox, output_schema_checkbox):
     if selection_table.value is not None:
-        schema_metadata=mo.hstack([
-            input_schema_checkbox,
-            output_schema_checkbox,
-        ],
-            justify="center", gap=1, align="center", wrap=True
+        schema_metadata = mo.hstack(
+            [
+                input_schema_checkbox,
+                output_schema_checkbox,
+            ],
+            justify="center",
+            gap=1,
+            align="center",
+            wrap=True,
         )
     return schema_metadata
 
+
 @app.cell
 def _(mo, selection_table, func_metadata):
     if selection_table.value is not None:
-        fm = mo.vstack([
-            func_metadata,
+        fm = mo.vstack(
+            [
+                func_metadata,
             ],
             align="center",
-            gap=2
+            gap=2,
         )
     return fm
 
+
 @app.cell
 def _(mo, selection_table, schema_metadata):
     if selection_table.value is not None:
-        sc_m = mo.vstack([
-            schema_metadata,
-            mo.md("**Make sure to select the checkbox options before filling in descriptions and tags or they will reset.**")
+        sc_m = mo.vstack(
+            [
+                schema_metadata,
+                mo.md(
+                    "**Make sure to select the checkbox options before filling in descriptions and tags or they will reset.**"
+                ),
             ],
             align="center",
-            gap=2
+            gap=2,
         )
     return sc_m
 
 
 @app.cell
-def _(json, mo, template_variant):
+def _(json, mo, template_variant, template):
     if template["input_schema"]:
         input_schema = template["input_schema"]
     else:
         input_schema = [
             {
-                'id': '1',
-                'type': 'struct',
-                'fields': [
+                "id": "1",
+                "type": "struct",
+                "fields": [
                     {
-                    'name': '<variable name 1>', 
-                    'type': 'string',
-                    'nullable': False, 
-                    'metadata': {}
+                        "name": "<variable name 1>",
+                        "type": "string",
+                        "nullable": False,
+                        "metadata": {},
                     },
                     {
-                    'name': '<variable name 2>', 
-                    'type': 'string', 
-                    'nullable': False, 
-                    'metadata': {}
-                    }
-                ]
+                        "name": "<variable name 2>",
+                        "type": "string",
+                        "nullable": False,
+                        "metadata": {},
+                    },
+                ],
             }
         ]
-        
+
     if template["output_schema"]:
         output_schema = template["output_schema"]
     else:
         output_schema = [
             {
-                'id': '1',
-                'type': 'struct',
-                'fields': [
+                "id": "1",
+                "type": "struct",
+                "fields": [
                     {
-                    'name': '<output return name>', 
-                    'type': 'string', 
-                    'nullable': False, 
-                    'metadata': {}
+                        "name": "<output return name>",
+                        "type": "string",
+                        "nullable": False,
+                        "metadata": {},
                     }
-                ]
+                ],
             }
         ]
 
     return input_schema, output_schema
 
-    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")
-
+    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
     return input_schema_editor, output_schema_editor
 
+
 @app.cell
 def _(mo, input_schema, output_schema):
-    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")
+    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",
+    )
     return input_schema_editor, output_schema_editor
 
+
 @app.cell
 def _(mo, input_schema_editor, output_schema_editor):
     schema_editors = mo.accordion(
         {
             """**Input Schema Metadata Editor**""": input_schema_editor,
             """**Output Schema Metadata Editor**""": output_schema_editor,
-        }, multiple=True
+        },
+        multiple=True,
     )
     return schema_editors
 
+
 @app.cell
 def _(
     ast,
@@ -1302,8 +1547,10 @@ def _(
     if software_spec and client is not None:
         # Start with the base required fields
         function_meta = {
-            client.repository.FunctionMetaNames.NAME: f"{uploaded_function_name.value}" or "your_function_name",
-            client.repository.FunctionMetaNames.SOFTWARE_SPEC_ID: software_spec or "45f12dfe-aa78-5b8d-9f38-0ee223c47309"
+            client.repository.FunctionMetaNames.NAME: f"{uploaded_function_name.value}"
+            or "your_function_name",
+            client.repository.FunctionMetaNames.SOFTWARE_SPEC_ID: software_spec
+            or "45f12dfe-aa78-5b8d-9f38-0ee223c47309",
         }
 
         # Add optional fields if they exist
@@ -1313,26 +1560,34 @@ def _(
             if filtered_tags:  # Only add if there are non-empty tags
                 function_meta[client.repository.FunctionMetaNames.TAGS] = filtered_tags
 
-
         if description_input.value:
-            function_meta[client.repository.FunctionMetaNames.DESCRIPTION] = description_input.value
+            function_meta[client.repository.FunctionMetaNames.DESCRIPTION] = (
+                description_input.value
+            )
 
         # Add input schema if checkbox is checked
         if input_schema_checkbox.value:
             try:
-                function_meta[client.repository.FunctionMetaNames.INPUT_DATA_SCHEMAS] = json.loads(input_schema_editor.value)
+                function_meta[
+                    client.repository.FunctionMetaNames.INPUT_DATA_SCHEMAS
+                ] = json.loads(input_schema_editor.value)
             except json.JSONDecodeError:
                 # If JSON parsing fails, try Python literal evaluation as fallback
-                function_meta[client.repository.FunctionMetaNames.INPUT_DATA_SCHEMAS] = ast.literal_eval(input_schema_editor.value)
+                function_meta[
+                    client.repository.FunctionMetaNames.INPUT_DATA_SCHEMAS
+                ] = ast.literal_eval(input_schema_editor.value)
 
         # Add output schema if checkbox is checked
         if output_schema_checkbox.value:
             try:
-                function_meta[client.repository.FunctionMetaNames.OUTPUT_DATA_SCHEMAS] = json.loads(output_schema_editor.value)
+                function_meta[
+                    client.repository.FunctionMetaNames.OUTPUT_DATA_SCHEMAS
+                ] = json.loads(output_schema_editor.value)
             except json.JSONDecodeError:
                 # If JSON parsing fails, try Python literal evaluation as fallback
-                function_meta[client.repository.FunctionMetaNames.OUTPUT_DATA_SCHEMAS] = ast.literal_eval(output_schema_editor.value)
-
+                function_meta[
+                    client.repository.FunctionMetaNames.OUTPUT_DATA_SCHEMAS
+                ] = ast.literal_eval(output_schema_editor.value)
 
     def upload_function(function_meta, use_function_object=False):
         """
@@ -1348,7 +1603,7 @@ def _(
 
         try:
             # Create temp file from the code in the editor
-            code_to_deploy = function_editor.value['editor']
+            code_to_deploy = function_editor.value["editor"]
             # This function is defined elsewhere in the notebook
             func_name = uploaded_function_name.value or "your_function_name"
             # Ensure function_meta has the correct function name
@@ -1372,14 +1627,16 @@ def _(
                 function_object = getattr(module, func_name)
 
                 # Change to /tmp directory before calling IBM Watson SDK functions
-                os.chdir('/tmp/notebook_functions')
+                os.chdir("/tmp/notebook_functions")
 
                 # Upload the function object
                 mo.md(f"Uploading function object: {func_name}")
-                func_details = client.repository.store_function(function_object, function_meta)
+                func_details = client.repository.store_function(
+                    function_object, function_meta
+                )
             else:
                 # Change to /tmp directory before calling IBM Watson SDK functions
-                os.chdir('/tmp/notebook_functions')
+                os.chdir("/tmp/notebook_functions")
 
                 # Create a zip file of the Python module
                 import gzip
@@ -1389,8 +1646,8 @@ def _(
                 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:
+                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
@@ -1407,13 +1664,13 @@ def _(
             # Always change back to the original directory, even if an exception occurs
             os.chdir(original_dir)
 
-    upload_status =  mo.state("No uploads yet")
+    upload_status = mo.state("No uploads yet")
 
     upload_button = mo.ui.button(
         label="Upload Function",
         on_click=lambda _: upload_function(function_meta, use_function_object=False),
         kind="success",
-        tooltip="Click to upload function to watsonx.ai"
+        tooltip="Click to upload function to watsonx.ai",
     )
 
     # function_meta
@@ -1422,18 +1679,19 @@ def _(
 
 @app.cell
 def _(get_upload_status, mo, upload_button):
-    # Upload your function 
+    # Upload your function
     if upload_button.value:
         try:
             upload_result = upload_button.value
-            artifact_id = upload_result['metadata']['id']
+            artifact_id = upload_result["metadata"]["id"]
         except Exception as e:
             mo.md(f"Error: {str(e)}")
 
-    upload_func = mo.vstack([
-        upload_button,
-        mo.md(f"**Status:** {get_upload_status()}")
-    ], justify="space-around", align="center")
+    upload_func = mo.vstack(
+        [upload_button, mo.md(f"**Status:** {get_upload_status()}")],
+        justify="space-around",
+        align="center",
+    )
     return artifact_id, upload_func
 
 
@@ -1457,12 +1715,30 @@ def _(client, mo, pd, upload_button, uuid):
         def get_sort_key(name):
             # Create a custom ordering list
             custom_order = [
-                "XXS", "XS", "S", "M", "L", "XL",
-                "XS-Spark", "S-Spark", "M-Spark", "L-Spark", "XL-Spark",
-                "K80", "K80x2", "K80x4",
-                "V100", "V100x2",
-                "WXaaS-XS", "WXaaS-S", "WXaaS-M", "WXaaS-L", "WXaaS-XL",
-                "Default Spark", "Notebook Default Spark", "ML"
+                "XXS",
+                "XS",
+                "S",
+                "M",
+                "L",
+                "XL",
+                "XS-Spark",
+                "S-Spark",
+                "M-Spark",
+                "L-Spark",
+                "XL-Spark",
+                "K80",
+                "K80x2",
+                "K80x4",
+                "V100",
+                "V100x2",
+                "WXaaS-XS",
+                "WXaaS-S",
+                "WXaaS-M",
+                "WXaaS-L",
+                "WXaaS-XL",
+                "Default Spark",
+                "Notebook Default Spark",
+                "ML",
             ]
 
             # If name is in the custom order list, use its index
@@ -1473,10 +1749,10 @@ def _(client, mo, pd, upload_button, uuid):
             return (1, name)
 
         # Add a temporary column for sorting
-        result_df['sort_key'] = result_df['NAME'].apply(get_sort_key)
+        result_df["sort_key"] = result_df["NAME"].apply(get_sort_key)
 
         # Sort the dataframe and drop the temporary column
-        result_df = result_df.sort_values('sort_key').drop('sort_key', axis=1)
+        result_df = result_df.sort_values("sort_key").drop("sort_key", axis=1)
 
         # Reset the index
         result_df = result_df.reset_index(drop=True)
@@ -1495,26 +1771,33 @@ def _(client, mo, pd, upload_button, uuid):
             label="#### **Select a supported hardware_specification for your deployment** *(Default: 'XS' - 1vCPU_4GB Ram)*",
             initial_selection=[1],
             page_size=6,
-            wrapped_columns=['DESCRIPTION']
+            wrapped_columns=["DESCRIPTION"],
         )
 
         deployment_type = mo.ui.radio(
-        options={"Function":"Online (Function Endpoint)","Runnable Job":"Batch (Runnable Jobs)"}, value="Function", label="Select the Type of Deployment:", inline=True
+            options={
+                "Function": "Online (Function Endpoint)",
+                "Runnable Job": "Batch (Runnable Jobs)",
+            },
+            value="Function",
+            label="Select the Type of Deployment:",
+            inline=True,
         )
         uuid_suffix = str(uuid.uuid4())[:4]
 
-        deployment_name = mo.ui.text(value=f"deployed_func_{uuid_suffix}", label="Deployment Name:", placeholder="<Must be completely unique>")
-    else:
-        hw_df = pd.DataFrame(
-        data=[["ID", "Activate client."]], 
-        columns=["ID", "VALUE"]
+        deployment_name = mo.ui.text(
+            value=f"deployed_func_{uuid_suffix}",
+            label="Deployment Name:",
+            placeholder="<Must be completely unique>",
         )
+    else:
+        hw_df = pd.DataFrame(data=[["ID", "Activate client."]], columns=["ID", "VALUE"])
 
         hw_selection_table = mo.ui.table(
             hw_df,
             selection="single",  # Only allow selecting one row
             label="You haven't activated the client",
-            initial_selection=[0]
+            initial_selection=[0],
         )
 
     return deployment_name, deployment_type, hw_selection_table
@@ -1547,18 +1830,24 @@ def _(
             print("Error: No artifact ID provided. Please upload a function first.")
             return None
 
-        if deployment_type.value == "Online (Function Endpoint)":  # Changed from "Online (Function Endpoint)"
+        if (
+            deployment_type.value == "Online (Function Endpoint)"
+        ):  # Changed from "Online (Function Endpoint)"
             deployment_props = {
                 client.deployments.ConfigurationMetaNames.NAME: deployment_name.value,
                 client.deployments.ConfigurationMetaNames.ONLINE: {},
-                client.deployments.ConfigurationMetaNames.HARDWARE_SPEC: {"id": selected_hw_config},
+                client.deployments.ConfigurationMetaNames.HARDWARE_SPEC: {
+                    "id": selected_hw_config
+                },
                 client.deployments.ConfigurationMetaNames.SERVING_NAME: deployment_name.value,
             }
         else:  # "Runnable Job" instead of "Batch (Runnable Jobs)"
             deployment_props = {
                 client.deployments.ConfigurationMetaNames.NAME: deployment_name.value,
                 client.deployments.ConfigurationMetaNames.BATCH: {},
-                client.deployments.ConfigurationMetaNames.HARDWARE_SPEC: {"id": selected_hw_config},
+                client.deployments.ConfigurationMetaNames.HARDWARE_SPEC: {
+                    "id": selected_hw_config
+                },
                 # batch does not use serving names
             }
 
@@ -1566,11 +1855,15 @@ def _(
             print(deployment_props)
             # First, get the asset details to confirm it exists
             asset_details = client.repository.get_details(artifact_id)
-            print(f"Asset found: {asset_details['metadata']['name']} with ID: {asset_details['metadata']['id']}")
+            print(
+                f"Asset found: {asset_details['metadata']['name']} with ID: {asset_details['metadata']['id']}"
+            )
 
             # Create the deployment
             deployed_function = client.deployments.create(artifact_id, deployment_props)
-            print(f"Creating deployment from Asset: {artifact_id} with deployment properties {str(deployment_props)}")
+            print(
+                f"Creating deployment from Asset: {artifact_id} with deployment properties {str(deployment_props)}"
+            )
             return deployed_function
         except Exception as e:
             print(f"Deployment error: {str(e)}")
@@ -1584,7 +1877,7 @@ def _(
         deployment_info = client.deployments.get_details(deployment_id)
         return deployment_info
 
-    deployment_status =  mo.state("No deployments yet")
+    deployment_status = mo.state("No deployments yet")
 
     if hw_selection_table.value is not None:
         selected_hw_config = get_selected_hw_spec()
@@ -1593,19 +1886,18 @@ def _(
         label="Deploy Function",
         on_click=lambda _: deploy_function(artifact_id, deployment_type),
         kind="success",
-        tooltip="Click to deploy function to watsonx.ai"
+        tooltip="Click to deploy function to watsonx.ai",
     )
 
     if client and upload_button.value:
-        deployment_definition = mo.hstack([
-            deployment_type,
-            deployment_name
-        ], justify="space-around")
+        deployment_definition = mo.hstack(
+            [deployment_type, deployment_name], justify="space-around"
+        )
     else:
-        deployment_definition = mo.hstack([
-            "No Deployment Type Selected",
-            "No Deployment Name Provided"
-        ], justify="space-around")
+        deployment_definition = mo.hstack(
+            ["No Deployment Type Selected", "No Deployment Name Provided"],
+            justify="space-around",
+        )
 
     # deployment_definition
     return deploy_button, deployment_definition
@@ -1615,10 +1907,9 @@ def _(
 def _(deploy_button, deployment_definition, mo):
     _ = deployment_definition
 
-    deploy_fnc = mo.vstack([
-        deploy_button,
-        deploy_button.value
-    ], justify="space-around", align="center")
+    deploy_fnc = mo.vstack(
+        [deploy_button, deploy_button.value], justify="space-around", align="center"
+    )
 
     return (deploy_fnc,)
 
@@ -1630,17 +1921,19 @@ def _(client, mo, pd, sys):
     def get_deployment_list():
         dep_df = client.deployments.list()
         dep_df = pd.DataFrame(dep_df)
-    
-        columns_to_drop = [col for col in dep_df.columns if 'STATE' in col or 'REPLACEMENT' in col]
+
+        columns_to_drop = [
+            col for col in dep_df.columns if "STATE" in col or "REPLACEMENT" in col
+        ]
         if columns_to_drop:
             dep_df = dep_df.drop(columns=columns_to_drop)
         return dep_df
 
     def get_deployment_ids(df):
-        dep_list = df['ID'].tolist()
+        dep_list = df["ID"].tolist()
         return dep_list
 
-    #----
+    # ----
 
     def get_data_assets_list():
         data_a_df = client.data_assets.list()
@@ -1648,25 +1941,29 @@ def _(client, mo, pd, sys):
         return data_a_df
 
     def get_data_asset_ids(df):
-        data_asset_list = df['ASSET_ID'].tolist()
+        data_asset_list = df["ASSET_ID"].tolist()
         return data_asset_list
 
-    #----
+    # ----
 
     def get_repository_list():
         rep_list_df = client.repository.list()
         rep_list_df = pd.DataFrame(rep_list_df)
-    
-        columns_to_drop = [col for col in ['SPEC_STATE', 'SPEC_REPLACEMENT'] if col in rep_list_df.columns]
+
+        columns_to_drop = [
+            col
+            for col in ["SPEC_STATE", "SPEC_REPLACEMENT"]
+            if col in rep_list_df.columns
+        ]
         if columns_to_drop:
             rep_list_df = rep_list_df.drop(columns=columns_to_drop)
         return rep_list_df
 
     def get_repository_ids(df):
-        repository_list = df['ID'].tolist()
+        repository_list = df["ID"].tolist()
         return repository_list
 
-    #----
+    # ----
 
     def get_pkg_ext_list():
         pkg_ext_list_df = client.package_extensions.list()
@@ -1674,96 +1971,95 @@ def _(client, mo, pd, sys):
         return pkg_ext_list_df
 
     def get_pkg_ext_ids(df):
-        pkg_ext_id_list = df['ASSET_ID'].tolist()
+        pkg_ext_id_list = df["ASSET_ID"].tolist()
         return pkg_ext_id_list
 
-    #----
+    # ----
 
     def get_sws_list():
         sws_list_df = client.software_specifications.list()
         # Filter to only include derived types
-        derived_sws_list_df = sws_list_df[
-            (sws_list_df['TYPE'] == 'derived')
-        ]
+        derived_sws_list_df = sws_list_df[(sws_list_df["TYPE"] == "derived")]
         # Reset the index and prepare final dataframe
         sws_list_df = pd.DataFrame(derived_sws_list_df).reset_index(drop=True)
         # Drop STATE and REPLACEMENT columns if they exist
-        columns_to_drop = [col for col in ['STATE', 'REPLACEMENT'] if col in sws_list_df.columns]
+        columns_to_drop = [
+            col for col in ["STATE", "REPLACEMENT"] if col in sws_list_df.columns
+        ]
         if columns_to_drop:
             sws_list_df = sws_list_df.drop(columns=columns_to_drop)
         return sws_list_df
 
     def get_sws_ids(df):
-        sws_id_list = df['ID'].tolist()
+        sws_id_list = df["ID"].tolist()
         return sws_id_list
 
-    #----
+    # ----
 
-    def delete_with_progress(ids_list, delete_function, item_type="items", display_errors=True):
+    def delete_with_progress(
+        ids_list, delete_function, item_type="items", display_errors=True
+    ):
         errors = []
-    
+
         with mo.status.progress_bar(
             total=len(ids_list) or 1,
             title=f"Purging {item_type}",
             subtitle=f"Deleting {item_type}...",
             completion_title="Purge Complete",
             completion_subtitle=f"Successfully deleted {len(ids_list) - len(errors)} {item_type}",
-            remove_on_exit=True
+            remove_on_exit=True,
         ) as progress:
             for item_id in ids_list:
                 try:
                     delete_function(item_id)
                 except Exception as e:
-                    error_msg = f"Error deleting {item_type} with ID {item_id}: {str(e)}"
+                    error_msg = (
+                        f"Error deleting {item_type} with ID {item_id}: {str(e)}"
+                    )
                     if display_errors:
                         print(error_msg)
                     errors.append((item_id, str(e)))
                 finally:
                     progress.update(increment=1)
-        
+
             if errors and display_errors:
                 with mo.redirect_stderr():
                     sys.stderr.write("\nErrors encountered during deletion:\n")
                     for item_id, error in errors:
                         sys.stderr.write(f"  - ID {item_id}: {error}\n")
-                    
+
             return f"Deleted {len(ids_list) - len(errors)} {item_type} successfully"
-        
+
     # Use with existing deletion functions
     def delete_deployments(deployment_ids):
         return delete_with_progress(
-            deployment_ids, 
-            lambda id: client.deployments.delete(id),
-            "deployments"
+            deployment_ids, lambda id: client.deployments.delete(id), "deployments"
         )
 
     def delete_data_assets(data_asset_ids):
         return delete_with_progress(
-            data_asset_ids, 
-            lambda id: client.data_assets.delete(id),
-            "data assets"
+            data_asset_ids, lambda id: client.data_assets.delete(id), "data assets"
         )
 
     def delete_repository_items(repository_ids):
         return delete_with_progress(
-            repository_ids, 
-            lambda id: client.repository.delete(id),
-            "repository items"
+            repository_ids, lambda id: client.repository.delete(id), "repository items"
         )
 
     def delete_pkg_ext_items(pkg_ids):
         return delete_with_progress(
-            pkg_ids, 
+            pkg_ids,
             lambda id: client.package_extensions.delete(id),
-            "package extensions"
+            "package extensions",
         )
 
     def delete_sws_items(sws_ids):
         return delete_with_progress(
-            sws_ids, 
+            sws_ids,
             lambda id: client.software_specifications.delete(id),
-            "software specifications"
+            "software specifications",
         )
+
     return (
         delete_data_assets,
         delete_deployments,
@@ -1817,7 +2113,6 @@ def _(
     else:
         pkg_ext_table = mo.md("No Table Loaded")
 
-
     return (
         data_assets_table,
         deployments_table,
@@ -1835,10 +2130,16 @@ def _(
     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_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])
+    deployments_purge_tab = mo.vstack(
+        [deployments_purge_stack, deployments_purge_stack_results]
+    )
     return (deployments_purge_tab,)
 
 
@@ -1850,10 +2151,16 @@ def _(
     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_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])
+    repository_purge_tab = mo.vstack(
+        [repository_purge_stack, repository_purge_stack_results]
+    )
     return (repository_purge_tab,)
 
 
@@ -1865,17 +2172,25 @@ def _(
     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_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])
+    data_assets_purge_tab = mo.vstack(
+        [data_assets_purge_stack, data_assets_purge_stack_results]
+    )
     return (data_assets_purge_tab,)
 
 
 @app.cell
 def _(get_sws_button, get_sws_id_list, mo, purge_sws, sws_table):
     sws_purge_stack = mo.hstack([get_sws_button, get_sws_id_list, purge_sws])
-    sws_purge_stack_results = mo.vstack([sws_table, get_sws_id_list.value, purge_sws.value])
+    sws_purge_stack_results = mo.vstack(
+        [sws_table, get_sws_id_list.value, purge_sws.value]
+    )
 
     sws_purge_stack_tab = mo.vstack([sws_purge_stack, sws_purge_stack_results])
     return (sws_purge_stack_tab,)
@@ -1889,8 +2204,12 @@ def _(
     pkg_ext_table,
     purge_pkg_ext,
 ):
-    pkg_ext_purge_stack = mo.hstack([get_pkg_ext_button, get_pkg_ext_id_list, purge_pkg_ext])
-    pkg_ext_purge_stack_results = mo.vstack([pkg_ext_table, get_pkg_ext_id_list.value, purge_pkg_ext.value])
+    pkg_ext_purge_stack = mo.hstack(
+        [get_pkg_ext_button, get_pkg_ext_id_list, purge_pkg_ext]
+    )
+    pkg_ext_purge_stack_results = mo.vstack(
+        [pkg_ext_table, get_pkg_ext_id_list.value, purge_pkg_ext.value]
+    )
 
     pkg_ext_purge_tab = mo.vstack([pkg_ext_purge_stack, pkg_ext_purge_stack_results])
     return (pkg_ext_purge_tab,)
@@ -1907,13 +2226,13 @@ def _(
 ):
     purge_tabs = mo.ui.tabs(
         {
-            "Purge Deployments": deployments_purge_tab, 
+            "Purge Deployments": deployments_purge_tab,
             "Purge Repository Assets": repository_purge_tab,
             "Purge Data Assets": data_assets_purge_tab,
             "Purge Software Specifications": sws_purge_stack_tab,
             "Purge Package Extensions": pkg_ext_purge_tab,
-        }
-        , lazy=False
+        },
+        lazy=False,
     )
 
     return (purge_tabs,)
@@ -2058,7 +2377,6 @@ def _(
         kind="danger",
     )
 
-
     ### Package Extensions Purge
     get_pkg_ext_button = mo.ui.button(
         label="Get Package Extensions Dataframe",