Update app.py

app.py

@@ -1,469 +1,1138 @@
 import marimo
 
-__generated_with = "0.9.2"
-app = marimo.App()
+__generated_with = "0.11.17"
+app = marimo.App(width="medium")
 
 
 @app.cell
-def __():
+def _():
     import marimo as mo
-
-    mo.md("# Welcome to marimo! 🌊🍃")
-    return (mo,)
+    import os
+    return mo, os
 
 
 @app.cell
-def __(mo):
-    slider = mo.ui.slider(1, 22)
-    return (slider,)
+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, slider):
-    mo.md(
-        f"""
-        marimo is a **reactive** Python notebook.
+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"
+    }
 
-        This means that unlike traditional notebooks, marimo notebooks **run
-        automatically** when you modify them or
-        interact with UI elements, like this slider: {slider}.
+    # Create a form with multiple elements
+    client_instantiation_form = (
+        mo.md('''
+        ###**watsonx.ai credentials:**
 
-        {"##" + "🍃" * slider.value}
-        """
-    )
-    return
+        {wx_region}
 
+        {wx_api_key}
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: disabling automatic execution": mo.md(
-                rf"""
-            marimo lets you disable automatic execution: just go into the
-            notebook settings and set
-
-            "Runtime > On Cell Change" to "lazy".
-
-            When the runtime is lazy, after running a cell, marimo marks its
-            descendants as stale instead of automatically running them. The
-            lazy runtime puts you in control over when cells are run, while
-            still giving guarantees about the notebook state.
-            """
-            )
-        }
+        {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)
     )
-    return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        Tip: This is a tutorial notebook. You can create your own notebooks
-        by entering `marimo edit` at the command line.
-        """
-    ).callout()
-    return
+    client_instantiation_form
+    return client_instantiation_form, regions, wx_platform_url
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 1. Reactive execution
+@app.cell
+def _(client_instantiation_form, mo):
+    from ibm_watsonx_ai import APIClient, Credentials
+
+    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"]
+        )
 
-        A marimo notebook is made up of small blocks of Python code called
-        cells.
+        # 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 = deployment_client.task_credentials.store()
+    else:
+        # project_client = None
+        deployment_client = None
+        task_credentials_details = None
+
+    template_variant = mo.ui.dropdown(["Base","Get Watsonx Token - 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,
+    )
 
-        marimo reads your cells and models the dependencies among them: whenever
-        a cell that defines a global variable  is run, marimo
-        **automatically runs** all cells that reference that variable.
 
-        Reactivity keeps your program state and outputs in sync with your code,
-        making for a dynamic programming environment that prevents bugs before they
-        happen.
-        """
+@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,
     )
-    return
 
 
-@app.cell(hide_code=True)
-def __(changed, mo):
-    (
-        mo.md(
-            f"""
-            **✨ Nice!** The value of `changed` is now {changed}.
-
-            When you updated the value of the variable `changed`, marimo
-            **reacted** by running this cell automatically, because this cell
-            references the global variable `changed`.
-
-            Reactivity ensures that your notebook state is always
-            consistent, which is crucial for doing good science; it's also what
-            enables marimo notebooks to double as tools and  apps.
-            """
+@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)
         )
-        if changed
-        else mo.md(
-            """
-            **🌊 See it in action.** In the next cell, change the value of the
-            variable  `changed` to `True`, then click the run button.
-            """
+
+        # 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,
     )
-    return
 
 
 @app.cell
-def __():
-    changed = False
-    return (changed,)
+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(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: execution order": (
-                """
-                The order of cells on the page has no bearing on
-                the order in which cells are executed: marimo knows that a cell
-                reading a variable must run after the cell that  defines it. This
-                frees you to organize your code in the way that makes the most
-                sense for you.
-                """
-            )
-        }
-    )
-    return
+@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
+        )
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        **Global names must be unique.** To enable reactivity, marimo imposes a
-        constraint on how names appear in cells: no two cells may define the same
-        variable.
-        """
-    )
-    return
+        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
+        )
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: encapsulation": (
-                """
-                By encapsulating logic in functions, classes, or Python modules,
-                you can minimize the number of global variables in your notebook.
-                """
-            )
-        }
+    # 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,
     )
-    return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: private variables": (
-                """
-                Variables prefixed with an underscore are "private" to a cell, so
-                they can be defined by multiple cells.
-                """
-            )
+@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>']
+                    ]
+                }
+            ]
         }
-    )
-    return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 2. UI elements
+    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)
 
-        Cells can output interactive UI elements. Interacting with a UI
-        element **automatically triggers notebook execution**: when
-        you interact with a UI element, its value is sent back to Python, and
-        every cell that references that element is re-run.
+    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
+    )
 
-        marimo provides a library of UI elements to choose from under
-        `marimo.ui`.
-        """
+    schema_editors
+    return (
+        input_schema,
+        input_schema_editor,
+        output_schema,
+        output_schema_editor,
+        sample_input,
+        sample_input_editor,
+        schema_editors,
     )
-    return
 
 
 @app.cell
-def __(mo):
-    mo.md("""**🌊 Some UI elements.** Try interacting with the below elements.""")
-    return
+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"
+    )
 
-@app.cell
-def __(mo):
-    icon = mo.ui.dropdown(["🍃", "🌊", "✨"], value="🍃")
-    return (icon,)
+    function_meta
+    return (
+        filtered_tags,
+        function_meta,
+        get_upload_status,
+        set_upload_status,
+        upload_button,
+        upload_function,
+        upload_status,
+    )
 
 
 @app.cell
-def __(icon, mo):
-    repetitions = mo.ui.slider(1, 16, label=f"number of {icon.value}: ")
-    return (repetitions,)
+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 __(icon, repetitions):
-    icon, repetitions
-    return
+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
 
-@app.cell
-def __(icon, mo, repetitions):
-    mo.md("# " + icon.value * repetitions.value)
-    return
+        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]
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 3. marimo is just Python
+        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"]
+        )
 
-        marimo cells parse Python (and only Python), and marimo notebooks are
-        stored as pure Python files — outputs are _not_ included. There's no
-        magical syntax.
+        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]
+        )
 
-        The Python files generated by marimo are:
 
-        - easily versioned with git, yielding minimal diffs
-        - legible for both humans and machines
-        - formattable using your tool of choice,
-        - usable as Python  scripts, with UI  elements taking their default
-        values, and
-        - importable by other modules (more on that in the future).
-        """
+    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,
     )
-    return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
+@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):
         """
-        ## 4. Running notebooks as apps
+        Deploys a function asset to watsonx.ai.
 
-        marimo notebooks can double as apps. Click the app window icon in the
-        bottom-right to see this notebook in "app view."
+        Parameters:
+        artifact_id (str): ID of the function artifact to deploy
+        deployment_type (object): Type of deployment (online or batch)
 
-        Serve a notebook as an app with `marimo run` at the command-line.
-        Of course, you can use marimo just to level-up your
-        notebooking, without ever making apps.
+        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"
     )
-    return
 
+    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(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 5. The `marimo` command-line tool
 
-        **Creating and editing notebooks.** Use
+@app.cell
+def _(deploy_button, deployment_definition, mo):
+    _ = deployment_definition
 
-        ```
-        marimo edit
-        ```
+    deploy_fnc = mo.vstack([
+        deploy_button,
+        deploy_button.value
+    ], justify="space-around", align="center")
 
-        in a terminal to start the marimo notebook server. From here
-        you can create a new notebook or edit existing ones.
+    mo.md(f"""
+    {deployment_definition}
+    <br>
+    <br>
+    {deploy_fnc}
 
+    ---
+    """)
+    return (deploy_fnc,)
 
-        **Running as apps.** Use
 
-        ```
-        marimo run notebook.py
-        ```
+@app.cell(hide_code=True)
+def _(deployment_client, mo):
+    ### Functions to List , Get ID's as a list and Purge of Assets
 
-        to start a webserver that serves your notebook as an app in read-only mode,
-        with code cells hidden.
+    def get_deployment_list():
+        deployment_df = deployment_client.deployments.list()
+        return deployment_df
 
-        **Convert a Jupyter notebook.** Convert a Jupyter notebook to a marimo
-        notebook using `marimo convert`:
+    def get_deployment_ids(df):
+        dep_list = df['ID'].tolist()
+        return dep_list
 
-        ```
-        marimo convert your_notebook.ipynb > your_app.py
-        ```
+    def get_data_assets_list():
+        data_assets_df = deployment_client.data_assets.list()
+        return data_assets_df
 
-        **Tutorials.** marimo comes packaged with tutorials:
+    def get_data_asset_ids(df):
+        data_asset_list = df['ASSET_ID'].tolist()
+        return data_asset_list
 
-        - `dataflow`: more on marimo's automatic execution
-        - `ui`: how to use UI elements
-        - `markdown`: how to write markdown, with interpolated values and
-           LaTeX
-        - `plots`: how plotting works in marimo
-        - `sql`: how to use SQL
-        - `layout`: layout elements in marimo
-        - `fileformat`: how marimo's file format works
-        - `markdown-format`: for using `.md` files in marimo
-        - `for-jupyter-users`: if you are coming from Jupyter
+    ### 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
 
-        Start a tutorial with `marimo tutorial`; for example,
+    def get_repository_ids(df):
+        repository_list = df['ID'].tolist()
+        return repository_list
 
-        ```
-        marimo tutorial dataflow
-        ```
+    def delete_with_progress(ids_list, delete_function, item_type="items"):
+        """
+        Generic wrapper that adds a progress bar to any deletion function
 
-        In addition to tutorials, we have examples in our
-        [our GitHub repo](https://www.github.com/marimo-team/marimo/tree/main/examples).
+        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,
     )
-    return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 6. The marimo editor
+@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,
+    )
 
-        Here are some tips to help you get started with the marimo editor.
-        """
+
+@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,
     )
-    return
 
 
 @app.cell
-def __(mo, tips):
-    mo.accordion(tips)
-    return
+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(hide_code=True)
-def __(mo):
-    mo.md("""## Finally, a fun fact""")
-    return
+@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 __(mo):
-    mo.md(
-        """
-        The name "marimo" is a reference to a type of algae that, under
-        the right conditions, clumps together to form a small sphere
-        called a "marimo moss ball". Made of just strands of algae, these
-        beloved assemblages are greater than the sum of their parts.
-        """
+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",
     )
-    return
 
+    purge_data_assets = mo.ui.button(
+        label="Purge Data Assets",
+        on_click=lambda _: delete_data_assets(get_data_asset_id_list.value),
+        kind="danger",
+    )
 
-@app.cell(hide_code=True)
-def __():
-    tips = {
-        "Saving": (
-            """
-            **Saving**
-
-            - _Name_ your app using the box at the top of the screen, or
-              with `Ctrl/Cmd+s`. You can also create a named app at the
-              command line, e.g., `marimo edit app_name.py`.
-
-            - _Save_ by clicking the save icon on the bottom right, or by
-              inputting `Ctrl/Cmd+s`. By default marimo is configured
-              to autosave.
-            """
-        ),
-        "Running": (
-            """
-            1. _Run a cell_ by clicking the play ( ▷ ) button on the top
-            right of a cell, or by inputting `Ctrl/Cmd+Enter`.
-
-            2. _Run a stale cell_  by clicking the yellow run button on the
-            right of the cell, or by inputting `Ctrl/Cmd+Enter`. A cell is
-            stale when its code has been modified but not run.
-
-            3. _Run all stale cells_ by clicking the play ( ▷ ) button on
-            the bottom right of the screen, or input `Ctrl/Cmd+Shift+r`.
-            """
-        ),
-        "Console Output": (
-            """
-            Console output (e.g., `print()` statements) is shown below a
-            cell.
-            """
-        ),
-        "Creating, Moving, and Deleting Cells": (
-            """
-            1. _Create_ a new cell above or below a given one by clicking
-                the plus button to the left of the cell, which appears on
-                mouse hover.
-
-            2. _Move_ a cell up or down by dragging on the handle to the 
-                right of the cell, which appears on mouse hover.
-
-            3. _Delete_ a cell by clicking the trash bin icon. Bring it
-                back by clicking the undo button on the bottom right of the
-                screen, or with `Ctrl/Cmd+Shift+z`.
-            """
-        ),
-        "Disabling Automatic Execution": (
-            """
-            Via the notebook settings (gear icon) or footer panel, you
-            can disable automatic execution. This is helpful when
-            working with expensive notebooks or notebooks that have
-            side-effects like database transactions.
-            """
-        ),
-        "Disabling Cells": (
-            """
-            You can disable a cell via the cell context menu.
-            marimo will never run a disabled cell or any cells that depend on it.
-            This can help prevent accidental execution of expensive computations
-            when editing a notebook.
-            """
-        ),
-        "Code Folding": (
-            """
-            You can collapse or fold the code in a cell by clicking the arrow
-            icons in the line number column to the left, or by using keyboard
-            shortcuts.
-
-            Use the command palette (`Ctrl/Cmd+k`) or a keyboard shortcut to
-            quickly fold or unfold all cells.
-            """
-        ),
-        "Code Formatting": (
-            """
-            If you have [ruff](https://github.com/astral-sh/ruff) installed,
-            you can format a cell with the keyboard shortcut `Ctrl/Cmd+b`.
-            """
-        ),
-        "Command Palette": (
-            """
-            Use `Ctrl/Cmd+k` to open the command palette.
-            """
-        ),
-        "Keyboard Shortcuts": (
-            """
-            Open the notebook menu (top-right) or input `Ctrl/Cmd+Shift+h` to
-            view a list of all keyboard shortcuts.
-            """
-        ),
-        "Configuration": (
-            """
-           Configure the editor by clicking the gears icon near the top-right
-           of the screen.
-           """
-        ),
-    }
-    return (tips,)
+    ### 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__":