Update main_app.py

main_app.py

@@ -1,5 +1,3 @@
-
-
 import marimo
 
 __generated_with = "0.13.0"
@@ -44,6 +42,7 @@ def _(os):
     from typing import Any, Dict, List, Optional, Pattern, Set, Union, Tuple
     from ibm_watsonx_ai import APIClient, Credentials
     from pathlib import Path
+    import importlib.util
     import pandas as pd
     import mimetypes
     import requests
@@ -51,11 +50,13 @@ def _(os):
     import polars
     import urllib3
     import tempfile
+    import importlib.util
     import base64
     import uuid
-    import ssl
     import time
     import json
+    import sys
+    import ssl
     import ast
     import io
     import re
@@ -63,6 +64,9 @@ def _(os):
     # Set explicit temporary directory
     os.environ['TMPDIR'] = '/tmp/notebook_functions'
 
+    # Create the directory if it doesn't exist
+    os.makedirs('/tmp/notebook_functions', exist_ok=True)
+
     # Make sure Python's tempfile module also uses this directory
     tempfile.tempdir = '/tmp/notebook_functions'
 
@@ -110,9 +114,11 @@ def _(os):
         Credentials,
         ast,
         get_iam_token,
+        importlib,
         json,
         pd,
         setup_task_credentials,
+        sys,
         tempfile,
         uuid,
     )
@@ -222,25 +228,32 @@ def _(
 
         if space_id:
             deployment_client = APIClient(credentials=wx_credentials, space_id=space_id)
+            client = deployment_client
         else:
             deployment_client = None
+            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)
+            task_credentials_details = setup_task_credentials(client)
+
     else:
         wx_credentials = None
         project_client = None
         deployment_client = None
         task_credentials_details = None
+        client = None
+    return client, deployment_client, project_client
 
+
+@app.cell
+def _(deployment_client, project_client):
     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, project_client, wx_credentials, deployment_client, task_credentials_details
+    return (client_callout_kind,)
 
 
 @app.cell
@@ -261,24 +274,7 @@ def _(client_callout_kind, client_instantiation_form, mo, template_variant):
 
 
 @app.cell
-def _(
-    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,
-):
+def _(client_stack, mo):
     client_section = mo.md(f'''
         ###**Instantiate your watsonx.ai client:**
 
@@ -295,7 +291,11 @@ def _(
         {client_stack}
 
     ''')
+    return (client_section,)
 
+
+@app.cell
+def _(mo, sc_m, schema_editors):
     sc_tabs = mo.ui.tabs(
         {
             "Schema Option Selection": sc_m,
@@ -304,7 +304,11 @@ def _(
                                        {schema_editors}"""),
         }
     )
+    return (sc_tabs,)
+
 
+@app.cell
+def _(fm, function_editor, mo, sc_tabs):
     function_section = mo.md(f'''###**Create your function from the template:**
 
         1. Use the code editor window to create a function to deploy
@@ -343,7 +347,11 @@ def _(
         {fm}
 
     ''')
+    return (function_section,)
+
 
+@app.cell
+def _(mo, selection_table, upload_func):
     upload_section = mo.md(f'''
         ###**Review and Upload your function**
 
@@ -364,7 +372,11 @@ def _(
         {upload_func}
 
     ''')
+    return (upload_section,)
 
+
+@app.cell
+def _(deploy_fnc, deployment_definition, hw_selection_table, mo):
     deployment_section = mo.md(f'''
         ###**Deploy your function:**
 
@@ -397,7 +409,11 @@ def _(
         {deploy_fnc}
 
     ''')
+    return (deployment_section,)
+
 
+@app.cell
+def _(mo, purge_tabs):
     purging_section = mo.md(f'''
         ###**Helper Purge Functions:**
 
@@ -411,7 +427,18 @@ def _(
 
     ''')
 
+    return (purging_section,)
+
 
+@app.cell
+def _(
+    json,
+    mo,
+    package_analysis_stack,
+    package_meta,
+    ss_asset_response,
+    yaml_template,
+):
     packages_section = mo.md(f'''
         ###**If needed - Create a custom software-spec with added python packages**
 
@@ -439,18 +466,12 @@ def _(
 
         ---
 
-        Results:
-
-        {ss_asset_details}
-
+        Result:
+    ```json
+    {json.dumps(ss_asset_response, indent=2)}
+    ```
     ''')
-    return (
-        client_section,
-        deployment_section,
-        function_section,
-        packages_section,
-        upload_section,
-    )
+    return (packages_section,)
 
 
 @app.cell
@@ -499,9 +520,9 @@ def _(deployment_section, mo):
 
 
 @app.cell
-def _(mo, packages_section):
+def _(mo, purging_section):
     ui_accordion_section_6 = mo.accordion(
-        {"Section 6: **Helper Functions**": packages_section}
+        {"Section 6: **Helper Functions**": purging_section}
     ) 
     ui_accordion_section_6
     return
@@ -647,19 +668,8 @@ 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))
-
+            f.write(str(yaml_editor_value))
         return temp_file.name
     return (create_yaml_tempfile,)
 
@@ -760,10 +770,10 @@ def _(check_packages, mo, package_df):
 
 
 @app.cell
-def _(deployment_client):
-    if deployment_client is not None:
+def _(client):
+    if 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)
+        base_software_spec = client.software_specifications.get_details(base_sw_spec_id)
     else:
         base_sw_spec_id = None
         base_software_spec = None
@@ -771,12 +781,14 @@ def _(deployment_client):
 
 
 @app.cell
-def _(create_yaml_tempfile, deployment_client, package_meta):
-    if package_meta.value is not None and deployment_client is not None:
+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']
         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']
+            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']
         }
         yaml_file_path = create_yaml_tempfile(package_meta.value['yml_editor'])
     else:
@@ -786,7 +798,23 @@ def _(create_yaml_tempfile, deployment_client, package_meta):
 
     return pe_metadata, yaml_file_path
 
-@app.cell(hide_code=True)
+
+@app.cell
+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
+        )
+        package_id = pe_asset_details["metadata"]["asset_id"]
+    else:
+        pe_asset_details = None
+        package_id = None
+    return (package_id,)
+
+
+@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):
@@ -973,47 +1001,51 @@ def _():
 
 
 @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"]
+def _(base_sw_spec_id, client, 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_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}]
+            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}]
         }
-        ss_asset_details = deployment_client.software_specifications.store(meta_props=ss_metadata)
+        ss_asset_details = client.software_specifications.store(meta_props=ss_metadata)
+
+        if ss_asset_details is not None and "metadata" in ss_asset_details:
+            ss_asset_response = ss_asset_details["metadata"]
+        else:
+            ss_asset_response = {"error": "Unsuccessful Upload"}
     else:
-        pe_asset_details = None
-        package_id = None
         ss_metadata = {}
         ss_asset_details = None
+        ss_asset_response = None
 
     # ss_asset_details
-    return (ss_asset_details,)
+    return (ss_asset_response,)
 
 
 @app.cell
-def _(deployment_client, mo, pd):
-    if deployment_client:
-        supported_specs = deployment_client.software_specifications.list()[
-            deployment_client.software_specifications.list()['STATE'] == 'supported'
+def _(client, mo, pd):
+    if client:
+        # First, get all specs data once
+        specs_df = client.software_specifications.list()
+
+        # 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']))
         ]
 
-        # Reset the index to start from 0
-        supported_specs = supported_specs.reset_index(drop=True)
+        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)
 
         # Create a mapping dictionary for framework names based on software specifications
         framework_mapping = {
@@ -1072,20 +1104,46 @@ def _(deployment_client, mo, pd):
         )
     else:
         sel_df = pd.DataFrame(
-        data=[["ID", "Activate deployment_client."]], 
+        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 Deployment_Client",
+            label="You haven't activated the client",
             initial_selection=[0]
         )
 
     return (selection_table,)
 
 
+@app.cell
+def _(mo):
+    get_selected_sw_spec, set_selected_sw_spec = mo.state(None)
+    return get_selected_sw_spec, set_selected_sw_spec
+
+
+@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])
+    return
+
+
+@app.cell
+def _(mo):
+    get_selected_hw_spec, set_selected_hw_spec = mo.state(None)
+    return get_selected_hw_spec, set_selected_hw_spec
+
+
+@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])
+    return
+
+
 @app.cell
 def _(mo):
     input_schema_checkbox = mo.ui.checkbox(label="Add input schema (optional)")
@@ -1097,13 +1155,14 @@ def _(mo):
 @app.cell
 def _(
     function_name,
+    get_selected_sw_spec,
     input_schema_checkbox,
     mo,
     output_schema_checkbox,
     selection_table,
     template_variant,
 ):
-    if selection_table.value['ID'].iloc[0]:
+    if selection_table.value is not None:
         # Create the input fields
         if function_name is not None:
             fnc_nm = function_name
@@ -1118,7 +1177,7 @@ def _(
             [mo.ui.text(placeholder="Metadata Tags..."), mo.ui.text(), mo.ui.text()],
             label="Optional Metadata Tags"
         )
-        software_spec = selection_table.value['ID'].iloc[0]
+        software_spec = get_selected_sw_spec()
 
         description_input = mo.ui.text_area(
             placeholder="Write a description for your function...)",
@@ -1231,9 +1290,10 @@ def _(json, mo, template_variant):
 @app.cell
 def _(
     ast,
-    deployment_client,
+    client,
     description_input,
     function_editor,
+    importlib,
     input_schema_checkbox,
     input_schema_editor,
     json,
@@ -1241,8 +1301,8 @@ def _(
     os,
     output_schema_checkbox,
     output_schema_editor,
-    selection_table,
     software_spec,
+    sys,
     tags_editor,
     uploaded_function_name,
 ):
@@ -1250,11 +1310,11 @@ def _(
 
     function_meta = {}
 
-    if selection_table.value['ID'].iloc[0] and deployment_client is not None:
+    if software_spec and client is not None:
         # Start with the base required fields
         function_meta = {
-            deployment_client.repository.FunctionMetaNames.NAME: f"{uploaded_function_name.value}" or "your_function_name",
-            deployment_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
@@ -1262,35 +1322,28 @@ def _(
             # Filter out empty strings from the tags list
             filtered_tags = [tag for tag in tags_editor.value if tag and tag.strip()]
             if filtered_tags:  # Only add if there are non-empty tags
-                function_meta[deployment_client.repository.FunctionMetaNames.TAGS] = filtered_tags
+                function_meta[client.repository.FunctionMetaNames.TAGS] = filtered_tags
 
 
         if description_input.value:
-            function_meta[deployment_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[deployment_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[deployment_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[deployment_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[deployment_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)
 
-        # 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)
 
     def upload_function(function_meta, use_function_object=False):
         """
@@ -1310,7 +1363,7 @@ def _(
             # 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
-            function_meta[deployment_client.repository.FunctionMetaNames.NAME] = func_name
+            function_meta[client.repository.FunctionMetaNames.NAME] = func_name
             # Save the file locally first
             save_dir = "/tmp/notebook_functions"
             os.makedirs(save_dir, exist_ok=True)
@@ -1320,8 +1373,6 @@ def _(
 
             if use_function_object:
                 # Import the function from the file
-                import sys
-                import importlib.util
                 # Add the directory to Python's path
                 sys.path.append(save_dir)
                 # Import the module
@@ -1336,19 +1387,11 @@ def _(
 
                 # Upload the function object
                 mo.md(f"Uploading function object: {func_name}")
-                func_details = deployment_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')
 
-                # # 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
-
                 # Create a zip file of the Python module
                 import gzip
                 import shutil
@@ -1363,10 +1406,7 @@ def _(
 
                 # 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)
-
-                # mo.md(f"Uploading function from file: {file_path}")
-                # func_details = deployment_client.repository.store_function(file_path, function_meta)
+                func_details = client.repository.store_function(gz_path, function_meta)
 
             set_upload_status(f"Latest Upload - id - {func_details['metadata']['id']}")
             return func_details
@@ -1409,7 +1449,7 @@ def _(get_upload_status, mo, upload_button):
 
 
 @app.cell
-def _(deployment_client, mo, pd, upload_button, uuid):
+def _(client, mo, pd, upload_button, uuid):
     def reorder_hardware_specifications(df):
         """
         Reorders a hardware specifications dataframe by type and size of environment
@@ -1454,9 +1494,9 @@ def _(deployment_client, mo, pd, upload_button, uuid):
 
         return result_df
 
-    if deployment_client and upload_button.value:
+    if client and upload_button.value:
 
-        hardware_specs = deployment_client.hardware_specifications.list()
+        hardware_specs = client.hardware_specifications.list()
         hardware_specs_df = reorder_hardware_specifications(hardware_specs)
 
         # Create a table with single-row selection
@@ -1477,14 +1517,14 @@ def _(deployment_client, mo, pd, upload_button, uuid):
         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 deployment_client."]], 
+        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 Deployment_Client",
+            label="You haven't activated the client",
             initial_selection=[0]
         )
 
@@ -1494,10 +1534,11 @@ def _(deployment_client, mo, pd, upload_button, uuid):
 @app.cell
 def _(
     artifact_id,
-    deployment_client,
+    client,
     deployment_details,
     deployment_name,
     deployment_type,
+    get_selected_hw_spec,
     hw_selection_table,
     mo,
     upload_button,
@@ -1519,27 +1560,27 @@ def _(
 
         if deployment_type.value == "Online (Function Endpoint)":  # Changed from "Online (Function Endpoint)"
             deployment_props = {
-                deployment_client.deployments.ConfigurationMetaNames.NAME: deployment_name.value,
-                deployment_client.deployments.ConfigurationMetaNames.ONLINE: {},
-                deployment_client.deployments.ConfigurationMetaNames.HARDWARE_SPEC: {"id": selected_hw_config},
-                deployment_client.deployments.ConfigurationMetaNames.SERVING_NAME: deployment_name.value,
+                client.deployments.ConfigurationMetaNames.NAME: deployment_name.value,
+                client.deployments.ConfigurationMetaNames.ONLINE: {},
+                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 = {
-                deployment_client.deployments.ConfigurationMetaNames.NAME: deployment_name.value,
-                deployment_client.deployments.ConfigurationMetaNames.BATCH: {},
-                deployment_client.deployments.ConfigurationMetaNames.HARDWARE_SPEC: {"id": selected_hw_config},
+                client.deployments.ConfigurationMetaNames.NAME: deployment_name.value,
+                client.deployments.ConfigurationMetaNames.BATCH: {},
+                client.deployments.ConfigurationMetaNames.HARDWARE_SPEC: {"id": selected_hw_config},
                 # batch does not use serving names
             }
 
         try:
             print(deployment_props)
             # First, get the asset details to confirm it exists
-            asset_details = deployment_client.repository.get_details(artifact_id)
+            asset_details = client.repository.get_details(artifact_id)
             print(f"Asset found: {asset_details['metadata']['name']} with ID: {asset_details['metadata']['id']}")
 
             # Create the deployment
-            deployed_function = deployment_client.deployments.create(artifact_id, deployment_props)
+            deployed_function = client.deployments.create(artifact_id, deployment_props)
             print(f"Creating deployment from Asset: {artifact_id} with deployment properties {str(deployment_props)}")
             return deployed_function
         except Exception as e:
@@ -1547,17 +1588,17 @@ def _(
             return None
 
     def get_deployment_id(deployed_function):
-        deployment_id = deployment_client.deployments.get_uid(deployment_details)
+        deployment_id = client.deployments.get_uid(deployment_details)
         return deployment_id
 
     def get_deployment_info(deployment_id):
-        deployment_info = deployment_client.deployments.get_details(deployment_id)
+        deployment_info = client.deployments.get_details(deployment_id)
         return deployment_info
 
     deployment_status =  mo.state("No deployments yet")
 
-    if hw_selection_table.value['ID'].iloc[0]:
-        selected_hw_config = hw_selection_table.value['ID'].iloc[0]
+    if hw_selection_table.value is not None:
+        selected_hw_config = get_selected_hw_spec()
 
     deploy_button = mo.ui.button(
         label="Deploy Function",
@@ -1566,7 +1607,7 @@ def _(
         tooltip="Click to deploy function to watsonx.ai"
     )
 
-    if deployment_client and upload_button.value:
+    if client and upload_button.value:
         deployment_definition = mo.hstack([
             deployment_type,
             deployment_name
@@ -1593,13 +1634,17 @@ def _(deploy_button, deployment_definition, mo):
     return (deploy_fnc,)
 
 
-@app.cell(hide_code=True)
-def _(deployment_client, mo, pd):
+@app.cell
+def _(client, mo, pd, sys):
     ### Functions to List , Get ID's as a list and Purge of Assets
 
     def get_deployment_list():
-        dep_df = deployment_client.deployments.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]
+        if columns_to_drop:
+            dep_df = dep_df.drop(columns=columns_to_drop)
         return dep_df
 
     def get_deployment_ids(df):
@@ -1609,7 +1654,7 @@ def _(deployment_client, mo, pd):
     #----
 
     def get_data_assets_list():
-        data_a_df = deployment_client.data_assets.list()
+        data_a_df = client.data_assets.list()
         data_a_df = pd.DataFrame(data_a_df)
         return data_a_df
 
@@ -1620,8 +1665,12 @@ def _(deployment_client, mo, pd):
     #----
 
     def get_repository_list():
-        rep_list_df = deployment_client.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]
+        if columns_to_drop:
+            rep_list_df = rep_list_df.drop(columns=columns_to_drop)
         return rep_list_df
 
     def get_repository_ids(df):
@@ -1630,63 +1679,130 @@ def _(deployment_client, mo, pd):
 
     #----
 
-    def delete_with_progress(ids_list, delete_function, item_type="items"):
-        """
-        Generic wrapper that adds a progress bar to any deletion function
+    def get_pkg_ext_list():
+        pkg_ext_list_df = client.package_extensions.list()
+        pkg_ext_list_df = pd.DataFrame(pkg_ext_list_df)
+        return pkg_ext_list_df
 
-        Parameters:
-            ids_list: List of IDs to delete
-            delete_function: Function that deletes a single ID
-            item_type: String describing what's being deleted (for display)
-        """
+    def get_pkg_ext_ids(df):
+        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')
+        ]
+        # 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]
+        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()
+        return sws_id_list
+
+    #----
+
+    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)} {item_type}"
+            completion_subtitle=f"Successfully deleted {len(ids_list) - len(errors)} {item_type}",
+            remove_on_exit=True
         ) as progress:
             for item_id in ids_list:
-                delete_function(item_id)
-                progress.update(increment=1)
-            return f"Deleted {len(ids_list)} {item_type} successfully"
-
+                try:
+                    delete_function(item_id)
+                except Exception as 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: deployment_client.deployments.delete(id),
+            lambda id: client.deployments.delete(id),
             "deployments"
         )
 
     def delete_data_assets(data_asset_ids):
         return delete_with_progress(
             data_asset_ids, 
-            lambda id: deployment_client.data_assets.delete(id),
+            lambda id: client.data_assets.delete(id),
             "data assets"
         )
 
     def delete_repository_items(repository_ids):
         return delete_with_progress(
             repository_ids, 
-            lambda id: deployment_client.repository.delete(id),
+            lambda id: client.repository.delete(id),
             "repository items"
         )
+
+    def delete_pkg_ext_items(pkg_ids):
+        return delete_with_progress(
+            pkg_ids, 
+            lambda id: client.package_extensions.delete(id),
+            "package extensions"
+        )
+
+    def delete_sws_items(sws_ids):
+        return delete_with_progress(
+            sws_ids, 
+            lambda id: client.software_specifications.delete(id),
+            "software specifications"
+        )
     return (
         delete_data_assets,
         delete_deployments,
+        delete_pkg_ext_items,
         delete_repository_items,
+        delete_sws_items,
         get_data_asset_ids,
         get_data_assets_list,
         get_deployment_ids,
         get_deployment_list,
+        get_pkg_ext_ids,
+        get_pkg_ext_list,
         get_repository_ids,
         get_repository_list,
+        get_sws_ids,
+        get_sws_list,
     )
 
 
 @app.cell
-def _(get_data_assets_tab, get_deployments_tab, get_repository_tab, mo):
+def _(
+    get_data_assets_tab,
+    get_deployments_tab,
+    get_pkg_ext_tab,
+    get_repository_tab,
+    get_sws_tab,
+    mo,
+):
     if get_deployments_tab() is not None:
         deployments_table = mo.ui.table(get_deployments_tab())
     else:
@@ -1702,7 +1818,24 @@ def _(get_data_assets_tab, get_deployments_tab, get_repository_tab, mo):
     else:
         data_assets_table = mo.md("No Table Loaded")
 
-    return data_assets_table, deployments_table, repository_table
+    if get_sws_tab() is not None:
+        sws_table = mo.ui.table(get_sws_tab())
+    else:
+        sws_table = mo.md("No Table Loaded")
+
+    if get_pkg_ext_tab() is not None:
+        pkg_ext_table = mo.ui.table(get_pkg_ext_tab())
+    else:
+        pkg_ext_table = mo.md("No Table Loaded")
+
+
+    return (
+        data_assets_table,
+        deployments_table,
+        pkg_ext_table,
+        repository_table,
+        sws_table,
+    )
 
 
 @app.cell
@@ -1729,7 +1862,6 @@ def _(
     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])
@@ -1752,9 +1884,47 @@ def _(
 
 
 @app.cell
-def _(data_assets_purge_tab, deployments_purge_tab, mo, repository_purge_tab):
+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_tab = mo.vstack([sws_purge_stack, sws_purge_stack_results])
+    return (sws_purge_stack_tab,)
+
+
+@app.cell
+def _(
+    get_pkg_ext_button,
+    get_pkg_ext_id_list,
+    mo,
+    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_tab = mo.vstack([pkg_ext_purge_stack, pkg_ext_purge_stack_results])
+    return (pkg_ext_purge_tab,)
+
+
+@app.cell
+def _(
+    data_assets_purge_tab,
+    deployments_purge_tab,
+    mo,
+    pkg_ext_purge_tab,
+    repository_purge_tab,
+    sws_purge_stack_tab,
+):
     purge_tabs = mo.ui.tabs(
-        {"Purge Deployments": deployments_purge_tab, "Purge Repository Assets": repository_purge_tab,"Purge Data Assets": data_assets_purge_tab }, lazy=False
+        {
+            "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
     )
 
     return (purge_tabs,)
@@ -1763,36 +1933,61 @@ def _(data_assets_purge_tab, deployments_purge_tab, mo, repository_purge_tab):
 @app.cell
 def _(mo):
     get_deployments_tab, set_deployments_tab = mo.state(None)
+    return get_deployments_tab, set_deployments_tab
+
+
+@app.cell
+def _(mo):
     get_repository_tab, set_repository_tab = mo.state(None)
+    return get_repository_tab, set_repository_tab
+
+
+@app.cell
+def _(mo):
     get_data_assets_tab, set_data_assets_tab = mo.state(None)
-    return (
-        get_data_assets_tab,
-        get_deployments_tab,
-        get_repository_tab,
-        set_data_assets_tab,
-        set_deployments_tab,
-        set_repository_tab,
-    )
+    return get_data_assets_tab, set_data_assets_tab
 
 
-@app.cell(hide_code=True)
+@app.cell
+def _(mo):
+    get_pkg_ext_tab, set_pkg_ext_tab = mo.state(None)
+    return get_pkg_ext_tab, set_pkg_ext_tab
+
+
+@app.cell
+def _(mo):
+    get_sws_tab, set_sws_tab = mo.state(None)
+    return get_sws_tab, set_sws_tab
+
+
+@app.cell
 def _(
     data_assets_table,
     delete_data_assets,
     delete_deployments,
+    delete_pkg_ext_items,
     delete_repository_items,
+    delete_sws_items,
     deployments_table,
     get_data_asset_ids,
     get_data_assets_list,
     get_deployment_ids,
     get_deployment_list,
+    get_pkg_ext_ids,
+    get_pkg_ext_list,
     get_repository_ids,
     get_repository_list,
+    get_sws_ids,
+    get_sws_list,
     mo,
+    pkg_ext_table,
     repository_table,
     set_data_assets_tab,
     set_deployments_tab,
+    set_pkg_ext_tab,
     set_repository_tab,
+    set_sws_tab,
+    sws_table,
 ):
     ### Temporary Function Purge - Assets
     get_data_assets_button = mo.ui.button(
@@ -1853,18 +2048,70 @@ def _(
         on_click=lambda _: delete_repository_items(get_repository_id_list.value),
         kind="danger",
     )
+
+    ### Software Spec Purge
+    get_sws_button = mo.ui.button(
+        label="Get Software Spec Dataframe",
+        on_click=lambda _: get_sws_list(),
+        on_change=lambda value: set_sws_tab(value),
+        kind="neutral",
+    )
+
+    get_sws_id_list = mo.ui.button(
+        label="Turn Dataframe into List of IDs",
+        on_click=lambda _: get_sws_ids(sws_table.value),
+        kind="neutral",
+    )
+
+    purge_sws = mo.ui.button(
+        label="Purge Software Specifications",
+        on_click=lambda _: delete_sws_items(get_sws_id_list.value),
+        kind="danger",
+    )
+
+
+    ### Package Extensions Purge
+    get_pkg_ext_button = mo.ui.button(
+        label="Get Package Extensions Dataframe",
+        on_click=lambda _: get_pkg_ext_list(),
+        on_change=lambda value: set_pkg_ext_tab(value),
+        kind="neutral",
+    )
+
+    get_pkg_ext_id_list = mo.ui.button(
+        label="Turn Dataframe into List of IDs",
+        on_click=lambda _: get_pkg_ext_ids(pkg_ext_table.value),
+        kind="neutral",
+    )
+
+    purge_pkg_ext = mo.ui.button(
+        label="Purge Package Extensions",
+        on_click=lambda _: delete_pkg_ext_items(get_pkg_ext_id_list.value),
+        kind="danger",
+    )
     return (
         get_data_asset_id_list,
         get_data_assets_button,
         get_deployment_id_list,
         get_deployments_button,
+        get_pkg_ext_button,
+        get_pkg_ext_id_list,
         get_repository_button,
         get_repository_id_list,
+        get_sws_button,
+        get_sws_id_list,
         purge_data_assets,
         purge_deployments,
+        purge_pkg_ext,
         purge_repository,
+        purge_sws,
     )
 
 
+@app.cell
+def _():
+    return
+
+
 if __name__ == "__main__":
     app.run()