ivoryos 1.0.8__py3-none-any.whl → 1.1.0__py3-none-any.whl

ivoryos/routes/design/design.py

@@ -1,81 +1,36 @@
-import csv
-import json
 import os
-import pickle
-import sys
-import time
 
-from flask import Blueprint, redirect, url_for, flash, jsonify, send_file, request, render_template, session, \
-    current_app, g
+from flask import Blueprint, redirect, url_for, flash, jsonify, request, render_template, session, \
+    current_app
 from flask_login import login_required
-from flask_socketio import SocketIO
-from werkzeug.utils import secure_filename
 
+from ivoryos.routes.library.library import publish
 from ivoryos.utils import utils
 from ivoryos.utils.global_config import GlobalConfig
-from ivoryos.utils.form import create_builtin_form, create_action_button, format_name, create_form_from_pseudo, \
+from ivoryos.utils.form import create_action_button, format_name, create_form_from_pseudo, \
     create_form_from_action, create_all_builtin_forms
-from ivoryos.utils.db_models import Script, WorkflowRun, SingleStep, WorkflowStep
+from ivoryos.utils.db_models import Script
+from ivoryos.utils.py_to_json import convert_to_cards
 from ivoryos.utils.script_runner import ScriptRunner
-# from ivoryos.utils.utils import load_workflows
 
-socketio = SocketIO()
-design = Blueprint('design', __name__, template_folder='templates/design')
+# Import the new modular components
+from ivoryos.routes.design.design_file import files
+from ivoryos.routes.design.design_step import steps
 
-global_config = GlobalConfig()
-runner = ScriptRunner()
-
-def abort_pending():
-    runner.abort_pending()
-    socketio.emit('log', {'message': "aborted pending iterations"})
-
-def abort_current():
-    runner.stop_execution()
-    socketio.emit('log', {'message': "stopped next task"})
-
-def pause():
-    runner.retry = False
-    msg = runner.toggle_pause()
-    socketio.emit('log', {'message': msg})
-    return msg
-
-def retry():
-    runner.retry = True
-    msg = runner.toggle_pause()
-    socketio.emit('log', {'message': msg})
-
-
-# ---- Socket.IO Event Handlers ----
-
-@socketio.on('abort_pending')
-def handle_abort_pending():
-    abort_pending()
-
-@socketio.on('abort_current')
-def handle_abort_current():
-    abort_current()
+# from ...utils.py_to_json import convert_to_cards
 
-@socketio.on('pause')
-def handle_pause():
-    pause()
+design = Blueprint('design', __name__, template_folder='templates')
 
-@socketio.on('retry')
-def handle_retry():
-    retry()
+# Register sub-blueprints
+design.register_blueprint(files)
+design.register_blueprint(steps)
 
+global_config = GlobalConfig()
 
-@socketio.on('connect')
-def handle_abort_action():
-    # Fetch log messages from local file
-    filename = os.path.join(current_app.config["OUTPUT_FOLDER"], current_app.config["LOGGERS_PATH"])
-    with open(filename, 'r') as log_file:
-        log_history = log_file.readlines()
-    for message in log_history[-10:]:
-        socketio.emit('log', {'message': message})
-
+# ---- Main Design Routes ----
 
-@design.route("/design/script/", methods=['GET', 'POST'])
-@design.route("/design/script/<instrument>/", methods=['GET', 'POST'])
+@design.route("/script/", methods=['GET', 'POST'])
+@design.route("/script/<instrument>/", methods=['GET', 'POST'])
 @login_required
 def experiment_builder(instrument=None):
     """
@@ -114,13 +69,10 @@ def experiment_builder(instrument=None):
     """
     deck = global_config.deck
     script = utils.get_script_file()
-    # load_workflows(script)
-    # registered_workflows = global_config.registered_workflows
 
     if deck and script.deck is None:
         script.deck = os.path.splitext(os.path.basename(deck.__file__))[
             0] if deck.__name__ == "__main__" else deck.__name__
-    # script.sort_actions()
 
     pseudo_deck_name = session.get('pseudo_deck', '')
     pseudo_deck_path = os.path.join(current_app.config["DUMMY_DECK"], pseudo_deck_name)
@@ -140,24 +92,17 @@ def experiment_builder(instrument=None):
     functions = {}
     if deck:
         deck_variables = list(global_config.deck_snapshot.keys())
-        # deck_variables.insert(0, "registered_workflows")
         deck_variables.insert(0, "flow_control")
-
     else:
         deck_variables = list(pseudo_deck.keys()) if pseudo_deck else []
         deck_variables.remove("deck_name") if len(deck_variables) > 0 else deck_variables
+    
     edit_action_info = session.get("edit_action")
     if edit_action_info:
         forms = create_form_from_action(edit_action_info, script=script)
     elif instrument:
-        # if instrument in ['if', 'while', 'variable', 'wait', 'repeat']:
-        #     forms = create_builtin_form(instrument, script=script)
         if instrument == 'flow_control':
             forms = create_all_builtin_forms(script=script)
-        # elif instrument == 'registered_workflows':
-        #     functions = utils._inspect_class(registered_workflows)
-        #     # forms = create_workflow_forms(script=script)
-        #     forms = create_form_from_pseudo(pseudo=functions, autofill=autofill, script=script)
         elif instrument in global_config.defined_variables.keys():
             _object = global_config.defined_variables.get(instrument)
             functions = utils._inspect_class(_object)
@@ -168,69 +113,71 @@ def experiment_builder(instrument=None):
             elif pseudo_deck:
                 functions = pseudo_deck.get(instrument, {})
             forms = create_form_from_pseudo(pseudo=functions, autofill=autofill, script=script)
+        
         if request.method == 'POST' and "hidden_name" in request.form:
-            # all_kwargs = request.form.copy()
             method_name = request.form.get("hidden_name", None)
-            # if method_name is not None:
-            form = forms.get(method_name)
+            form = forms.get(method_name) if forms else None
             insert_position = request.form.get("drop_target_id", None)
-            kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
-            if form and form.validate_on_submit():
-                function_name = kwargs.pop("hidden_name")
-                save_data = kwargs.pop('return', '')
-
-                primitive_arg_types = utils.get_arg_type(kwargs, functions[function_name])
-
-                script.eval_list(kwargs, primitive_arg_types)
-                kwargs = script.validate_variables(kwargs)
-                action = {"instrument": instrument, "action": function_name,
-                          "args": kwargs,
-                          "return": save_data,
-                          'arg_types': primitive_arg_types}
-                script.add_action(action=action, insert_position=insert_position)
-            else:
-                flash(form.errors)
+            
+            if form:
+                kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
+                if form.validate_on_submit():
+                    function_name = kwargs.pop("hidden_name")
+                    save_data = kwargs.pop('return', '')
+
+                    primitive_arg_types = utils.get_arg_type(kwargs, functions[function_name])
+
+                    script.eval_list(kwargs, primitive_arg_types)
+                    kwargs = script.validate_variables(kwargs)
+                    action = {"instrument": instrument, "action": function_name,
+                              "args": kwargs,
+                              "return": save_data,
+                              'arg_types': primitive_arg_types}
+                    script.add_action(action=action, insert_position=insert_position)
+                else:
+                    flash(form.errors)
 
         elif request.method == 'POST' and "builtin_name" in request.form:
             function_name = request.form.get("builtin_name")
-            form = forms.get(function_name)
-            kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
+            form = forms.get(function_name) if forms else None
             insert_position = request.form.get("drop_target_id", None)
 
-            if form.validate_on_submit():
-                # print(kwargs)
-                logic_type = kwargs.pop('builtin_name')
-                if 'variable' in kwargs:
-                    try:
-                        script.add_variable(insert_position=insert_position, **kwargs)
-                    except ValueError:
-                        flash("Invalid variable type")
+            if form:
+                kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
+                if form.validate_on_submit():
+                    logic_type = kwargs.pop('builtin_name')
+                    if 'variable' in kwargs:
+                        try:
+                            script.add_variable(insert_position=insert_position, **kwargs)
+                        except ValueError:
+                            flash("Invalid variable type")
+                    else:
+                        script.add_logic_action(logic_type=logic_type, insert_position=insert_position, **kwargs)
                 else:
-                    script.add_logic_action(logic_type=logic_type, insert_position=insert_position, **kwargs)
-            else:
-                flash(form.errors)
+                    flash(form.errors)
+                    
         elif request.method == 'POST' and "workflow_name" in request.form:
             workflow_name = request.form.get("workflow_name")
-            form = forms.get(workflow_name)
-            kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
+            form = forms.get(workflow_name) if forms else None
             insert_position = request.form.get("drop_target_id", None)
 
-            if form.validate_on_submit():
-                # workflow_name = kwargs.pop('workflow_name')
-                save_data = kwargs.pop('return', '')
-
-                primitive_arg_types = utils.get_arg_type(kwargs, functions[workflow_name])
-
-                script.eval_list(kwargs, primitive_arg_types)
-                kwargs = script.validate_variables(kwargs)
-                action = {"instrument": instrument, "action": workflow_name,
-                          "args": kwargs,
-                          "return": save_data,
-                          'arg_types': primitive_arg_types}
-                script.add_action(action=action, insert_position=insert_position)
-                script.add_workflow(**kwargs, insert_position=insert_position)
-            else:
-                flash(form.errors)
+            if form:
+                kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
+                if form.validate_on_submit():
+                    save_data = kwargs.pop('return', '')
+
+                    primitive_arg_types = utils.get_arg_type(kwargs, functions[workflow_name])
+
+                    script.eval_list(kwargs, primitive_arg_types)
+                    kwargs = script.validate_variables(kwargs)
+                    action = {"instrument": instrument, "action": workflow_name,
+                              "args": kwargs,
+                              "return": save_data,
+                              'arg_types': primitive_arg_types}
+                    script.add_action(action=action, insert_position=insert_position)
+                    script.add_workflow(**kwargs, insert_position=insert_position)
+                else:
+                    flash(form.errors)
 
         # toggle autofill, autofill doesn't apply to control flow ops
         elif request.method == 'POST' and "autofill" in request.form:
@@ -252,7 +199,7 @@ def experiment_builder(instrument=None):
                            use_llm=enable_llm)
 
 
-@design.route("/design/generate_code", methods=['POST'])
+@design.route("/generate_code", methods=['POST'])
 @login_required
 def generate_code():
     """
@@ -274,7 +221,6 @@ def generate_code():
     if request.method == 'POST' and "gen" in request.form:
         prompt = request.form.get("prompt")
         session['prompt'][instrument] = prompt
-        # sdl_module = utils.parse_functions(find_instrument_by_name(f'deck.{instrument}'), doc_string=True)
         sdl_module = global_config.deck_snapshot.get(instrument, {})
         empty_script = Script(author=session.get('user'))
         if enable_llm and agent is None:
@@ -300,134 +246,8 @@ def generate_code():
     return redirect(url_for("design.experiment_builder", instrument=instrument, use_llm=True))
 
 
-@design.route("/design/campaign", methods=['GET', 'POST'])
-@login_required
-def experiment_run():
-    """
-    .. :quickref: Workflow Execution; Execute/iterate the workflow
-
-    .. http:get:: /design/campaign
-
-    Compile the workflow and load the experiment execution interface.
-
-    .. http:post:: /design/campaign
-
-    Start workflow execution
-
-    """
-    deck = global_config.deck
-    script = utils.get_script_file()
-
-    # script.sort_actions() # handled in update list
-    off_line = current_app.config["OFF_LINE"]
-    deck_list = utils.import_history(os.path.join(current_app.config["OUTPUT_FOLDER"], 'deck_history.txt'))
-    # if not off_line and deck is None:
-    #     # print("loading deck")
-    #     module = current_app.config.get('MODULE', '')
-    #     deck = sys.modules[module] if module else None
-    #     script.deck = os.path.splitext(os.path.basename(deck.__file__))[0]
-    design_buttons = {stype: create_action_button(script, stype) for stype in script.stypes}
-    config_preview = []
-    config_file_list = [i for i in os.listdir(current_app.config["CSV_FOLDER"]) if not i == ".gitkeep"]
-    try:
-        # todo
-        exec_string = script.python_script if script.python_script else script.compile(current_app.config['SCRIPT_FOLDER'])
-        # exec_string = script.compile(current_app.config['SCRIPT_FOLDER'])
-        # print(exec_string)
-    except Exception as e:
-        flash(e.__str__())
-        # handle api request
-        if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-            return jsonify({"error": e.__str__()})
-        else:
-            return redirect(url_for("design.experiment_builder"))
-
-    config_file = request.args.get("filename")
-    config = []
-    if config_file:
-        session['config_file'] = config_file
-    filename = session.get("config_file")
-    if filename:
-        # config_preview = list(csv.DictReader(open(os.path.join(current_app.config['CSV_FOLDER'], filename))))
-        config = list(csv.DictReader(open(os.path.join(current_app.config['CSV_FOLDER'], filename))))
-        config_preview = config[1:]
-        arg_type = config.pop(0)  # first entry is types
-    try:
-        for key, func_str in exec_string.items():
-            exec(func_str)
-        line_collection = script.convert_to_lines(exec_string)
-
-    except Exception:
-        flash(f"Please check {key} syntax!!")
-        return redirect(url_for("design.experiment_builder"))
-    # runner.globals_dict.update(globals())
-    run_name = script.name if script.name else "untitled"
-
-    dismiss = session.get("dismiss", None)
-    script = utils.get_script_file()
-    no_deck_warning = False
-
-    _, return_list = script.config_return()
-    config_list, config_type_list = script.config("script")
-    # config = script.config("script")
-    data_list = os.listdir(current_app.config['DATA_FOLDER'])
-    data_list.remove(".gitkeep") if ".gitkeep" in data_list else data_list
-    if deck is None:
-        no_deck_warning = True
-        flash(f"No deck is found, import {script.deck}")
-    elif script.deck:
-        is_deck_match = script.deck == deck.__name__ or script.deck == \
-                        os.path.splitext(os.path.basename(deck.__file__))[0]
-        if not is_deck_match:
-            flash(f"This script is not compatible with current deck, import {script.deck}")
-    if request.method == "POST":
-        bo_args = None
-        compiled = False
-        if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-            payload_json = request.get_json()
-            compiled = True
-            if "kwargs" in payload_json:
-                config = payload_json["kwargs"]
-            elif "parameters" in payload_json:
-                bo_args = payload_json
-            repeat = payload_json.pop("repeat", None)
-        else:
-            if "bo" in request.form:
-                bo_args = request.form.to_dict()
-            if "online-config" in request.form:
-                config = utils.web_config_entry_wrapper(request.form.to_dict(), config_list)
-            repeat = request.form.get('repeat', None)
 
-        try:
-            datapath = current_app.config["DATA_FOLDER"]
-            run_name = script.validate_function_name(run_name)
-            runner.run_script(script=script, run_name=run_name, config=config, bo_args=bo_args,
-                              logger=g.logger, socketio=g.socketio, repeat_count=repeat,
-                              output_path=datapath, compiled=compiled,
-                              current_app=current_app._get_current_object()
-                              )
-            if utils.check_config_duplicate(config):
-                flash(f"WARNING: Duplicate in config entries.")
-        except Exception as e:
-            if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-                return jsonify({"error": e.__str__()})
-            else:
-                flash(e)
-    if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-        # wait to get a workflow ID
-        while not global_config.runner_status:
-            time.sleep(1)
-        return jsonify({"status": "task started", "task_id": global_config.runner_status.get("id")})
-    else:
-        return render_template('experiment_run.html', script=script.script_dict, filename=filename,
-                           dot_py=exec_string, line_collection=line_collection,
-                           return_list=return_list, config_list=config_list, config_file_list=config_file_list,
-                           config_preview=config_preview, data_list=data_list, config_type_list=config_type_list,
-                           no_deck_warning=no_deck_warning, dismiss=dismiss, design_buttons=design_buttons,
-                           history=deck_list, pause_status=runner.pause_status())
-
-
-@design.route("/design/script/toggle/<stype>")
+@design.route("/script/toggle/<stype>")
 @login_required
 def toggle_script_type(stype=None):
     """
@@ -465,7 +285,7 @@ def toggle_show_code():
 
 
 # --------------------handle all the import/export and download/upload--------------------------
-@design.route("/design/clear")
+@design.route("/clear")
 @login_required
 def clear():
     """
@@ -490,7 +310,7 @@ def clear():
     return redirect(url_for("design.experiment_builder"))
 
 
-@design.route("/design/import/pseudo", methods=['POST'])
+@design.route("/import/pseudo", methods=['POST'])
 @login_required
 def import_pseudo():
     """
@@ -513,274 +333,33 @@ def import_pseudo():
     return redirect(url_for("design.experiment_builder"))
 
 
-@design.route('/design/uploads', methods=['POST'])
-@login_required
-def upload():
-    """
-    .. :quickref: Workflow Execution; upload a workflow config file (.CSV)
-
-    .. http:post:: /design/uploads
-
-    :form file: workflow CSV config file
-    :status 302: save csv file and then redirects to :http:get:`/design/campaign`
-    """
-    if request.method == "POST":
-        f = request.files['file']
-        if 'file' not in request.files:
-            flash('No file part')
-        if f.filename.split('.')[-1] == "csv":
-            filename = secure_filename(f.filename)
-            f.save(os.path.join(current_app.config['CSV_FOLDER'], filename))
-            session['config_file'] = filename
-            return redirect(url_for("design.experiment_run"))
-        else:
-            flash("Config file is in csv format")
-            return redirect(url_for("design.experiment_run"))
-
-
-@design.route('/design/workflow/download/<filename>')
-@login_required
-def download_results(filename):
-    """
-    .. :quickref: Workflow Design; download a workflow data file
-
-    .. http:get:: /design/workflow/download/<filename>
-
-    """
-    filepath = os.path.join(current_app.config["DATA_FOLDER"], filename)
-    return send_file(os.path.abspath(filepath), as_attachment=True)
-
-
-@design.route('/design/load_json', methods=['POST'])
-@login_required
-def load_json():
-    """
-    .. :quickref: Workflow Design Ext; upload a workflow design file (.JSON)
-
-    .. http:post:: /load_json
-
-    :form file: workflow design JSON file
-    :status 302: load pseudo deck and then redirects to :http:get:`/design/script`
-    """
-    if request.method == "POST":
-        f = request.files['file']
-        if 'file' not in request.files:
-            flash('No file part')
-        if f.filename.endswith("json"):
-            script_dict = json.load(f)
-            utils.post_script_file(script_dict, is_dict=True)
-        else:
-            flash("Script file need to be JSON file")
-    return redirect(url_for("design.experiment_builder"))
-
-
-@design.route('/design/script/download/<filetype>')
-@login_required
-def download(filetype):
-    """
-    .. :quickref: Workflow Design Ext; download a workflow design file
-
-    .. http:get:: /design/script/download/<filetype>
-
-    """
-    script = utils.get_script_file()
-    run_name = script.name if script.name else "untitled"
-    if filetype == "configure":
-        filepath = os.path.join(current_app.config['SCRIPT_FOLDER'], f"{run_name}_config.csv")
-        with open(filepath, 'w', newline='') as f:
-            writer = csv.writer(f)
-            cfg, cfg_types = script.config("script")
-            writer.writerow(cfg)
-            writer.writerow(list(cfg_types.values()))
-    elif filetype == "script":
-        script.sort_actions()
-        json_object = json.dumps(script.as_dict())
-        filepath = os.path.join(current_app.config['SCRIPT_FOLDER'], f"{run_name}.json")
-        with open(filepath, "w") as outfile:
-            outfile.write(json_object)
-    elif filetype == "python":
-        filepath = os.path.join(current_app.config["SCRIPT_FOLDER"], f"{run_name}.py")
-    else:
-        return "Unsupported file type", 400
-    return send_file(os.path.abspath(filepath), as_attachment=True)
-
-
-@design.route("/design/step/edit/<uuid>", methods=['GET', 'POST'])
-@login_required
-def edit_action(uuid: str):
-    """
-    .. :quickref: Workflow Design; edit parameters of an action step on canvas
-
-    .. http:get:: /design/step/edit/<uuid>
-
-    Load parameter form of an action step
-
-    .. http:post:: /design/step/edit/<uuid>
-
-    :param uuid: The step's uuid
-    :type uuid: str
-
-    :form dynamic form: workflow step dynamic inputs
-    :status 302: save changes and then redirects to :http:get:`/design/script`
-    """
-    script = utils.get_script_file()
-    action = script.find_by_uuid(uuid)
-    session['edit_action'] = action
-
-    if request.method == "POST" and action is not None:
-        forms = create_form_from_action(action, script=script)
-        if "back" not in request.form:
-            kwargs = {field.name: field.data for field in forms if field.name != 'csrf_token'}
-            # print(kwargs)
-            if forms and forms.validate_on_submit():
-                save_as = kwargs.pop('return', '')
-                kwargs = script.validate_variables(kwargs)
-            # try:
-                script.update_by_uuid(uuid=uuid, args=kwargs, output=save_as)
-            # except Exception as e:
-            else:
-                flash(forms.errors)
-        session.pop('edit_action')
-    return redirect(url_for('design.experiment_builder'))
-
-
-@design.route("/design/step/delete/<id>")
-@login_required
-def delete_action(id: int):
-    """
-    .. :quickref: Workflow Design; delete an action step on canvas
-
-    .. http:get:: /design/step/delete/<id>
-
-    :param id: The step number id
-    :type id: int
-
-    :status 302: save changes and then redirects to :http:get:`/design/script`
-    """
-    back = request.referrer
-    script = utils.get_script_file()
-    script.delete_action(id)
-    utils.post_script_file(script)
-    return redirect(back)
-
-
-@design.route("/design/step/duplicate/<id>")
-@login_required
-def duplicate_action(id: int):
-    """
-    .. :quickref: Workflow Design; duplicate an action step on canvas
-
-    .. http:get:: /design/step/duplicate/<id>
-
-    :param id: The step number id
-    :type id: int
-
-    :status 302: save changes and then redirects to :http:get:`/design/script`
-    """
-    back = request.referrer
-    script = utils.get_script_file()
-    script.duplicate_action(id)
-    utils.post_script_file(script)
-    return redirect(back)
-
-
-# ---- HTTP API Endpoints ----
 
-@design.route("/api/runner/status", methods=["GET"])
-def runner_status():
-    """
-    .. :quickref: Workflow Design; get the execution status
-
-    .. http:get:: /api/runner/status
-
-    :status 200: status
-    """
-    runner_busy = global_config.runner_lock.locked()
-    status = {"busy": runner_busy}
-    task_status = global_config.runner_status
-    current_step = {}
-    # print(task_status)
-    if task_status is not None:
-        task_type = task_status["type"]
-        task_id = task_status["id"]
-        if task_type == "task":
-            step = SingleStep.query.get(task_id)
-            current_step = step.as_dict()
-        if task_type == "workflow":
-            workflow = WorkflowRun.query.get(task_id)
-            if workflow is not None:
-                latest_step = WorkflowStep.query.filter_by(workflow_id=workflow.id).order_by(WorkflowStep.start_time.desc()).first()
-                if latest_step is not None:
-                    current_step = latest_step.as_dict()
-                status["workflow_status"] = {"workflow_info": workflow.as_dict(), "runner_status": runner.get_status()}
-    status["current_task"] = current_step
-    return jsonify(status), 200
-
-
-
-@design.route("/api/runner/abort_pending", methods=["POST"])
-def api_abort_pending():
-    """
-    .. :quickref: Workflow Design; abort pending action(s) during execution
-
-    .. http:get:: /api/runner/abort_pending
-
-    :status 200: {"status": "ok"}
-    """
-    abort_pending()
-    return jsonify({"status": "ok"}), 200
-
-@design.route("/api/runner/abort_current", methods=["POST"])
-def api_abort_current():
-    """
-    .. :quickref: Workflow Design; abort right after current action during execution
-
-    .. http:get:: /api/runner/abort_current
-
-    :status 200: {"status": "ok"}
-    """
-    abort_current()
-    return jsonify({"status": "ok"}), 200
-
-@design.route("/api/runner/pause", methods=["POST"])
-def api_pause():
-    """
-    .. :quickref: Workflow Design; pause during execution
-
-    .. http:get:: /api/runner/pause
-
-    :status 200: {"status": "ok"}
-    """
-    msg = pause()
-    return jsonify({"status": "ok", "pause_status": msg}), 200
-
-@design.route("/api/runner/retry", methods=["POST"])
-def api_retry():
-    """
-    .. :quickref: Workflow Design; retry when error occur during execution
-
-    .. http:get:: /api/runner/retry
-
-    :status 200: {"status": "ok"}
-    """
-    retry()
-    return jsonify({"status": "ok, retrying failed step"}), 200
-
-
-@design.route("/api/design/submit", methods=["POST"])
+@design.route("/submit_python", methods=["POST"])
 def submit_script():
-    """
-    .. :quickref: Workflow Design; submit script
-
-    .. http:get:: /api/design/submit
-
-    :status 200: {"status": "ok"}
-    """
+    """Submit script"""
     deck = global_config.deck
     deck_name = os.path.splitext(os.path.basename(deck.__file__))[0] if deck.__name__ == "__main__" else deck.__name__
     script = Script(author=session.get('user'), deck=deck_name)
     script_collection = request.get_json()
+    workflow_name = script_collection.pop("workflow_name")
     script.python_script = script_collection
     # todo check script format
+    script.name = workflow_name
+    result = {}
+    for stype, py_str in script_collection.items():
+        try:
+            card = convert_to_cards(py_str)
+            script.script_dict[stype] = card
+            result[stype] = "success"
+        except Exception as e:
+            result[
+                stype] = f"failed to transcript to ivoryos visualization, but function can still run. error: {str(e)}"
     utils.post_script_file(script)
-    return jsonify({"status": "ok"}), 200
+    try:
+        publish()
+        db_status = "success"
+    except Exception as e:
+        db_status = "failed"
+    return jsonify({"script": result, "db": db_status}), 200
+
+