file swap

app.py → app1.py

@@ -1,158 +1,44 @@
-from hugchat import hugchat
-from hugchat.login import Login
-from pyecore.resources import ResourceSet, URI
+
 import gradio as gr
-import logging
-from pathlib import Path
-from typing import List, Optional, Tuple
+import os
 
 from dotenv import load_dotenv
 
 load_dotenv()
 
-import verify
+import verify2
 
-from queue import Empty, Queue
-from threading import Thread
 
-import gradio as gr
-from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
-from langchain_community.chat_models import ChatOpenAI
-from langchain.prompts import HumanMessagePromptTemplate
-from langchain.schema import AIMessage, BaseMessage, HumanMessage, SystemMessage
 # adapted from https://github.com/hwchase17/langchain/issues/2428#issuecomment-1512280045
-from queue import Queue
-from typing import Any
 
-from langchain.callbacks.base import BaseCallbackHandler
 from datasets import load_dataset
 
-dataset = load_dataset("VeryMadSoul/NLD")
-
-
-class QueueCallback(BaseCallbackHandler):
-    """Callback handler for streaming LLM responses to a queue."""
-
-    def __init__(self, queue: Queue):
-        self.queue = queue
-
-    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
-        self.queue.put(token)
-
-    def on_llm_end(self, *args, **kwargs: Any) -> None:
-        return self.queue.empty()
-
-def apply_hf_settings_button(prompt, model_name) : 
-    verify.chatbot.switch_llm(HF_MODELS_NAMES.index(model_name))    
-    verify.chatbot.new_conversation(switch_to = True)
-    return "",[]
-
-HF_MODELS_NAMES = [model.name for model in verify.chatbot.get_available_llm_models()]
-
-
-DEFAULT_TEMPERATURE = 0.2
-
-ChatHistory = List[str]
-
-logging.basicConfig(
-    format="[%(asctime)s %(levelname)s]: %(message)s", level=logging.INFO
-)
-# load up our system prompt
-default_system_prompt = '''You are a systems engineer, expert in model driven engineering and meta-modeling
-Your OUTPUT should always be an ecore xmi in this format :
-
-```XML
-
-YOUR CODE HERE 
-
-```
-'''
-# for the human, we will just inject the text
-human_message_prompt_template = HumanMessagePromptTemplate.from_template("{text}")
-
 
-def on_message_button_click(
-    chat: Optional[ChatOpenAI],
-    message: str,
-    chatbot_messages: ChatHistory,
-    messages: List[BaseMessage],
-) -> Tuple[ChatOpenAI, str, ChatHistory, List[BaseMessage]]:
-    if chat is None:
-        # in the queue we will store our streamed tokens
-        queue = Queue()
-        # let's create our default chat
-        chat = ChatOpenAI(
-            model_name=GPT_MODELS_NAMES[0],
-            temperature=DEFAULT_TEMPERATURE,
-            streaming=True,
-            callbacks=([QueueCallback(queue)]),
-        )
-    else:
-        # hacky way to get the queue back
-        queue = chat.callbacks[0].queue
+BASE_DIR = 'outs'
+def list_files(directory):
+    dir_path = os.path.join(BASE_DIR, directory)
+    if not os.path.exists(dir_path):
+        return []
+    files = os.listdir(dir_path)
+    return files
 
-    job_done = object()
+def file_content(directory, file_name):
+    file_path = os.path.join(BASE_DIR, directory, file_name)
+    with open(file_path, 'r') as file:
+        content = file.read()
+    return content
 
-    logging.info(f"Asking question to GPT, messages={messages}")
-    # let's add the messages to our stuff
-    messages.append(HumanMessage(content=message))
-    chatbot_messages.append((message, ""))
-    # this is a little wrapper we need cuz we have to add the job_done
-    def task():
-        chat(messages)
-        queue.put(job_done)
+def download_file(directory, file_name):
+    file_path = os.path.join(BASE_DIR, directory, file_name)
+    return file_path
 
-    # now let's start a thread and run the generation inside it
-    t = Thread(target=task)
-    t.start()
-    # this will hold the content as we generate
-    content = ""
-    # now, we read the next_token from queue and do what it has to be done
-    while True:
-        try:
-            next_token = queue.get(True, timeout=1)
-            if next_token is job_done:
-                break
-            content += next_token
-            chatbot_messages[-1] = (message, content)
-            yield chat, "", chatbot_messages, messages
-        except Empty:
-            continue
-    # finally we can add our reply to messsages
-    messages.append(AIMessage(content=content))
-    logging.debug(f"reply = {content}")
-    logging.info(f"Done!")
-    return chat, "", chatbot_messages, messages
+examples = [
+    '''SimplePDL is an experimental language for specifying processes. The SPEM standard (Software Process Engineering Metamodel) proposed by the OMG inspired our work, but we also took ideas from the UMA metamodel (Unified Method Architecture) used in the EPF Eclipse plug-in (Eclipse Process Framework), dedicated to process modeling. SimplePDL is simplified to keep the presentation simple.
+Its metamodel is given in the figure 1. It defines the process concept (Process) composed of a set of work definitions (WorkDefinition) representing the activities to be performed during the development. One workdefinition may depend upon another (WorkSequence). In such a case, an ordering constraint (linkType) on the second workdefinition is specified, using the enumeration WorkSequenceType. For example, linking two workdefinitions wd1 and wd2 by a precedence relation of kind finishToStart means that wd2 can be started only if wd1 is finished (and respectively for startToStart, startToFinish and finishToFinish). SimplePDL does also allow to explicitly represent resources (Resource) that are needed in order to perform one workdefinition (designer, computer, server...) and also time constraints (min_time and max_time on WorkDefinition and Process) to specify the minimum (resp. maximum) time allowed to perform the workdefinition or the whole process.''',
+    " A FSM is conceived as an abstract machine that can be in one of a finite number of states. The machine is in only one state at a time; the state it is in at any given time is called the current state. It can change from one state to another when initiated by a triggering event or condition; this is called a transition. A particular FSM is defined by a list of its states, and the triggering condition for each transition.",
+    "Un Website est l'élément racine. Il est décrit par deux attributs (copyright et isMobileFriendly) et par une composition d'une ou plusieurs pages. Une page est décrite par deux attributs (son nom et son titre), ainsi que par des références à d'autres pages."
+]
 
-
-def system_prompt_handler(value: str) -> str:
-    return value
-
-
-def on_clear_button_click(system_prompt: str) -> Tuple[str, List, List]:
-    return "", [], [SystemMessage(content=system_prompt)]
-
-
-def on_apply_settings_button_click(
-    system_prompt: str, model_name: str, temperature: float
-):
-    logging.info(
-        f"Applying settings: model_name={model_name}, temperature={temperature}"
-    )
-    chat = ChatOpenAI(
-        model_name=model_name,
-        temperature=temperature,
-        streaming=True,
-        callbacks=[QueueCallback(Queue())],
-    )
-    # don't forget to nuke our queue
-    chat.callbacks[0].queue.empty()
-    return chat, *on_clear_button_click(system_prompt)
-
-
-
-
-    
 def trigger_example(example):
     chat, updated_history = generate_response(example)
     return chat, updated_history
@@ -160,14 +46,15 @@ def trigger_example(example):
 def generate_response(user_message,  history):
 
     #history.append((user_message,str(chatbot.chat(user_message))))
-    history, errors = verify.iterative_prompting(user_message,verify.description)
+    history, errors = verify2.iterative_prompting(user_message,verify2.description,model=verify2.model)
     return "", history
 
+def apply_gpt_settings_button(prompt, model_name):
+    verify2.model = model_name
+    return "", []
+
 def clear_chat():
     return [], []
-
-examples = [dataset['train'][i]['NLD'] for i in range(len(dataset['train']))]
-
 custom_css = """
 #logo-img {
     border: none !important;
@@ -177,26 +64,26 @@ custom_css = """
     min-height: 300px;
 }
 """
-GPT_MODELS_NAMES = ["gpt-3.5-turbo", "gpt-4",'gpt-4o']
-
+GPT_MODELS_NAMES = ["gpt-4-turbo", "gpt-4o", "gpt-3.5-turbo"]
 with gr.Blocks(analytics_enabled=False, css=custom_css) as demo:
 
     
-    with gr.Tab("HF_API"):
+    with gr.Tab("OPENAI API"):
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Image("images\logo.png", elem_id="logo-img", show_label=False, show_share_button=False, show_download_button=False)
             with gr.Column(scale=3):
                 gr.Markdown("""This Chatbot has been made to showcase our work on generating meta-model from textual descriptions.
-            <br/><br/>
-            The output of this conversation is going to be an ecore file that is validated by PyEcore [Pyecore (https://github.com/pyecore/pyecore)]
-            <br/>
-            Available Models : <br>
-            - Cohere4ai-command-r-plus<br>
-            - Llama-3-70B<br>
-            
-          """
-            )
+                <br/><br/>
+                The output of this conversation is going to be an ecore file that is validated by PyEcore [Pyecore (https://github.com/pyecore/pyecore)]
+                <br/>
+                Available Models : <br>
+                - GPT3-Turbo<br>
+                - GPT4-Turbo<br>
+                - GPT4-Omni                
+                
+            """
+                )
             
         with gr.Row():
             chatbot1 = gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True)
@@ -218,111 +105,51 @@ with gr.Blocks(analytics_enabled=False, css=custom_css) as demo:
         submit_button.click(fn=generate_response, inputs=[user_message, chatbot1], outputs=[user_message, chatbot1], concurrency_limit=32)
         
         clear_button.click(fn=clear_chat, inputs=None, outputs=[chatbot1, history], concurrency_limit=32)
+        
 
+        
         with gr.Accordion("Settings", open=False):
                             model_name = gr.Dropdown(
-                                choices=HF_MODELS_NAMES, value=HF_MODELS_NAMES[0], label="model"
+                                choices=GPT_MODELS_NAMES, value=GPT_MODELS_NAMES[0], label="model"
                             )
                             settings_button = gr.Button("Apply")
                             settings_button.click(
-                                apply_hf_settings_button,
+                                apply_gpt_settings_button,
                                 [user_message,model_name],
                                 [user_message, chatbot1],
                             )
 
 
-
         with gr.Row():
             gr.Examples(
                 examples=examples,
                 inputs=user_message,
                 cache_examples=False,
                 fn=trigger_example,
-                outputs=[chatbot],
+                outputs=[chatbot1],
                 examples_per_page=100
             )
         #user_message.submit(lambda x: gr.update(value=""), None, [user_message], queue=False)
         #submit_button.click(lambda x: gr.update(value=""), None, [user_message], queue=False)
         #clear_button.click(lambda x: gr.update(value=""), None, [user_message], queue=False)
+    with gr.Tab("File Browser"):
         
-    
-    with gr.Tab("OPENAI"):
-        system_prompt = gr.State(default_system_prompt)
-    # here we keep our state so multiple user can use the app at the same time!
-        messages = gr.State([SystemMessage(content=default_system_prompt)])
-    # same thing for the chat, we want one chat per use so callbacks are unique I guess
-        chat = gr.State(None)
-
-        with gr.Column(elem_id="col_container"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Image("images\logo.png", elem_id="logo-img", show_label=False, show_share_button=False, show_download_button=False)
-                with gr.Column(scale=3):
-                    gr.Markdown("""This Chatbot has been made to showcase our work on generating meta-model from textual descriptions.
-                <br/><br/>
-                The output of this conversation is going to be an ecore file that is validated by PyEcore [Pyecore (https://github.com/pyecore/pyecore)]
-                <br/>
-                Available Models : <br>
-                - GPT3-Turbo<br>
-                - GPT4-Turbo<br>
-                - GPT4-Omni                
-                
-            """
-                )
-            
-            
-            chatbot1 = gr.Chatbot()
-            with gr.Column():
-                message = gr.Textbox(label="chat input")
-                message.submit(
-                    on_message_button_click,
-                    [chat, message, chatbot1, messages],
-                    [chat, message, chatbot1, messages],
-                    queue=True,
-                )
-                message_button = gr.Button("Submit", variant="primary")
-                message_button.click(
-                    on_message_button_click,
-                    [chat, message, chatbot1, messages],
-                    [chat, message, chatbot1, messages],
-                )
-            with gr.Row():
-                with gr.Column():
-                    clear_button = gr.Button("Clear")
-                    clear_button.click(
-                        on_clear_button_click,
-                        [system_prompt],
-                        [message, chatbot1, messages],
-                        queue=False,
-                    )
-                with gr.Accordion("Settings", open=False):
-                    model_name = gr.Dropdown(
-                        choices=GPT_MODELS_NAMES, value=GPT_MODELS_NAMES[0], label="model"
-                    )
-                    temperature = gr.Slider(
-                        minimum=0.0,
-                        maximum=1.0,
-                        value=0.7,
-                        step=0.1,
-                        label="temperature",
-                        interactive=True,
-                    )
-                    apply_settings_button = gr.Button("Apply")
-                    apply_settings_button.click(
-                        on_apply_settings_button_click,
-                        [system_prompt, model_name, temperature],
-                        [chat, message, chatbot1, messages],
-                    )
-            with gr.Row():
-                gr.Examples(
-                examples=examples,
-                inputs=message,
-                cache_examples=False,
-                fn=on_message_button_click,
-                outputs=[chat, message, chatbot1, messages],
-                examples_per_page=100
-                )
-            
+        directory_dropdown = gr.Dropdown(choices=["HF", "OAI"], label="Select Directory")
+        file_dropdown = gr.Dropdown(choices=[], label="Files")
+        file_content_display = gr.Textbox(label="File Content", lines=10, interactive=False)
+        download_button = gr.File(label="Download File")
+
+        def update_file_list(directory):
+            files = list_files(directory)
+            return gr.Dropdown(choices=files)
+
+        def update_file_content_and_path(directory, file_name):
+            content = file_content(directory, file_name)
+            file_path = download_file(directory, file_name)
+            return content, file_path
+
+        directory_dropdown.change(update_file_list, inputs=directory_dropdown, outputs=file_dropdown)
+        file_dropdown.change(update_file_content_and_path, inputs=[directory_dropdown, file_dropdown], outputs=[file_content_display, download_button])
 
 if __name__ == "__main__":
     # demo.launch(debug=True)

cookies/mad.mik788@gmail.com.json

@@ -1 +0,0 @@
-{"hf-chat": "c50ecd5a-49c6-4476-bbf6-79889e915ceb", "token": "QRBRiJammSDwTGqibPwKOClSgxOJnjubtRtrwjfAfWJxBGNNIKhitDezddYOGTClZSYoqsKSNbLAaLvsJuePsicMWYDRkFwkoiALdDWyWyPDiYiaeLgJlTkHCYVMpich"}

verify.py → verify2.py

@@ -1,19 +1,15 @@
-from hugchat import hugchat
-from hugchat.login import Login
+from openai import OpenAI
+import pyecore
 from pyecore.resources import ResourceSet, URI
 import os
-
-from pathlib import Path
-from datasets import load_dataset
-import pandas as pd
 from datasets import Dataset,DatasetDict, load_dataset
 from huggingface_hub import CommitScheduler
 from uuid import uuid4
 import json
 from datetime import datetime
+from pathlib import Path
+import app1
 
-
-import os
 JSON_DATASET_DIR = Path("json_dataset")
 JSON_DATASET_DIR.mkdir(parents=True, exist_ok=True)
 
@@ -32,29 +28,34 @@ def save_json(model: str, errors: list) -> None:
             json.dump({"model": model, "error": errors, "datetime": datetime.now().isoformat()}, f)
             f.write("\n")
 
-# Log into huggingface and grant authorization to huggingchat
-EMAIL = os.environ['HF_EMAIL'] 
-PASSWD = os.environ['HF_PASSWORD'] 
-cookie_path_dir = "./cookies/" # NOTE: trailing slash (/) is required to avoid errors
-sign = Login(EMAIL, PASSWD)
-cookies = sign.login(cookie_dir_path=cookie_path_dir, save_cookies=True)
 
-# Create your ChatBot
-chatbot = hugchat.ChatBot(cookies=cookies.get_dict(), system_prompt = '''You are a systems engineer, expert in model driven engineering and meta-modeling
-Your OUTPUT should always follow this format :
+OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
+
+model = "gpt-4o"
+
+default_system_prompt = '''You are a systems engineer, expert in model driven engineering and meta-modeling
+Your OUTPUT should always be an ecore xmi in this format :
 
 ```xml
 
-< YOUR CODE HERE >
+YOUR CODE HERE 
 
 ```
-''')  # or cookie_path="usercookies/<email>.json"
-chatbot.switch_llm(1)
+'''
+
+fix_err_system_prompt = '''You are a systems engineer, expert in model driven engineering and meta-modeling,
+Fix the xmi provided with the errors
+NB : the error Invalid tag name refers to the <!-- --> tags
+
+Your OUTPUT should always be an ecore xmi in this format :
+
+```xml
+
+YOUR CODE HERE 
 
-# Create a new conversation
-chatbot.new_conversation(switch_to = True) # switch to the new conversation
+```
+'''
 
-#create prompt
 NLD= '''SimplePDL is an experimental language for specifying processes. The SPEM standard (Software Process Engineering Metamodel) proposed by the OMG inspired our work, but we also took ideas from the UMA metamodel (Unified Method Architecture) used in the EPF Eclipse plug-in (Eclipse Process Framework), dedicated to process modeling. SimplePDL is simplified to keep the presentation simple.
 Its metamodel is given in the figure 1. It defines the process concept (Process) composed of a set of work definitions (WorkDefinition) representing the activities to be performed during the development. One workdefinition may depend upon another (WorkSequence). In such a case, an ordering constraint (linkType) on the second workdefinition is specified, using the enumeration WorkSequenceType. For example, linking two workdefinitions wd1 and wd2 by a precedence relation of kind finishToStart means that wd2 can be started only if wd1 is finished (and respectively for startToStart, startToFinish and finishToFinish). SimplePDL does also allow to explicitly represent resources (Resource) that are needed in order to perform one workdefinition (designer, computer, server...) and also time constraints (min_time and max_time on WorkDefinition and Process) to specify the minimum (resp. maximum) time allowed to perform the workdefinition or the whole process.'''
 description='''# Writing Ecore Files
@@ -190,129 +191,159 @@ Ecore also supports the definition of operations and constraints on model elemen
 
 
 ##Reaccuring errors : 
-Invalid tag name error is linked to the tag <!-- --> don't use it in the syntax
+Invalid tag name refers to <!-- --> which are not accepted in xmi format
 
 ## Conclusion
 
 Ecore files provide a structured way to define models using an XML-based syntax. By understanding the syntax and semantics of Ecore files, developers can create robust and well-defined models that can be used as the foundation for various tools and applications within the Eclipse Modeling Framework.'''
-#prompt= "Convert the following description into an ecore xmi representation:\n" + NLD  + "\n Here's a technical document of how to write correct ecore file:\n" + description     #WHen tryin to add the description
-
-
-# Non stream response
-#query_result0 = chatbot.chat(prompt)
-#print(query_result0) # or query_result.text or query_result["text"]
-
-'''
-# Stream response
-for resp in chatbot.query(
-    "Hello",
-    stream=True
-):
-    print(resp)
-
-# Web search (new feature)
-query_result = chatbot.query("Hi!", web_search=True)
-print(query_result)
-for source in query_result.web_search_sources:
-    print(source.link)
-    print(source.title)
-    print(source.hostname)
-'''
-
-# Create a new conversation
-#chatbot.new_conversation(switch_to = True) # switch to the new conversation
-
-# Get conversations on the server that are not from the current session (all your conversations in huggingchat)
-#conversation_list = chatbot.get_remote_conversations(replace_conversation_list=True)
-# Get conversation list(local)
-#conversation_list = chatbot.get_conversation_list()
-
-# Get the available models (not hardcore)
-#models = chatbot.get_available_llm_models()
-
-# Switch model with given index
-
-#chatbot.switch_llm(2) # Switch to the second model
-
-# Get information about the current conversation
-#info = chatbot.get_conversation_info()
-#print(info.id, info.title, info.model, info.system_prompt, info.history)
-
-### Assistant
-#assistant = chatbot.search_assistant(assistant_name="ChatGpt") # assistant name list in https://huggingface.co/chat/assistants
-#assistant_list = chatbot.get_assistant_list_by_page(page=0)
-#chatbot.new_conversation(assistant=assistant, switch_to=True) # create a new conversation with assistant
-def initial_prompt(NLD, description):
-    prompt= "Convert the following description into an ecore xmi representation:\n" + NLD  + "\n Here's a technical document of how to write correct ecore file:\n" + description     #WHen tryin to add the description
-
-    return chatbot.chat(prompt)
-
-def fix_err(xmi, err):
-  prompt="Fix the following error: " +str(err)+"\n in the following xmi  :\n" + xmi+ "\n Here's a technical document of how to write correct ecore file:\n" + description
-
-  return chatbot.chat(prompt)
 
 def verify_xmi(output,output_file_name):
   #here we're gonna verify our Model's output by using the either a tool or a developped solution XMI parser
 
   #Return can be either bool or preferably the actual compilation error or xmi line error
-  output = str(output)
+
   #Returning a bool won't be that helpful ..
-  with open("outs\output"+output_file_name+".ecore", "w") as file1:
+  with open("outs\OAI\output"+output_file_name+".ecore", "w+") as file1:
     # Writing data to a file
-    if "```xml" in output:
-      file1.writelines(output[output.find("```xml")+len("```xml\n"):output.rfind("```")])
-    else:
-      file1.writelines(output[output.find("```")+len("```\n"):output.rfind("```")])
+
+    file1.writelines(output[output.find("```xml")+len("```xml\n"):output.rfind("```")])
   try:
     rset = ResourceSet()
-    resource = rset.get_resource(URI("outs\output"+output_file_name+".ecore"))
+    resource = rset.get_resource(URI("outs\OAI\output"+output_file_name+".ecore"))
 
   except Exception as e:
     return e.args[0]
   return 'no e'
 
-def iterative_prompting(NLD, XMI,max_iter=3):
-
-  history= []
 
-  i=0
+def fix_err(xmi, err , model, max_tokens = 2000):
+  client = OpenAI()
+
+  response = client.chat.completions.create(
+        model=model,
+  messages=[
+    {
+      "role": "system",
+      "content": [
+        {
+          "type": "text",
+          "text": fix_err_system_prompt
+        }
+      ]
+    },
+    {
+      "role": "user",
+      "content": [
+        {
+          "type": "text",
+          "text": " \n Fix the following error: " +str(err)+"\n in the following xmi  :\n" + xmi+"\n \n Output only the code ." #NLD #description + "\nConvert to XMI:\n" + NLD     #WHen tryin to add the description
+        }
+      ]
+    }
+  ],
+        temperature=0.2,
+        max_tokens=max_tokens,
+        top_p=1,
+        frequency_penalty=0,
+        presence_penalty=0,
+    )
+  return response.choices[0].message.content
+
+
+def prompt(NLD, description,model=model, max_tokens=2000):
+    client = OpenAI()
+
+    """prompt.
+
+    Parameters
+    ----------
+    NLD :
+        Natural Language Description
+    description :
+        description
+    model : 
+        OpenAI model
+    max_tokens :
+        max_tokens
+
+    """
+    response = client.chat.completions.create(
+        model=model,
+  messages=[
+    {
+      "role": "system",
+      "content": [
+        {
+          "type": "text",
+          "text": default_system_prompt
+        }
+      ]
+    },
+    {
+      "role": "user",
+      "content": [
+        {
+          "type": "text",
+          "text" : "Convert the following description into an ecore xmi representation:\n" + NLD  + "\n Here's a technical document if you need it of how to write correct ecore file:\n" + description     #WHen tryin to add the description
+
+        }
+      ]
+    }
+  ],
+        temperature=0.2,
+        max_tokens=max_tokens,
+        top_p=1,
+        frequency_penalty=0,
+        presence_penalty=0,
+    )
+    return response.choices[0].message.content
+
+
+def iterative_prompting(NLD, XMI,max_iter=3,model=model):
+    history= []
+
+
+    i=0
+
+
+    task = "\nConvert to XMI, Output only the code :\n"
+    XMI=""
+    gpt4o_output = prompt(NLD, description, model)
+    history.append((NLD,str(gpt4o_output)))
+
+    correct_syntax= verify_xmi(gpt4o_output,str(i))
     
- 
-  XMI=""
-  output = initial_prompt(NLD, description)
-  history.append((NLD,str(output)))
-  print(output)
+    error = (correct_syntax == 'no e')
+    errors = []
+    errors.append(correct_syntax)
+    while not error  and i<=3:
+        i+=1
 
-  correct_syntax= verify_xmi(output,str(i))
-  errors =[]
-  error = (correct_syntax == 'no e')
-  errors.append(correct_syntax)
+        print('****************************************')
+        print('Iteration ' +  str(i))
+        print('****************************************')
 
-  while (not error) and i<=max_iter:
-    i+=1
-   
 
-    #print('****************************************')
-    #print('Iteration ' +  str(i))
-    #print('****************************************')
+        error = "\n This Xmi was incorrect. Please fix the errors : " + " "+str(correct_syntax)
+        print("**************************")
 
+        print(correct_syntax)
 
-    error = "\n This Xmi was incorrect. Please fix the errors." + " "+str(correct_syntax)
-    
-    #print("**************************")
-    #print(correct_syntax)
-    #print("**************************")
+        print("**************************")
 
 
-    output = fix_err(output , correct_syntax)
-    history.append((error,str(output)))
-    #print(output)
-    correct_syntax = verify_xmi(output,str(i))
-    #print(correct_syntax)
-    error = (correct_syntax == 'no e')
-    errors.append(correct_syntax)
-  
-  save_json(chatbot.get_conversation_info().model, errors)
+        gpt4o_output = fix_err(gpt4o_output , correct_syntax, model)
+        history.append((error,str(gpt4o_output)))
+
+        print(gpt4o_output)
+
+        correct_syntax = verify_xmi(gpt4o_output,str(i))
+        print(correct_syntax)
+
+
+
+        error = (correct_syntax == 'no e')
+        errors.append(correct_syntax)
 
-  return history, errors
+    save_json(model, errors)
+    return history, errors