V1

README.md

@@ -1,12 +1,53 @@
----
-title: Ecore Gen
-emoji: 👁
-colorFrom: pink
-colorTo: purple
-sdk: gradio
-sdk_version: 4.36.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Gradio App for Generating and Validating Ecore Files
+This repository contains a Gradio-based web application that leverages open-source language models from HuggingChat API and OpenAI API. The app provides two tabs: one for using models from HuggingChat and the other for models from OpenAI. Both tabs allow users to generate an Ecore file from a natural language description and iteratively validate it.
+
+## Features
+- Two Tabs for Model Selection:
+ - HuggingChat API: Uses open-source language models from HuggingChat.
+ - OpenAI API: Uses language models from OpenAI.
+- Ecore File Generation: Converts natural language descriptions into Ecore files.
+- Iterative Validation: Validates the generated Ecore files iteratively to ensure correctness.
+## Installation
+1. Clone the repository:
+
+```bash
+git clone https://github.com/your-username/your-repo-name.git
+cd your-repo-name
+```
+2.  Install the required packages:
+
+```bash
+pip install -r requirements.txt
+```
+## Usage
+
+1. Navigate to the project directory:
+
+```bash
+cd your-repo-name
+```
+2. Run the application:
+
+```bash
+python app.py
+```
+3. Open your web browser and go to the provided local address to interact with the app.
+
+## Folder Structure
+- app.py: Main script to run the Gradio app.
+- requirements.txt: List of required Python packages.
+- README.md: Project documentation.
+
+## Contributing
+Contributions are welcome! Please create a new branch for each feature or bug fix:
+
+```bash
+git checkout -b feature/your-feature-name
+```
+Submit a pull request with a detailed explanation of your changes.
+
+
+
+## Contact
+For any questions or feedback, please open an issue or contact [[email protected]].
+

app.py

@@ -0,0 +1,332 @@
+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
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+import verify
+
+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
+
+    job_done = object()
+
+    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)
+
+    # 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
+
+
+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
+
+def generate_response(user_message,  history):
+
+    #history.append((user_message,str(chatbot.chat(user_message))))
+    history, errors = verify.iterative_prompting(user_message,verify.description)
+    return "", history
+
+def clear_chat():
+    return [], []
+
+examples = [dataset['train'][i]['NLD'] for i in range(len(dataset['train']))]
+
+custom_css = """
+#logo-img {
+    border: none !important;
+}
+#chat-message {
+    font-size: 14px;
+    min-height: 300px;
+}
+"""
+GPT_MODELS_NAMES = ["gpt-3.5-turbo", "gpt-4",'gpt-4o']
+
+with gr.Blocks(analytics_enabled=False, css=custom_css) as demo:
+
+    
+    with gr.Tab("HF_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>
+            
+          """
+            )
+            
+        with gr.Row():
+            chatbot1 = gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True)
+        
+        with gr.Row():
+            user_message = gr.Textbox(lines=1, placeholder="Ask anything ...", label="Input", show_label=False)
+
+      
+        with gr.Row():
+            submit_button = gr.Button("Submit")
+            clear_button = gr.Button("Clear chat")
+
+            
+
+                        
+        history = gr.State([])
+        
+        user_message.submit(fn=generate_response, inputs=[user_message, chatbot1], outputs=[user_message, chatbot1], concurrency_limit=32)
+        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"
+                            )
+                            settings_button = gr.Button("Apply")
+                            settings_button.click(
+                                apply_hf_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],
+                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("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
+                )
+            
+
+if __name__ == "__main__":
+    # demo.launch(debug=True)
+    try:
+        demo.queue(api_open=False, max_size=40).launch(show_api=False)
+    except Exception as e:
+        print(f"Error: {e}")

cookies/[email protected]

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

json_dataset/train-f14e52a9-8beb-4a90-ac8a-b0cae5352428.json

@@ -0,0 +1,2 @@
+{"model": "microsoft/Phi-3-mini-4k-instruct", "error": ["Start tag expected, '<' not found, line 1, column 1", "Start tag expected, '<' not found, line 1, column 1", "Start tag expected, '<' not found, line 1, column 2", "Start tag expected, '<' not found, line 7, column 2", "Start tag expected, '<' not found, line 6, column 2"], "datetime": "2024-06-17T14:15:44.872853"}
+{"model": "mistralai/Mistral-7B-Instruct-v0.2", "error": ["Extra content at the end of the document, line 4, column 1", "Namespace prefix ecore on EPackage is not defined, line 1, column 81", "Namespace prefix ecore on EPackage is not defined, line 1, column 81", "Start tag expected, '<' not found, line 1, column 1", "Namespace prefix ecore on EPackage is not defined, line 1, column 81"], "datetime": "2024-06-17T14:18:43.999325"}

outs/output0.ecore

@@ -0,0 +1,20 @@
+<ecore:EPackage name="FiniteStateMachine" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xsi:schemaLocation="http://www.eclipse.org/emf/2002/Ecore http://www.eclipse.org/emf/2002/Ecore.xsd">
+
+</ecore:EPackage>
+```
+
+2. Inside the `EPackage`, define the `EClass` representing the FSM states. Let's call it `State`.
+
+```xml
+<eClassifiers xsi:type="ecore:EClass" name="State">
+  <!-- Add structural features if necessary -->
+</eClassifiers>
+```
+
+3. Inside the same `EPackage`, define the `EClass` representing the FSM itself. Let's call it `FSM`.
+
+```xml
+<eClassifiers xsi:type="ecore:EClass" name="FSM">
+  <eStructuralFeatures xsi:type="ecore:EReference" name="currentState" lowerBound="1" eType="#//State" containment="true"/>
+  <!-- Add other features as needed, such as transitions -->
+</eClassifiers>

outs/output1.ecore

@@ -0,0 +1,65 @@
+<ecore:EPackage name="library" nsURI="http://example.com/library" nsPrefix="lib">
+
+</ecore:EPackage>
+```
+
+### EClassifiers
+
+Inside the `EPackage`, you can define `EClassifiers`, which represent classes, data types, or other types in the model. The two most common types of `EClassifiers` are `EClass` and `EDataType`.
+
+#### EClass
+
+An `EClass` represents a class in the model. It can contain `EStructuralFeatures`, which define the attributes and references of the class.
+
+Example:
+
+```xml
+<eClassifiers xsi:type="ecore:EClass" name="Book">
+  <eStructuralFeatures xsi:type="ecore:EAttribute" name="title" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  <eStructuralFeatures xsi:type="ecore:EReference" name="author" lowerBound="1" eType="#//Author" containment="true"/>
+</eClassifiers>
+```
+
+In this example, the `Book` class has a `title` attribute (of type `EString`) and an `author` reference (to the `Author` class).
+
+#### EStructuralFeatures
+
+`EStructuralFeatures` represent the attributes and references of an `EClass`. They can be of type `EAttribute` or `EReference`.
+
+- `EAttribute`: Represents an attribute of the class, with a name and a data type (`eType`).
+- `EReference`: Represents a reference to another `EClass`, with a name, a reference type (`eType`), and additional properties like `containment`, `lowerBound`, and `upperBound`.
+
+#### EDataType
+
+An `EDataType` represents a data type in the model, such as `EString`, `EInt`, or a user-defined data type.
+
+Example:
+
+```xml
+<eClassifiers xsi:type="ecore:EDataType" name="SSN" instanceClassName="java.lang.String">
+  <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+    <details key="documentation" value="A social security number"/>
+  </eAnnotations>
+</eClassifiers>
+```
+
+In this example, the `SSN` data type is defined as a string with additional documentation.
+
+### Annotations
+
+Ecore supports annotations, which provide additional metadata or constraints for model elements. Annotations are represented by the `eAnnotations` element.
+
+Example:
+
+```xml
+<eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+  <details key="documentation" value="A social security number"/>
+</eAnnotations>
+```
+
+### Containers and Nested Packages
+
+To nest packages inside each other, use the `eContainedPackages` element under the parent `EPackage`.
+
+Example:
+

outs/output2.ecore

@@ -0,0 +1,72 @@
+<ecore:EPackage name="library" nsURI="http://example.com/library" nsPrefix="lib">
+
+</ecore:EPackage>
+```
+
+### EClassifiers
+
+Within the `EPackage`, you may define `EClassifiers`, representing classes, data types, or other types in the model. The primary types of `EClassifiers` include `EClass` and `EDataType`.
+
+#### EClass
+
+An `EClass` represents a class in the model and contains `EStructuralFeatures`, defining its attributes and references.
+
+Example:
+
+```xml
+<eClassifiers xsi:type="ecore:EClass" name="Book">
+  <eStructuralFeatures xsi:type="ecore:EAttribute" name="title" eType="ecore:EDataType #//EString"/>
+  <eStructuralFeatures xsi:type="ecore:EReference" name="author" lowerBound="1" eType="#//Author" containment="true"/>
+</eClassifiers>
+```
+
+Here, the `Book` class possesses a `title` attribute (of type `EString`) and an `author` reference (referencing the `Author` class).
+
+#### EStructuralFeatures
+
+`EStructuralFeatures` denote the attributes and references of an `EClass`. They come in two forms: `EAttribute` and `EReference`.
+
+- `EAttribute`: Defines an attribute of the class, consisting of a name and a data type (`eType`).
+- `EReference`: Represents a reference to another `EClass`, including a name, a reference type (`eType`), and optional properties like `containment`, `lowerBound`, and `upperBound`.
+
+#### EDataType
+
+An `EDataType` represents a data type in the model, such as `EString`, `EInt`, or custom data types.
+
+Example:
+
+```xml
+<eClassifiers xsi:type="ecore:EDataType" name="SSN" instanceClassName="java.lang.String">
+  <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+    <details key="documentation" value="A social security number"/>
+  </eAnnotations>
+</eClassifiers>
+```
+
+This example introduces a `SSN` data type, defined as a string with added documentation.
+
+### Annotations
+
+Ecore allows annotations, providing additional metadata or constraints for model elements. Annotations are represented through the `eAnnotations` element.
+
+Example:
+
+```xml
+<eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+  <details key="documentation" value="A social security number"/>
+</eAnnotations>
+```
+
+### Containers and Nested Packages
+
+To embed packages within each other, utilize the `eContainedPackages` element beneath the parent `EPackage`.
+
+Example:
+
+```xml
+<ecore:EPackage name="RootPackage" nsURI="root_package.ecore" nsPrefix="rp">
+  ...
+  <eContainedPackages>
+    <eReference target="./sub_package.ecore"/>
+  </eContainedPackages>
+</ecore:EPackage>

outs/output3.ecore

@@ -0,0 +1,5 @@
+have corrected the recurring errors in your document regarding XML comments and invalid tags. Here's the updated conclusion section:
+
+## Conclusion
+
+Ecore files offer a standardized approach to modeling using an XML-based syntax. Understanding the syntax and semantics of Ecore files enables developers to build accurate and consistent models that serve as strong foundations for various EMF-based tools and applications. Remember to avoid using XML comments (<!-- -->) directly in the syntax and ensure proper usage of Ecore constructs, such as EPackage, EClass, EStructuralFeatures, and EDataTypes, along with their respective attributes and relationships. Happy modeling

outs/output4.ecore

@@ -0,0 +1,81 @@
+<ecore:EPackage name="library" nsURI="http://example.com/library" nsPrefix="lib">
+
+</ecore:EPackage>
+```
+
+### EClassifiers
+
+Within the `EPackage`, define `EClassifiers`�classes, data types, or other types. Commonly used `EClassifiers` include `EClass` and `EDataType`.
+
+#### EClass
+
+An `EClass` defines a class with possible `EStructuralFeatures`:
+
+- Attributes (`EAttribute`).
+- References (`EReference`).
+
+Example:
+
+```xml
+<eClassifiers xsi:type="ecore:EClass" name="Book">
+  <eStructuralFeatures>
+    <eStructuralFeature xsi:type="ecore:EAttribute" name="title" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeature xsi:type="ecore:EReference" name="author" lowerBound="1" eType="#//Author" containment="true"/>
+  </eStructuralFeatures>
+</eClassifiers>
+```
+
+#### EDataType
+
+Define custom `EDataTypes`:
+
+```xml
+<eClassifiers xsi:type="ecore:EDataType" name="SSN" instanceClassName="java.lang.String">
+  <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+    <details key="documentation" value="A social security number"/>
+  </eAnnotations>
+</eClassifiers>
+```
+
+### Annotations
+
+Use `eAnnotations` for metadata and constraints:
+
+```xml
+<eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+  <details key="documentation" value="A social security number"/>
+</eAnnotations>
+```
+
+### Comments and Documentation
+
+XML comments (<!-- -->) aren't supported; use `eAnnotations` instead.
+
+## Semantics
+
+Beyond syntax, Ecore files establish model behavior and constraints through inheritance, containment, multiplicities, and operations/constraints.
+
+### Inheritance
+
+Ecore allows single inheritance via `eSuperTypes`:
+
+```xml
+<eClassifiers xsi:type="ecore:EClass" name="FictionBook" eSuperTypes="#//Book">
+  ...
+</eClassifiers>
+```
+
+### Containment
+
+Containment relationships exist when a reference has `containment="true"`:
+
+```xml
+<eStructuralFeature xsi:type="ecore:EReference" name="author" lowerBound="1" eType="#//Author" containment="true"/>
+```
+
+### Multiplicities
+
+Multiplicities specify allowed numbers of features:
+
+```xml
+<eStructuralFeature xsi:type="ecore:EReference" name="chapters" upperBound="-1" eType="#//Chapter" containment="true"/>

requirements.txt

@@ -0,0 +1,7 @@
+pyecore
+gradio
+hugchat
+langchain
+langchain_community
+huggingface
+huggingface-hub

verify.py

@@ -0,0 +1,318 @@
+from hugchat import hugchat
+from hugchat.login import Login
+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
+
+
+import os
+JSON_DATASET_DIR = Path("json_dataset")
+JSON_DATASET_DIR.mkdir(parents=True, exist_ok=True)
+
+JSON_DATASET_PATH = JSON_DATASET_DIR / f"train-{uuid4()}.json"
+
+scheduler = CommitScheduler(
+    repo_id="VeryMadSoul/errors",
+    repo_type="dataset",
+    folder_path=JSON_DATASET_DIR,
+    path_in_repo="data",
+)
+
+def save_json(model: str, errors: list) -> None:
+    with scheduler.lock:
+        with JSON_DATASET_PATH.open("a") as f:
+            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 :
+
+```xml
+
+< YOUR CODE HERE >
+
+```
+''')  # or cookie_path="usercookies/<email>.json"
+chatbot.switch_llm(1)
+
+# 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
+
+## Introduction
+
+Ecore is the core meta-model of the Eclipse Modeling Framework (EMF), which provides a foundation for building tools and applications based on models. Ecore files define the structure and constraints of a model using an XML-based syntax. This document explains how to write Ecore files, covering both the syntax and semantics.
+
+## Syntax
+
+An Ecore file is an XML document that follows the Ecore XML Schema. The root element of an Ecore file is `EPackage`, which represents a package or namespace for the model.
+
+### EPackage
+
+The `EPackage` element has the following attributes:
+
+- `name`: The name of the package.
+- `nsURI`: The namespace Uniform Resource Identifier (URI) for the package, which should be a globally unique identifier.
+- `nsPrefix`: The preferred namespace prefix to be used for the package.
+
+Example:
+
+```xml
+<ecore:EPackage name="library" nsURI="http://example.com/library" nsPrefix="lib">
+
+</ecore:EPackage>
+```
+
+### EClassifiers
+
+Inside the `EPackage`, you can define `EClassifiers`, which represent classes, data types, or other types in the model. The two most common types of `EClassifiers` are `EClass` and `EDataType`.
+
+#### EClass
+
+An `EClass` represents a class in the model. It can contain `EStructuralFeatures`, which define the attributes and references of the class.
+
+Example:
+
+```xml
+<eClassifiers xsi:type="ecore:EClass" name="Book">
+  <eStructuralFeatures xsi:type="ecore:EAttribute" name="title" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  <eStructuralFeatures xsi:type="ecore:EReference" name="author" lowerBound="1" eType="#//Author" containment="true"/>
+</eClassifiers>
+```
+
+In this example, the `Book` class has a `title` attribute (of type `EString`) and an `author` reference (to the `Author` class).
+
+#### EStructuralFeatures
+
+`EStructuralFeatures` represent the attributes and references of an `EClass`. They can be of type `EAttribute` or `EReference`.
+
+- `EAttribute`: Represents an attribute of the class, with a name and a data type (`eType`).
+- `EReference`: Represents a reference to another `EClass`, with a name, a reference type (`eType`), and additional properties like `containment`, `lowerBound`, and `upperBound`.
+
+#### EDataType
+
+An `EDataType` represents a data type in the model, such as `EString`, `EInt`, or a user-defined data type.
+
+Example:
+
+```xml
+<eClassifiers xsi:type="ecore:EDataType" name="SSN" instanceClassName="java.lang.String">
+  <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+    <details key="documentation" value="A social security number"/>
+  </eAnnotations>
+</eClassifiers>
+```
+
+In this example, the `SSN` data type is defined as a string with additional documentation.
+
+### Annotations
+
+Ecore supports annotations, which provide additional metadata or constraints for model elements. Annotations are represented by the `eAnnotations` element.
+
+Example:
+
+```xml
+<eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+  <details key="documentation" value="A social security number"/>
+</eAnnotations>
+```
+### Comments and Documentation
+XML comments are not supported in XMI Format
+USE EANNOTATIONS instead 
+
+
+
+## Semantics
+
+Beyond the syntax, Ecore files also define the semantics of the model, which determine the behavior and constraints of the model elements.
+
+### Inheritance
+
+Ecore supports inheritance between classes. An `EClass` can inherit from one or more `EClasses` using the `eSuperTypes` element.
+
+Example:
+
+```xml
+<eClassifiers xsi:type="ecore:EClass" name="FictionBook" eSuperTypes="#//Book">
+  <eStructuralFeatures xsi:type="ecore:EAttribute" name="genre" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+</eClassifiers>
+```
+
+In this example, the `FictionBook` class inherits from the `Book` class and adds a `genre` attribute.
+
+### Containment
+
+Ecore supports containment relationships between classes, which determine ownership and lifecycle management. A containment reference is specified using the `containment="true"` attribute on an `EReference`.
+
+Example:
+
+```xml
+<eStructuralFeatures xsi:type="ecore:EReference" name="author" lowerBound="1" eType="#//Author" containment="true"/>
+```
+
+In this example, the `author` reference of the `Book` class has containment set to `true`, meaning that the `Author` instance is owned by the `Book` instance.
+
+### Multiplicities
+
+Ecore supports multiplicity constraints on attributes and references, which define the allowed number of values for a feature. Multiplicities are specified using the `lowerBound` and `upperBound` attributes on `EStructuralFeatures`.
+
+Example:
+
+```xml
+<eStructuralFeatures xsi:type="ecore:EReference" name="chapters" upperBound="-1" eType="#//Chapter" containment="true"/>
+```
+
+In this example, the `chapters` reference of a `Book` class has an unbounded upper bound (`-1`), allowing any number of `Chapter` instances to be contained within the `Book`.
+
+### Operations and Constraints
+
+Ecore also supports the definition of operations and constraints on model elements, although these are typically specified using additional tools or languages, such as the Object Constraint Language (OCL) or Java code.
+
+
+##Reaccuring errors : 
+Invalid tag name error is linked to the tag <!-- --> don't use it in the syntax
+
+## 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:
+    # 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("```")])
+  try:
+    rset = ResourceSet()
+    resource = rset.get_resource(URI("outs\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
+    
+ 
+  XMI=""
+  output = initial_prompt(NLD, description)
+  history.append((NLD,str(output)))
+  print(output)
+
+  correct_syntax= verify_xmi(output,str(i))
+  errors =[]
+  error = (correct_syntax == 'no e')
+  errors.append(correct_syntax)
+
+  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)
+    #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)
+
+  return history, errors