Delete app_v1.py

app_v1.py

@@ -1,1152 +0,0 @@
-import marimo
-
-__generated_with = "0.11.17"
-app = marimo.App(width="medium")
-
-
-@app.cell
-def _():
-    import marimo as mo
-    import os
-    return mo, os
-
-
-@app.cell
-def _(os):
-    ### Imports
-    from typing import (
-        Any, Dict, List, Optional, Pattern, Set, Union, Tuple
-    )
-    from pathlib import Path
-    from urllib.request import urlopen
-    # from rich.markdown import Markdown as Markd
-    from rich.console import Console
-    from rich.theme import Theme
-    from rich.text import Text
-    from rich import print
-    from tqdm import tqdm
-    from enum import Enum
-    import pandas as pd
-    import tempfile
-    import requests
-    import getpass
-    import urllib3
-    import base64
-    import time
-    import json
-    import uuid
-    import ssl
-    import ast
-    import re
-
-    pd.set_option('display.max_columns', None)  
-    pd.set_option('display.max_rows', None)     
-    pd.set_option('display.max_colwidth', None) 
-    pd.set_option('display.width', None)     
-
-    custom_theme = Theme({
-        "info": "blue_violet", "warning": "yellow", "danger": "red", "python": "blue_violet", "string": "cyan", "number": "magenta", "keyword": "bright_blue", "comment": "dim blue_violet", "json":"blue_violet"
-    })
-
-    # Set explicit temporary directory
-    os.environ['TMPDIR'] = '/tmp'
-
-    # Make sure Python's tempfile module also uses this directory
-    tempfile.tempdir = '/tmp'
-
-    ### Prepares the console
-    console = Console(width=250, color_system="auto", force_jupyter=True)
-    return (
-        Any,
-        Console,
-        Dict,
-        Enum,
-        List,
-        Optional,
-        Path,
-        Pattern,
-        Set,
-        Text,
-        Theme,
-        Tuple,
-        Union,
-        ast,
-        base64,
-        console,
-        custom_theme,
-        getpass,
-        json,
-        pd,
-        print,
-        re,
-        requests,
-        ssl,
-        tempfile,
-        time,
-        tqdm,
-        urllib3,
-        urlopen,
-        uuid,
-    )
-
-
-@app.cell
-def _(mo):
-    ### Credentials for the watsonx.ai SDK client
-
-    # Endpoints
-    wx_platform_url = "https://api.dataplatform.cloud.ibm.com"
-    regions = {
-        "US": "https://us-south.ml.cloud.ibm.com",
-        "EU": "https://eu-de.ml.cloud.ibm.com",
-        "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"
-    }
-
-    # Create a form with multiple elements
-    client_instantiation_form = (
-        mo.md('''
-        ###**watsonx.ai credentials:**
-
-        {wx_region}
-
-        {wx_api_key}
-
-        {space_id}
-    ''').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")
-        ,)
-        .form(show_clear_button=True, bordered=False)
-    )
-
-
-    client_instantiation_form
-    return client_instantiation_form, regions, wx_platform_url
-
-
-@app.cell
-def _(client_instantiation_form, mo):
-    from ibm_watsonx_ai import APIClient, Credentials
-
-    def setup_task_credentials(deployment_client):
-        # Get existing task credentials
-        existing_credentials = deployment_client.task_credentials.get_details()
-        
-        # Delete existing credentials if any
-        if "resources" in existing_credentials and existing_credentials["resources"]:
-            for cred in existing_credentials["resources"]:
-                cred_id = deployment_client.task_credentials.get_id(cred)
-                deployment_client.task_credentials.delete(cred_id)
-        
-        # Store new credentials
-        return deployment_client.task_credentials.store()
-
-    if client_instantiation_form.value:
-    ### Instantiate the watsonx.ai client
-        wx_credentials = Credentials(
-            url=client_instantiation_form.value["wx_region"],
-            api_key=client_instantiation_form.value["wx_api_key"]
-        )
-
-        # project_client = APIClient(credentials=wx_credentials, project_id=client_instantiation_form.value["project_id"])
-        deployment_client = APIClient(credentials=wx_credentials, space_id=client_instantiation_form.value["space_id"])
-
-        task_credentials_details = setup_task_credentials(deployment_client)
-    else:
-        # project_client = None
-        deployment_client = None
-        task_credentials_details = None
-
-    template_variant = mo.ui.dropdown(["Base","Stream Files to IBM COS [Example]"], label="Code Template:", value="Base")
-
-    if deployment_client is not None:
-        client_callout_kind = "success"
-    else:
-        client_callout_kind = "neutral"
-
-    client_callout = mo.callout(template_variant, kind=client_callout_kind)
-
-    client_callout
-    return (
-        APIClient,
-        Credentials,
-        client_callout,
-        client_callout_kind,
-        deployment_client,
-        # project_client,
-        task_credentials_details,
-        template_variant,
-        wx_credentials,
-    )
-
-
-@app.cell
-def _(mo, template_variant):
-    # Template for WatsonX.ai deployable function
-    if template_variant.value == "Stream Files to IBM COS [Example]":
-        with open("stream_files_to_cos.py", "r") as file:
-            template = file.read()
-    else:
-        template = '''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()
-            '''
-
-    function_editor = (
-        mo.md('''
-        #### **Create your function by editing the template:**
-
-        {editor}
-
-        ''')
-        .batch(
-            editor = mo.ui.code_editor(value=template, language="python", min_height=50)
-        )
-        .form(show_clear_button=True, bordered=False)
-        )
-
-    function_editor
-    return file, function_editor, template
-
-
-@app.cell
-def _(function_editor, mo, os):
-    if function_editor.value:
-        # Get the edited code from the function editor
-        code = function_editor.value['editor']
-        # Create a namespace to execute the code in
-        namespace = {}
-        # Execute the code
-        exec(code, namespace)
-
-        # Find the first function defined in the namespace
-        function_name = None
-        for name, obj in namespace.items():
-            if callable(obj) and name != "__builtins__":
-                function_name = name
-                break
-
-        if function_name:
-            # Instantiate the deployable function
-            deployable_function = namespace[function_name]
-            # Now deployable_function contains the score function
-            mo.md(f"Created deployable function from '{function_name}'")
-            # Create the directory if it doesn't exist
-            save_dir = "/tmp/notebook_functions"
-            os.makedirs(save_dir, exist_ok=True)
-            # Save the function code to a file
-            file_path = os.path.join(save_dir, f"{function_name}.py")
-            with open(file_path, "w") as f:
-                f.write(code)
-        else:
-            mo.md("No function found in the editor code")
-    return (
-        code,
-        deployable_function,
-        f,
-        file_path,
-        function_name,
-        name,
-        namespace,
-        obj,
-        save_dir,
-    )
-
-
-@app.cell
-def _(deployment_client, mo, pd):
-    if deployment_client:
-        supported_specs = deployment_client.software_specifications.list()[
-            deployment_client.software_specifications.list()['STATE'] == 'supported'
-        ]
-
-        # Reset the index to start from 0
-        supported_specs = supported_specs.reset_index(drop=True)
-
-        # Create a mapping dictionary for framework names based on software specifications
-        framework_mapping = {
-            "tensorflow_rt24.1-py3.11": "TensorFlow",
-            "pytorch-onnx_rt24.1-py3.11": "PyTorch",
-            "onnxruntime_opset_19": "ONNX or ONNXRuntime",
-            "runtime-24.1-py3.11": "AI Services/Python Functions/Python Scripts",
-            "autoai-ts_rt24.1-py3.11": "AutoAI",
-            "autoai-kb_rt24.1-py3.11": "AutoAI",
-            "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"
-        }
-
-        # Define the preferred order for items to appear at the top
-        preferred_order = [
-            "runtime-24.1-py3.11",
-            "runtime-24.1-py3.11-cuda",
-            "runtime-24.1-r4.3",
-            "ai-service-v5-software-specification",
-            "autoai-rag_rt24.1-py3.11",
-            "autoai-ts_rt24.1-py3.11",
-            "autoai-kb_rt24.1-py3.11",
-            "tensorflow_rt24.1-py3.11",
-            "pytorch-onnx_rt24.1-py3.11",
-            "onnxruntime_opset_19",
-            "spark-mllib_3.4",
-        ]
-
-        # 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)
-        )
-
-        # Sort the DataFrame by the new column
-        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'])
-
-        # Drop the REPLACEMENT column if it exists and add NOTES column
-        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")
-
-        # 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
-        )
-    else:
-        sel_df = pd.DataFrame(
-        data=[["ID", "Activate deployment_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",
-            initial_selection=[0]
-        )
-
-    # Display the table
-    mo.md(f"""---
-    <br>
-    <br>
-    {selection_table}
-    <br>
-    <br>
-    ---
-    <br>
-    <br>
-    """)
-    return (
-        framework_mapping,
-        preferred_order,
-        sel_df,
-        selection_table,
-        supported_specs,
-    )
-
-
-@app.cell
-def _(mo):
-    input_schema_checkbox = mo.ui.checkbox(label="Add input schema (optional)")
-    output_schema_checkbox = mo.ui.checkbox(label="Add output schema (optional)")
-    sample_input_checkbox = mo.ui.checkbox(label="Add sample input example (optional)")
-    return input_schema_checkbox, output_schema_checkbox, sample_input_checkbox
-
-
-@app.cell
-def _(
-    input_schema_checkbox,
-    mo,
-    output_schema_checkbox,
-    sample_input_checkbox,
-    selection_table,
-    template_variant,
-):
-    if selection_table.value['ID'].iloc[0]:
-        # Create the input fields
-        if template_variant.value == "Stream Files to IBM COS [Example]":
-            fnc_nm = "stream_file_to_cos"
-        else:
-            fnc_nm = "your_function_name"
-
-        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..."), mo.ui.text(), mo.ui.text()],
-            label="Optional Metadata Tags"
-        )
-        software_spec = selection_table.value['ID'].iloc[0]
-
-        description_input = mo.ui.text_area(
-            placeholder="Write a description for your function...)",
-            label="Description",
-            max_length=256,
-            rows=5,
-            full_width=True
-        )
-
-
-        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
-        )
-
-        schema_metadata=mo.hstack([
-            input_schema_checkbox,
-            output_schema_checkbox,
-            sample_input_checkbox
-        ],
-            justify="center", gap=1, align="center", wrap=True
-        )
-
-    # Display the metadata inputs
-    mo.vstack([
-        func_metadata,
-        mo.md("**Make sure to click the checkboxes before filling in descriptions and tags or they will reset.**"),
-        schema_metadata
-        ],
-        align="center",
-        gap=2
-    )
-    return (
-        description_input,
-        fnc_nm,
-        func_metadata,
-        schema_metadata,
-        software_spec,
-        tags_editor,
-        uploaded_function_name,
-    )
-
-
-@app.cell
-def _(json, mo):
-    if template_variant.value == "Stream Files to IBM COS [Example]":
-        from cos_stream_schema_examples import input_schema, output_schema, sample_input
-    else:
-        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': {}
-                    }
-                ]
-            }
-        ]
-
-        sample_input = {
-            'input_data': [
-                {
-                    'fields': ['<variable name 1>', '<variable name 2>'],
-                    'values': [
-                        ['<sample input value for variable 1>', '<sample input value for variable 2>']
-                    ]
-                }
-            ]
-        }
-
-
-    input_schema_editor = mo.ui.code_editor(value=json.dumps(input_schema, indent=4), language="python", min_height=25)
-    output_schema_editor = mo.ui.code_editor(value=json.dumps(output_schema, indent=4), language="python", min_height=25)
-    sample_input_editor = mo.ui.code_editor(value=json.dumps(sample_input, indent=4), language="python", min_height=25)
-
-    schema_editors = mo.accordion(
-        {
-            """**Input Schema Metadata Editor**""": input_schema_editor,
-            """**Output Schema Metadata Editor**""": output_schema_editor,
-            """**Sample Input Metadata Editor**""": sample_input_editor
-        }, multiple=True
-    )
-
-    schema_editors
-    return (
-        input_schema,
-        input_schema_editor,
-        output_schema,
-        output_schema_editor,
-        sample_input,
-        sample_input_editor,
-        schema_editors,
-    )
-
-
-@app.cell
-def _(
-    ast,
-    deployment_client,
-    description_input,
-    function_editor,
-    input_schema_checkbox,
-    input_schema_editor,
-    json,
-    mo,
-    os,
-    output_schema_checkbox,
-    output_schema_editor,
-    sample_input_checkbox,
-    sample_input_editor,
-    selection_table,
-    software_spec,
-    tags_editor,
-    uploaded_function_name,
-):
-    get_upload_status, set_upload_status = mo.state("No uploads yet")
-
-    function_meta = {}
-
-    if selection_table.value['ID'].iloc[0] and deployment_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"
-        }
-
-        # Add optional fields if they exist
-        if tags_editor.value:
-            # 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
-
-
-        if description_input.value:
-            function_meta[deployment_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)
-            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)
-
-        # 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)
-            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)
-
-        # 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=True):
-        """
-        Uploads a Python function to watsonx.ai as a deployable asset.
-        Parameters:
-        function_meta (dict): Metadata for the function
-        use_function_object (bool): Whether to use function object (True) or file path (False)
-        Returns:
-        dict: Details of the uploaded function
-        """
-        # Store the original working directory
-        original_dir = os.getcwd()
-
-        try:
-            # Create temp file from the code in the 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
-            function_meta[deployment_client.repository.FunctionMetaNames.NAME] = func_name
-            # Save the file locally first
-            save_dir = "/tmp/notebook_functions"
-            os.makedirs(save_dir, exist_ok=True)
-            file_path = f"{save_dir}/{func_name}.py"
-            with open(file_path, "w", encoding="utf-8") as f:
-                f.write(code_to_deploy)
-
-            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
-                spec = importlib.util.spec_from_file_location(func_name, file_path)
-                module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(module)
-                # Get the function object
-                function_object = getattr(module, func_name)
-
-                # Change to /tmp directory before calling IBM Watson SDK functions
-                os.chdir('/tmp')
-
-                # Upload the function object
-                mo.md(f"Uploading function object: {func_name}")
-                func_details = deployment_client.repository.store_function(function_object, function_meta)
-            else:
-                # Change to /tmp directory before calling IBM Watson SDK functions
-                os.chdir('/tmp')
-
-                # Upload using the file path approach
-                mo.md(f"Uploading function from file: {file_path}")
-                func_details = deployment_client.repository.store_function(file_path, function_meta)
-
-            set_upload_status(f"Latest Upload - id - {func_details['metadata']['id']}")
-            return func_details
-        except Exception as e:
-            set_upload_status(f"Error uploading function: {str(e)}")
-            mo.md(f"Detailed error: {str(e)}")
-            raise
-        finally:
-            # Always change back to the original directory, even if an exception occurs
-            os.chdir(original_dir)
-
-    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=True),
-        kind="success",
-        tooltip="Click to upload function to watsonx.ai"
-    )
-
-    function_meta
-    return (
-        filtered_tags,
-        function_meta,
-        get_upload_status,
-        set_upload_status,
-        upload_button,
-        upload_function,
-        upload_status,
-    )
-
-
-@app.cell
-def _(get_upload_status, mo, upload_button):
-    # Upload your function 
-    if upload_button.value:
-        try:
-            upload_result = upload_button.value
-            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")
-    return artifact_id, upload_func, upload_result
-
-
-@app.cell
-def _(deployment_client, mo, pd, upload_button, upload_func, uuid):
-    def reorder_hardware_specifications(df):
-        """
-        Reorders a hardware specifications dataframe by type and size of environment
-        without hardcoding specific hardware types.
-
-        Parameters:
-        df (pandas.DataFrame): The hardware specifications dataframe to reorder
-
-        Returns:
-        pandas.DataFrame: Reordered dataframe with reset index
-        """
-        # Create a copy to avoid modifying the original dataframe
-        result_df = df.copy()
-
-        # Define a function to extract the base type and size
-        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"
-            ]
-
-            # If name is in the custom order list, use its index
-            if name in custom_order:
-                return (0, custom_order.index(name))
-
-            # For any name not in the custom order, put it at the end
-            return (1, name)
-
-        # Add a temporary column for sorting
-        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)
-
-        # Reset the index
-        result_df = result_df.reset_index(drop=True)
-
-        return result_df
-
-    if deployment_client and upload_button.value:
-
-        hardware_specs = deployment_client.hardware_specifications.list()
-        hardware_specs_df = reorder_hardware_specifications(hardware_specs)
-
-        # Create a table with single-row selection
-        hw_selection_table = mo.ui.table(
-            hardware_specs_df,
-            selection="single",  # Only allow selecting one row
-            label="#### **Select a supported hardware_specification for your deployment** *(Default: 'XS' - 1vCPU_4GB Ram)*",
-            initial_selection=[1],
-            page_size=6,
-            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
-        )
-        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 deployment_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",
-            initial_selection=[0]
-        )
-
-
-    mo.md(f"""
-    <br>
-    <br>
-    {upload_func}
-    <br>
-    <br>
-    ---
-    {hw_selection_table}
-    <br>
-    <br>
-
-
-    """)
-    return (
-        deployment_name,
-        deployment_type,
-        hardware_specs,
-        hardware_specs_df,
-        hw_df,
-        hw_selection_table,
-        reorder_hardware_specifications,
-        uuid_suffix,
-    )
-
-
-@app.cell
-def _(
-    artifact_id,
-    deployment_client,
-    deployment_details,
-    deployment_name,
-    deployment_type,
-    hw_selection_table,
-    mo,
-    print,
-    upload_button,
-):
-    def deploy_function(artifact_id, deployment_type):
-        """
-        Deploys a function asset to watsonx.ai.
-
-        Parameters:
-        artifact_id (str): ID of the function artifact to deploy
-        deployment_type (object): Type of deployment (online or batch)
-
-        Returns:
-        dict: Details of the deployed function
-        """
-        if not artifact_id:
-            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)"
-            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,
-            }
-        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},
-                # 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)
-            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)
-            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)}")
-            return None
-
-    def get_deployment_id(deployed_function):
-        deployment_id = deployment_client.deployments.get_uid(deployment_details)
-        return deployment_id
-
-    def get_deployment_info(deployment_id):
-        deployment_info = deployment_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]
-
-    deploy_button = mo.ui.button(
-        label="Deploy Function",
-        on_click=lambda _: deploy_function(artifact_id, deployment_type),
-        kind="success",
-        tooltip="Click to deploy function to watsonx.ai"
-    )
-
-    if deployment_client and upload_button.value:
-        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
-    return (
-        deploy_button,
-        deploy_function,
-        deployment_definition,
-        deployment_status,
-        get_deployment_id,
-        get_deployment_info,
-        selected_hw_config,
-    )
-
-
-@app.cell
-def _(deploy_button, deployment_definition, mo):
-    _ = deployment_definition
-
-    deploy_fnc = mo.vstack([
-        deploy_button,
-        deploy_button.value
-    ], justify="space-around", align="center")
-
-    mo.md(f"""
-    {deployment_definition}
-    <br>
-    <br>
-    {deploy_fnc}
-
-    ---
-    """)
-    return (deploy_fnc,)
-
-
-@app.cell(hide_code=True)
-def _(deployment_client, mo):
-    ### Functions to List , Get ID's as a list and Purge of Assets
-
-    def get_deployment_list():
-        deployment_df = deployment_client.deployments.list()
-        return deployment_df
-
-    def get_deployment_ids(df):
-        dep_list = df['ID'].tolist()
-        return dep_list
-
-    def get_data_assets_list():
-        data_assets_df = deployment_client.data_assets.list()
-        return data_assets_df
-
-    def get_data_asset_ids(df):
-        data_asset_list = df['ASSET_ID'].tolist()
-        return data_asset_list
-
-    ### List Repository Assets, Get ID's as a list and Purge Repository Assets (AI Services, Functions, Models, etc.)
-    def get_repository_list():
-        repository_df = deployment_client.repository.list()
-        return repository_df
-
-    def get_repository_ids(df):
-        repository_list = df['ID'].tolist()
-        return repository_list
-
-    def delete_with_progress(ids_list, delete_function, item_type="items"):
-        """
-        Generic wrapper that adds a progress bar to any deletion function
-
-        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)
-        """
-        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}"
-        ) 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"
-
-    # Use with existing deletion functions
-    def delete_deployments(deployment_ids):
-        return delete_with_progress(
-            deployment_ids, 
-            lambda id: deployment_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),
-            "data assets"
-        )
-
-    def delete_repository_items(repository_ids):
-        return delete_with_progress(
-            repository_ids, 
-            lambda id: deployment_client.repository.delete(id),
-            "repository items"
-        )
-    return (
-        delete_data_assets,
-        delete_deployments,
-        delete_repository_items,
-        delete_with_progress,
-        get_data_asset_ids,
-        get_data_assets_list,
-        get_deployment_ids,
-        get_deployment_list,
-        get_repository_ids,
-        get_repository_list,
-    )
-
-
-@app.cell
-def _(get_deployment_id_list, get_deployments_button, mo, purge_deployments):
-    deployments_purge_stack = mo.hstack([get_deployments_button, get_deployment_id_list, purge_deployments])
-    deployments_purge_stack_results = mo.vstack([get_deployments_button.value, get_deployment_id_list.value, purge_deployments.value])
-
-    deployments_purge_tab = mo.vstack([deployments_purge_stack, deployments_purge_stack_results])
-    return (
-        deployments_purge_stack,
-        deployments_purge_stack_results,
-        deployments_purge_tab,
-    )
-
-
-@app.cell
-def _(get_repository_button, get_repository_id_list, mo, purge_repository):
-    repository_purge_stack = mo.hstack([get_repository_button, get_repository_id_list, purge_repository])
-
-    repository_purge_stack_results = mo.vstack([get_repository_button.value, get_repository_id_list.value, purge_repository.value])
-
-    repository_purge_tab = mo.vstack([repository_purge_stack, repository_purge_stack_results])
-    return (
-        repository_purge_stack,
-        repository_purge_stack_results,
-        repository_purge_tab,
-    )
-
-
-@app.cell
-def _(get_data_asset_id_list, get_data_assets_button, mo, purge_data_assets):
-    data_assets_purge_stack = mo.hstack([get_data_assets_button, get_data_asset_id_list, purge_data_assets])
-    data_assets_purge_stack_results = mo.vstack([get_data_assets_button.value, get_data_asset_id_list.value, purge_data_assets.value])
-
-    data_assets_purge_tab = mo.vstack([data_assets_purge_stack, data_assets_purge_stack_results])
-    return (
-        data_assets_purge_stack,
-        data_assets_purge_stack_results,
-        data_assets_purge_tab,
-    )
-
-
-@app.cell
-def _(data_assets_purge_tab, deployments_purge_tab, mo, repository_purge_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
-    )
-
-    asset_purge = mo.accordion(
-        {
-            """<br>
-    #### **Supporting Cleanup Functionality, lists of different assets and purge them if needed** *(purges all detected)*
-    <br>""": purge_tabs,
-        }
-    )
-
-    asset_purge
-    return asset_purge, purge_tabs
-
-
-@app.cell(hide_code=True)
-def _(
-    delete_data_assets,
-    delete_deployments,
-    delete_repository_items,
-    get_data_asset_ids,
-    get_data_assets_list,
-    get_deployment_ids,
-    get_deployment_list,
-    get_repository_ids,
-    get_repository_list,
-    mo,
-):
-    ### Temporary Function Purge - Assets
-    get_data_assets_button = mo.ui.button(
-        label="Get Data Assets Dataframe",
-        on_click=lambda _: get_data_assets_list(),
-        kind="neutral",
-    )
-
-    get_data_asset_id_list = mo.ui.button(
-        label="Turn Dataframe into List of IDs",
-        on_click=lambda _: get_data_asset_ids(get_data_assets_button.value),
-        kind="neutral",
-    )
-
-    purge_data_assets = mo.ui.button(
-        label="Purge Data Assets",
-        on_click=lambda _: delete_data_assets(get_data_asset_id_list.value),
-        kind="danger",
-    )
-
-    ### Temporary Function Purge - Deployments
-    get_deployments_button = mo.ui.button(
-        label="Get Deployments Dataframe",
-        on_click=lambda _: get_deployment_list(),
-        kind="neutral",
-    )
-
-    get_deployment_id_list = mo.ui.button(
-        label="Turn Dataframe into List of IDs",
-        on_click=lambda _: get_deployment_ids(get_deployments_button.value),
-        kind="neutral",
-    )
-
-    purge_deployments = mo.ui.button(
-        label="Purge Deployments",
-        on_click=lambda _: delete_deployments(get_deployment_id_list.value),
-        kind="danger",
-    )
-
-    ### Repository Items Purge
-    get_repository_button = mo.ui.button(
-        label="Get Repository Dataframe",
-        on_click=lambda _: get_repository_list(),
-        kind="neutral",
-    )
-
-    get_repository_id_list = mo.ui.button(
-        label="Turn Dataframe into List of IDs",
-        on_click=lambda _: get_repository_ids(get_repository_button.value),
-        kind="neutral",
-    )
-
-    purge_repository = mo.ui.button(
-        label="Purge Repository Items",
-        on_click=lambda _: delete_repository_items(get_repository_id_list.value),
-        kind="danger",
-    )
-    return (
-        get_data_asset_id_list,
-        get_data_assets_button,
-        get_deployment_id_list,
-        get_deployments_button,
-        get_repository_button,
-        get_repository_id_list,
-        purge_data_assets,
-        purge_deployments,
-        purge_repository,
-    )
-
-
-if __name__ == "__main__":
-    app.run()