tried adding yaml component, a lot needs to be fixed

app.py

@@ -1,30 +1,173 @@
 import streamlit as st
+import pandas as pd
+import os
+from modeci_mdf.mdf import Model, Graph, Node, Parameter, OutputPort
+from modeci_mdf.utils import load_mdf_json, load_mdf, load_mdf_yaml
+from modeci_mdf.execution_engine import EvaluableGraph
+from code_editor import code_editor
 
 st.set_page_config(layout="wide")
+st.title("🔋 MDF Simulator")
 
-def main():
-    st.markdown("## Introduction to Model Description Format (MDF)")
-    st.markdown("""
-    The Model Description Format (MDF) is a standardized format used to represent computational models. MDF aims to facilitate the exchange and reuse of models across different simulation platforms. It provides a structured way to describe the components and behaviors of models in a machine-readable format.
+height = [19, 22]
+theme = "default"
+shortcuts = "vscode"
+focus = False
+wrap = True
+editor_btns = [{
+    "name": "Run",
+    "feather": "Play",
+    "primary": True,
+    "hasText": True,
+    "showWithIcon": True,
+    "commands": ["submit"],
+    "style": {"bottom": "0.44rem", "right": "0.4rem"}
+}]
 
-    ### Key Components of MDF:
-    
-    - **Model**: The top-level container that holds all the information about the model.
-    - **Graphs**: A model can contain one or more graphs, which represent different parts of the model or different modeling scenarios.
-    - **Nodes**: Each graph contains nodes, which are the fundamental units of the model representing entities or processes.
-    - **Parameters**: Nodes have parameters that define their properties and behaviors.
-    - **OutputPorts**: Nodes can have output ports, which specify the outputs of the nodes that can be connected to inputs of other nodes.
-    - **Edges**: Edges define the connections between nodes, representing the flow of information or material.
-
-    ### Benefits of Using MDF:
+def mdf_model_to_paramters_dictionary(param_inputs, mdf_model):
+    mod_graph = mdf_model.graphs[0]
+    nodes = mod_graph.nodes[0]
+    parameters = nodes.parameters
+    for param in parameters:
+        if isinstance(param.value, str) or param.value is None:
+            continue
+        st.session_state.param_inputs[param.id] = param.value
+    return st.session_state.param_inputs
+
+def run_simulation(param_inputs, mdf_model):
+    mod_graph = mdf_model.graphs[0]
+    nodes = mod_graph.nodes[0]
+    parameters = nodes.parameters
+    outputs = nodes.output_ports
+    eg = EvaluableGraph(mod_graph, verbose=False)
+    duration = param_inputs["Simulation Duration (s)"]
+    dt = param_inputs["Time Step (s)"]
+    t = 0
+    times = []
+    output_values = {op.value: [] for op in outputs}
+    while t <= duration:
+        times.append(t)
+        if t == 0:
+            eg.evaluate()
+        else:
+            eg.evaluate(time_increment=dt)
+
+        for param in output_values:
+            eval_param = eg.enodes[nodes.id].evaluable_parameters[param]
+            output_values[param].append(eval_param.curr_value)
+        t += dt
+    chart_data = pd.DataFrame(output_values)
+    chart_data['Time'] = times
+    chart_data.set_index('Time', inplace=True)
+    return chart_data
+
+def show_simulation_results():
+    if 'chart_data' in st.session_state:
+        st.line_chart(st.session_state.chart_data, use_container_width=True, height=400)
+        st.write("Input Values")
+        st.write(st.session_state.param_inputs)
+        st.write("Output Values")
+        st.write(st.session_state.chart_data)
+
+def show_mdf_graph():
+    if 'mdf_model_graph' in st.session_state:
+        st.subheader("MDF Graph")
+        image_path = st.session_state.mdf_model.id + ".png"
+        st.image(image_path, caption="Model Graph Visualization")
+
+def show_json_output():
+    if 'mdf_model_json' in st.session_state:
+        st.subheader("JSON Output")
+        st.json(st.session_state.mdf_model_json)
+
+def update_view_tabs(mdf_model, param_inputs):
+    tab1, tab2, tab3, tab4 = st.tabs(["Simulation Results", "MDF Graph", "Json Output", "Yaml Output"])
+    with tab1:
+        show_simulation_results()
+    with tab2:
+        show_mdf_graph()
+    with tab3:
+        show_json_output()
+    with tab4:
+        changes_in_yaml_to_update_model()
+
+def parameter_form_to_update_model_and_view(mdf_model, param_inputs):
+    mod_graph = mdf_model.graphs[0]
+    nodes = mod_graph.nodes[0]
+    parameters = nodes.parameters
+    form = st.form(key="parameter_form")
+    for i, param in enumerate(parameters):
+        if isinstance(param.value, str) or param.value is None:
+            continue  
+        key = f"{param.id}_{i}"
+        if mdf_model.metadata:
+            param_inputs[param.id] = float(form.text_input(f"{param.metadata.get('description', param.id)} ({param.id})", value=param.value, key=key))
+        else:
+            param_inputs[param.id] = float(form.text_input(f"{param.id}", value=param.value, key=key))
+    param_inputs["Simulation Duration (s)"] = float(form.text_input("Simulation Duration (s)", value=st.session_state.param_inputs.get("Simulation Duration (s)", 10), key="sim_duration"))
+    param_inputs["Time Step (s)"] = float(form.text_input("Time Step (s)", value=st.session_state.param_inputs.get("Time Step (s)", 0.1), key="time_step"))
     
-    - **Standardization**: Ensures consistency and compatibility across different tools and platforms.
-    - **Interoperability**: Facilitates the integration of models from different sources.
-    - **Reusability**: Encourages the reuse of models and model components.
-    - **Transparency**: Provides a clear and comprehensive description of models, aiding in understanding and validation.
+    run_button = form.form_submit_button("Run Simulation")
+    if run_button:
+        st.session_state.run_button_clicked = True
+        for i in param_inputs:
+            st.session_state.param_inputs[i] = float(param_inputs[i])
+        st.session_state.chart_data = run_simulation(param_inputs, mdf_model)
+        st.session_state.mdf_model_graph = mdf_model.to_graph_image(engine="dot", output_format="png", view_on_render=False, level=3, filename_root=mdf_model.id, only_warn_on_fail=(os.name == "nt"))
+        st.session_state.mdf_model_json = mdf_model.to_json()
+        st.session_state.update_button_clicked = False
+
+def upload_file_and_load_to_model():
+    uploaded_file = st.file_uploader("Choose a JSON/YAML/BSON file", type=["json", "yaml", "bson"])
+    if uploaded_file is not None:
+        filename = uploaded_file.name
+        with open(filename, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        mdf_model = load_mdf(filename)
+        st.session_state.original_mdf_model = mdf_model  # Save the original model
+        st.session_state.mdf_model_yaml = mdf_model  # Save the current model state
+        return mdf_model
 
-    MDF is designed to be extensible and flexible, allowing for the inclusion of additional metadata and custom components as needed. By using MDF, researchers and engineers can create, share, and collaborate on models more effectively.
-    """)
 
+def changes_in_yaml_to_update_model():
+    response = code_editor(st.session_state.mdf_model_yaml.to_yaml(),  height=height, lang="yaml", theme=theme, shortcuts=shortcuts, focus=focus, buttons=editor_btns, options={"wrap": wrap})
+    st.write("First, make changes in the YAML code above, press Ctrl + Enter (or Run button inside code editor) and then click on the 'Update Model' button below to update the model. Sometimes you have to follow these steps twice.")
+    if len(response['id']) != 0 and (response['type'] == "selection" or response['type'] == "submit"):
+        code_text = response['text']
+        update_button = st.button("Update Model")
+        if update_button:
+            mdf_model = Model.from_yaml(code_text)
+            mdf_model_to_paramters_dictionary(st.session_state.param_inputs, mdf_model)
+            st.session_state.mdf_model_yaml = mdf_model
+            st.session_state.chart_data = run_simulation(st.session_state.param_inputs, mdf_model)
+            st.session_state.mdf_model_graph = mdf_model.to_graph_image(engine="dot", output_format="png", view_on_render=False, level=3, filename_root=mdf_model.id, only_warn_on_fail=(os.name == "nt"))
+            st.session_state.mdf_model_json = mdf_model.to_json()
+            st.session_state.update_button_clicked = True
+            
+        
+
+
+def main():
+    mdf_model = upload_file_and_load_to_model()
+    st.write("Latest changes here: Working on making YAML editor.")
+    if mdf_model:
+        st.session_state.mdf_model = mdf_model
+        if 'run_button_clicked' not in st.session_state:
+            st.session_state.run_button_clicked = False
+        if 'update_button_clicked' not in st.session_state:
+            st.session_state.update_button_clicked = False
+        param_inputs = {}
+        if mdf_model.metadata:
+            preferred_duration = float(mdf_model.metadata.get("preferred_duration", 10))
+            preferred_dt = float(mdf_model.metadata.get("preferred_dt", 0.1))
+        else:
+            preferred_duration = 100
+            preferred_dt = 0.1
+        param_inputs["Simulation Duration (s)"] = preferred_duration
+        param_inputs["Time Step (s)"] = preferred_dt
+        st.session_state.param_inputs = param_inputs
+        parameter_form_to_update_model_and_view(st.session_state.mdf_model, st.session_state.param_inputs)
+        update_view_tabs(mdf_model, param_inputs)
+        
 if __name__ == "__main__":
     main()

other_files/app.py

@@ -0,0 +1,154 @@
+import streamlit as st, pandas as pd, os, io
+from modeci_mdf.mdf import Model, Graph, Node, Parameter, OutputPort
+from modeci_mdf.utils import load_mdf_json, load_mdf, load_mdf_yaml
+from modeci_mdf.execution_engine import EvaluableGraph
+st.set_page_config(layout="wide")
+st.title("🔋 MDF Simulator")
+
+# models: Purpose: To store the state of the model and update the model
+def run_simulation(param_inputs, mdf_model):
+    mod_graph = mdf_model.graphs[0]
+    nodes = mod_graph.nodes[0]
+    parameters = nodes.parameters
+    outputs = nodes.output_ports
+    eg = EvaluableGraph(mod_graph, verbose=False)
+    duration = param_inputs["Simulation Duration (s)"]
+    dt = param_inputs["Time Step (s)"]
+    t = 0
+    times = []
+    output_values = {op.value: [] for op in outputs}
+    while t <= duration:
+        times.append(t)
+        if t == 0:
+            eg.evaluate()
+        else:
+            eg.evaluate(time_increment=dt)
+
+        for param in output_values:
+            eval_param = eg.enodes[nodes.id].evaluable_parameters[param]
+            output_values[param].append(eval_param.curr_value)
+        t += dt
+    chart_data = pd.DataFrame(output_values)
+    chart_data['Time'] = times
+    chart_data.set_index('Time', inplace=True)
+    return chart_data
+
+# views: Purpose: To display the state of the model and update the view
+def show_simulation_results(chart_data):
+    st.line_chart(chart_data, use_container_width=True, height=400)
+    st.write("Output Values")
+    st.write(chart_data)
+
+def show_mdf_graph(mdf_model):
+    st.subheader("MDF Graph")
+    mdf_model.to_graph_image(engine="dot", output_format="png", view_on_render=False, level=3, filename_root=mdf_model.id, only_warn_on_fail=(os.name == "nt"))
+    image_path = mdf_model.id + ".png"
+    st.image(image_path, caption="Model Graph Visualization")
+
+def show_json_output(mdf_model):
+    st.subheader("JSON Output")
+    st.json(mdf_model.to_json())
+
+def view_tabs(mdf_model, param_inputs): # view
+    tab1, tab2, tab3, tab4 = st.tabs(["Simulation Results", "MDF Graph", "Json Output", "Yaml Output"])
+    with tab1:
+        chart_data = run_simulation(param_inputs, mdf_model) # model
+        show_simulation_results(chart_data) # view
+    with tab2:
+        show_mdf_graph(mdf_model) # view
+    with tab3:
+        show_json_output(mdf_model) # view
+    with tab4:
+        update_model_button = st.button("Update Model", key="updateModelButton")
+        if update_model_button:
+            changes_in_modelcode_to_update_model(mdf_model, param_inputs)
+
+def parameter_form_to_update_model_and_view(mdf_model, parameters, param_inputs, mod_graph, nodes):
+    form = st.form(key="parameter_form")
+    for i, param in enumerate(parameters):
+        if isinstance(param.value, str) or param.value is None:
+            continue  
+        key = f"{param.id}_{i}"
+        if mdf_model.metadata:
+            param_inputs[param.id] = float(form.text_input(f"{param.metadata.get('description', param.id)} ({param.id})", value=param.value, key=key))
+        else:
+            param_inputs[param.id] = float(form.text_input(f"{param.id}", value=param.value, key=key))
+    param_inputs["Simulation Duration (s)"] = float(form.text_input("Simulation Duration (s)", value=param_inputs["Simulation Duration (s)"], key="sim_duration"))
+    param_inputs["Time Step (s)"] = float(form.text_input("Time Step (s)", value=param_inputs["Time Step (s)"], key="time_step"))
+    for param in parameters:
+        if param.id in param_inputs:
+            param.value = param_inputs[param.id]
+    form.form_submit_button(on_click=view_tabs(mdf_model, param_inputs))
+
+def upload_file_and_load_to_model():
+    uploaded_file = st.file_uploader("Choose a JSON/YAML/BSON file", type=["json", "yaml", "bson"])
+    if uploaded_file is not None:
+        filename = uploaded_file.name
+        with open(filename, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        mdf_model = load_mdf(filename)
+        st.session_state.original_mdf_model = mdf_model  # Save the original model
+        st.session_state.mdf_model_yaml = mdf_model  # Save the current model state
+        return mdf_model
+
+def changes_in_modelcode_to_update_model(mdf_model, param_inputs):
+    update_model_button = st.button("Update Model") # this is working
+    if update_model_button:
+        print("Failed to update model:") 
+        st.balloons()
+        st.toast("Failed to update model", "Failed to update model", "error")
+    st.text_area("Update the model parameters", height=700, value=st.session_state.mdf_model)
+    new_mdf_model_text = st.text_area("Update the model parameters", height=700, value=st.session_state.mdf_model)
+    if st.button("Reset Code"):
+        st.session_state.mdf_model = st.session_state.original_mdf_model
+        mdf_model = load_mdf_json(io.BytesIO(st.session_state.original_mdf_model.encode('utf-8')))  # Load from stored JSON string
+        view_tabs(mdf_model, param_inputs)
+    
+        try:
+            st.session_state.mdf_model = new_mdf_model_text
+            mdf_model = load_mdf_json(io.BytesIO(new_mdf_model_text.encode('utf-8')))  # Attempt to load updated model from JSON string
+            view_tabs(mdf_model, param_inputs)
+        except Exception as e:
+            print(f"Failed to update model: {e}") #yahan tak pohoch hi nahi raha hai
+
+def main():
+    mdf_model = upload_file_and_load_to_model() # controller
+    
+    if mdf_model:
+        mod_graph = mdf_model.graphs[0]
+        nodes = mod_graph.nodes[0]
+        parameters = nodes.parameters
+        param_inputs = {}
+        if mdf_model.metadata:
+            preferred_duration = float(mdf_model.metadata.get("preferred_duration", 10))
+            preferred_dt = float(mdf_model.metadata.get("preferred_dt", 0.1))
+        else:
+            preferred_duration = 100
+            preferred_dt = 0.1
+        param_inputs["Simulation Duration (s)"] = preferred_duration
+        param_inputs["Time Step (s)"] = preferred_dt
+        parameter_form_to_update_model_and_view(mdf_model, parameters, param_inputs, mod_graph, nodes)
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+# def changes_in_yaml_to_update_model(mdf_model, param_inputs ):
+#     if 'original_mdf_model' not in st.session_state:
+#         st.session_state.original_mdf_model = mdf_model.to_yaml()
+#     if 'mdf_model_yaml' not in st.session_state:
+#         st.session_state.mdf_model_yaml = mdf_model.to_yaml()
+    
+#     new_mdf_model_yaml = st.text_area("Update the model parameters", height=700, value=st.session_state.mdf_model_yaml)
+    
+#     if st.button("Reset Code"):
+#         st.session_state.mdf_model_yaml = st.session_state.original_mdf_model
+#         mdf_model = load_mdf_yaml(io.BytesIO(st.session_state.original_mdf_model.encode('utf-8')))
+#         view_tabs(mdf_model, param_inputs)
+    
+#     if st.button("Update Model"):
+#         st.session_state.mdf_model_yaml = new_mdf_model_yaml
+#         mdf_model = load_mdf_yaml(io.BytesIO(new_mdf_model_yaml.encode('utf-8')))
+#         view_tabs(mdf_model, param_inputs)

other_files/extra_fiel.py

@@ -0,0 +1,12 @@
+#Download the files to be uploaded from here:
+        files=["switched_rlc_circuit.json", "NewtonCoolingModel.json"]
+        for filename in files:
+            with open(filename, 'rb') as f:
+                file_data = f.read()
+                b64 = base64.b64encode(file_data).decode()
+
+            # Generate the download link
+            href = f'<a href="data:application/json;base64,{b64}" download="{filename}">Download the {filename} JSON file from here</a>'
+
+            # Use st.markdown to display the link
+            st.markdown(href, unsafe_allow_html=True)

{pages → other_files}/🤖_ModelViewController.py

@@ -129,7 +129,6 @@ def main():
         st.header(f"Model: {model_name}")
         controller.view.display_parameters(controller.model.parameters, controller.model.mdf_model.metadata or {})
         run_simulation_button = st.button("Run Simulation")
-        # time.sleep(10)
         if run_simulation_button:
             controller.update_model_parameters()
             controller.run_simulation()