Create app110.py

app110.py

@@ -0,0 +1,1595 @@
+import streamlit as st
+import pandas as pd
+import os
+import json
+import base64
+import random
+from streamlit_pdf_viewer import pdf_viewer
+from langchain.prompts import PromptTemplate
+from datetime import datetime
+from pathlib import Path
+from openai import OpenAI
+from dotenv import load_dotenv
+import warnings
+
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+warnings.filterwarnings('ignore')
+
+os.getenv("OAUTH_CLIENT_ID")
+
+
+# # Load environment variables and initialize the OpenAI client to use Hugging Face Inference API.
+# load_dotenv()
+# client = OpenAI(
+#     base_url="https://api-inference.huggingface.co/v1",
+#     api_key=os.environ.get('TOKEN2') # Hugging Face API token
+# )
+#####
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://router.huggingface.co/together/v1",
+    #api_key="hf_XXXXX",
+    api_key=os.environ.get('LLM'), # Hugging Face API token
+)
+
+completion = client.chat.completions.create(
+    model="meta-llama/Meta-Llama-3-8B-Instruct-Turbo",
+    messages=[
+        {
+            "role": "user",
+            "content": "What is the capital of France?"
+        }
+    ],
+)
+
+print(completion.choices[0].message)
+#####
+##########################################################3
+# import streamlit as st
+# from transformers import AutoModelForCausalLM, AutoTokenizer
+# import torch
+
+# # Model selection dropdown
+# selected_model = st.selectbox(
+#     "Select Model",
+#     ["meta-llama/Meta-Llama-3-8B-Instruct-Turbo", 
+#      "meta-llama/Llama-3.3-70B-Instruct", 
+#      "meta-llama/Llama-3.2-3B-Instruct",
+#      "meta-llama/Llama-4-Scout-17B-16E-Instruct", 
+#      "meta-llama/Meta-Llama-3-8B-Instruct",
+#      "meta-llama/Llama-3.1-70B-Instruct"],
+#     key='model_select'
+# )
+
+# @st.cache_resource  # Cache the model to prevent reloading
+# def load_model(model_name):
+#     try:
+#         # Optimized model loading configuration
+#         model = AutoModelForCausalLM.from_pretrained(
+#             model_name,
+#             torch_dtype=torch.float16,        # Use half precision
+#             device_map="auto",                # Automatic device mapping
+#             load_in_8bit=True,               # Enable 8-bit quantization
+#             low_cpu_mem_usage=True,          # Optimize CPU memory usage
+#             max_memory={0: "10GB"}           # Limit GPU memory usage
+#         )
+        
+#         tokenizer = AutoTokenizer.from_pretrained(
+#             model_name,
+#             padding_side="left",
+#             truncation_side="left"
+#         )
+        
+#         return model, tokenizer
+    
+#     except Exception as e:
+#         st.error(f"Error loading model: {str(e)}")
+#         return None, None
+
+# # Load the selected model with optimizations
+# if selected_model:
+#     model, tokenizer = load_model(selected_model)
+
+#     # Check if model loaded successfully
+#     if model is not None:
+#         st.success(f"Successfully loaded {selected_model}")
+#     else:
+#         st.warning("Please select a different model or check your hardware capabilities")
+
+# # Function to generate text
+# def generate_response(prompt, model, tokenizer):
+#     try:
+#         inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+        
+#         with torch.no_grad():
+#             outputs = model.generate(
+#                 inputs["input_ids"],
+#                 max_length=256,
+#                 num_return_sequences=1,
+#                 temperature=0.7,
+#                 do_sample=True,
+#                 pad_token_id=tokenizer.pad_token_id
+#             )
+        
+#         response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+#         return response
+    
+#     except Exception as e:
+#         return f"Error generating response: {str(e)}"
+############################################################
+
+####new
+# from openai import OpenAI
+
+# client = OpenAI(
+#     base_url="https://router.huggingface.co/together/v1",
+#     api_key=os.environ.get('TOKEN2'),
+# )
+
+# completion = client.chat.completions.create(
+#     model="meta-llama/Meta-Llama-3-8B-Instruct-Turbo",
+#     messages=[
+#         {
+#             "role": "user",
+#             "content": "What is the capital of France?"
+#         }
+#     ],
+#     max_tokens=512,
+# )
+
+# print(completion.choices[0].message)
+#####
+
+# Create necessary directories
+for dir_name in ['data', 'feedback']:
+    if not os.path.exists(dir_name):
+        os.makedirs(dir_name)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .stButton > button {
+        width: 100%;
+        margin-bottom: 10px;
+        background-color: #4CAF50;
+        color: white;
+        border: none;
+        padding: 10px;
+        border-radius: 5px;
+    }
+    .task-button {
+        background-color: #2196F3 !important;
+    }
+    .stSelectbox {
+        margin-bottom: 20px;
+    }
+    .output-container {
+        padding: 20px;
+        border-radius: 5px;
+        border: 1px solid #ddd;
+        margin: 10px 0;
+    }
+    .status-container {
+        padding: 10px;
+        border-radius: 5px;
+        margin: 10px 0;
+    }
+    .sidebar-info {
+        padding: 10px;
+        background-color: #f0f2f6;
+        border-radius: 5px;
+        margin: 10px 0;
+    }
+    .feedback-button {
+        background-color: #ff9800 !important;
+    }
+    .feedback-container {
+        padding: 15px;
+        background-color: #f5f5f5;
+        border-radius: 5px;
+        margin: 15px 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Helper functions
+def read_csv_with_encoding(file):
+    encodings = ['utf-8', 'latin1', 'iso-8859-1', 'cp1252']
+    for encoding in encodings:
+        try:
+            return pd.read_csv(file, encoding=encoding)
+        except UnicodeDecodeError:
+            continue
+    raise UnicodeDecodeError("Failed to read file with any supported encoding")
+
+#def save_feedback(feedback_data):
+    #feedback_file = 'feedback/user_feedback.csv'
+    #feedback_df = pd.DataFrame([feedback_data])
+    
+    #if os.path.exists(feedback_file):
+        #feedback_df.to_csv(feedback_file, mode='a', header=False, index=False)
+    #else:
+        #feedback_df.to_csv(feedback_file, index=False)
+
+def reset_conversation():
+    st.session_state.conversation = []
+    st.session_state.messages = []
+    if 'task_choice' in st.session_state:
+        del st.session_state.task_choice
+    return None
+    #new 24 March
+    #user_input = st.text_input("Enter your prompt:")
+###########33
+
+# Initialize session state variables
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+if "examples_to_classify" not in st.session_state:
+    st.session_state.examples_to_classify = []
+if "system_role" not in st.session_state:
+    st.session_state.system_role = ""
+
+    
+
+# Main app title
+st.title("🤖🦙 Text Data Labeling and Generation App")
+# def embed_pdf_sidebar(pdf_path):
+#     with open(pdf_path, "rb") as f:
+#         base64_pdf = base64.b64encode(f.read()).decode('utf-8')
+#     pdf_display = f"""
+#         <iframe src="data:application/pdf;base64,{base64_pdf}" 
+#         width="100%" height="400" type="application/pdf"></iframe>
+#     """
+#     st.markdown(pdf_display, unsafe_allow_html=True)
+# 
+        
+    
+# Sidebar settings
+with st.sidebar:
+    st.title("⚙️ Settings")
+   
+
+#this last code works
+with st.sidebar:
+    st.markdown("### 📘Data Generation and Labeling Instructions")
+    #st.markdown("<h4 style='color: #4A90E2;'>📘    Instructions</h4>", unsafe_allow_html=True)
+    with open("User instructions.pdf", "rb") as f:
+        st.download_button(
+            label="📄 Download Instructions PDF",
+            data=f,
+            #file_name="instructions.pdf",
+            file_name="User instructions.pdf",
+            mime="application/pdf"
+        )
+   
+    selected_model = st.selectbox(
+        "Select Model",
+        ["meta-llama/Llama-3.2-11B-Vision-Instruct","meta-llama/Meta-Llama-3-8B-Instruct-Turbo", "meta-llama/Llama-3.3-70B-Instruct", "meta-llama/Llama-3.2-3B-Instruct","meta-llama/Llama-4-Scout-17B-16E-Instruct", "meta-llama/Meta-Llama-3-8B-Instruct",
+         "meta-llama/Llama-3.1-70B-Instruct"],
+        key='model_select'
+    )
+
+#################new oooo
+
+# # Model selection dropdown
+# selected_model = st.selectbox(
+#     "Select Model",
+#     [#"meta-llama/Meta-Llama-3-8B-Instruct-Turbo",
+#      "meta-llama/Llama-3.2-3B-Instruct",
+#      "meta-llama/Llama-3.3-70B-Instruct", 
+#      "meta-llama/Llama-3.2-3B-Instruct",
+#      "meta-llama/Llama-4-Scout-17B-16E-Instruct", 
+#      "meta-llama/Meta-Llama-3-8B-Instruct",
+#      "meta-llama/Llama-3.1-70B-Instruct"],
+#     key='model_select'
+# )
+
+# @st.cache_resource  # Cache the model to prevent reloading
+# def load_model(model_name):
+#     try:
+#         # Optimized model loading configuration
+#         model = AutoModelForCausalLM.from_pretrained(
+#             model_name,
+#             torch_dtype=torch.float16,        # Use half precision
+#             device_map="auto",                # Automatic device mapping
+#             load_in_8bit=True,               # Enable 8-bit quantization
+#             low_cpu_mem_usage=True,          # Optimize CPU memory usage
+#             max_memory={0: "10GB"}           # Limit GPU memory usage
+#         )
+        
+#         tokenizer = AutoTokenizer.from_pretrained(
+#             model_name,
+#             padding_side="left",
+#             truncation_side="left"
+#         )
+        
+#         return model, tokenizer
+    
+#     except Exception as e:
+#         st.error(f"Error loading model: {str(e)}")
+#         return None, None
+
+# # Load the selected model with optimizations
+# if selected_model:
+#     model, tokenizer = load_model(selected_model)
+
+#     # Check if model loaded successfully
+#     if model is not None:
+#         st.success(f"Successfully loaded {selected_model}")
+#     else:
+#         st.warning("Please select a different model or check your hardware capabilities")
+
+# # Function to generate text
+# def generate_response(prompt, model, tokenizer):
+#     try:
+#         inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+        
+#         with torch.no_grad():
+#             outputs = model.generate(
+#                 inputs["input_ids"],
+#                 max_length=256,
+#                 num_return_sequences=1,
+#                 temperature=0.7,
+#                 do_sample=True,
+#                 pad_token_id=tokenizer.pad_token_id
+#             )
+        
+#         response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+#         return response
+    
+#     except Exception as e:
+#         return f"Error generating response: {str(e)}"
+# ################
+
+# model = AutoModelForCausalLM.from_pretrained(
+#     "meta-llama/Meta-Llama-3-8B-Instruct",
+#     torch_dtype=torch.float16,  # Use half precision
+#     device_map="auto",          # Automatic device mapping
+#     load_in_8bit=True          # Load in 8-bit precision
+# )
+    temperature = st.slider(
+        "Temperature",
+        0.0, 1.0, 0.7,
+        help="Controls randomness in generation"
+    )
+    
+    st.button("🔄 New Conversation", on_click=reset_conversation)  
+    with st.container():
+        st.markdown(f"""
+           <div class="sidebar-info">
+               <h4>Current Model: {selected_model}</h4>
+               <p><em>Note: Generated content may be inaccurate or false. Check important info.</em></p>
+           </div>
+            """, unsafe_allow_html=True)
+    
+    feedback_url = "https://docs.google.com/forms/d/e/1FAIpQLSdZ_5mwW-pjqXHgxR0xriyVeRhqdQKgb5c-foXlYAV55Rilsg/viewform?usp=header"
+    st.sidebar.markdown(
+        f'<a href="{feedback_url}" target="_blank"><button style="width: 100%;">Feedback Form</button></a>',
+        unsafe_allow_html=True
+    )
+
+# Display conversation
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# Main content
+if 'task_choice' not in st.session_state:
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("📝 Data Generation", key="gen_button", help="Generate new data"):
+            st.session_state.task_choice = "Data Generation"
+    with col2:
+        if st.button("🏷️ Data Labeling", key="label_button", help="Label existing data"):
+            st.session_state.task_choice = "Data Labeling"
+
+if "task_choice" in st.session_state:
+    if st.session_state.task_choice == "Data Generation":
+        st.header("📝 Data Generation")
+
+       # 1. Domain selection
+        domain_selection = st.selectbox("Domain", [
+            "Restaurant reviews", "E-Commerce reviews", "News", "AG News", "Tourism", "Custom"
+        ])
+        
+        # 2. Handle custom domain input
+        custom_domain_valid = True  # Assume valid until proven otherwise
+        
+        if domain_selection == "Custom":
+            domain = st.text_input("Specify custom domain")
+            if not domain.strip():
+                st.error("Please specify a domain name.")
+                custom_domain_valid = False
+        else:
+            domain = domain_selection
+
+        # Classification type selection
+        classification_type = st.selectbox(
+            "Classification Type",
+            ["Sentiment Analysis", "Binary Classification", "Multi-Class Classification"]
+        )
+        # Labels setup based on classification type
+        #labels = []
+        labels = []
+        labels_valid = False
+        errors = []
+
+        def validate_binary_labels(labels):
+            errors = []
+            normalized = [label.strip().lower() for label in labels]
+        
+            if not labels[0].strip():
+                errors.append("First class name is required.")
+            if not labels[1].strip():
+                errors.append("Second class name is required.")
+            if normalized[0] == normalized[1] and all(normalized):
+                errors.append("Class names must be different.")
+            return errors
+        
+        if classification_type == "Sentiment Analysis":
+            st.write("### Sentiment Analysis Labels (Fixed)")
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.text_input("First class", "Positive", disabled=True)
+            with col2:
+                st.text_input("Second class", "Negative", disabled=True)
+            with col3:
+                st.text_input("Third class", "Neutral", disabled=True)
+            labels = ["Positive", "Negative", "Neutral"]
+        
+        elif classification_type == "Binary Classification":
+            st.write("### Binary Classification Labels")
+            col1, col2 = st.columns(2)
+            with col1:
+                label_1 = st.text_input("First class", "Positive")
+            with col2:
+                label_2 = st.text_input("Second class", "Negative")
+            
+            labels = [label_1, label_2]
+            errors = validate_binary_labels(labels)
+        
+            if errors:
+                st.error("\n".join(errors))
+            else:
+                st.success("Binary class names are valid and unique!")
+
+        
+        elif classification_type == "Multi-Class Classification":
+            st.write("### Multi-Class Classification Labels")
+        
+            default_labels_by_domain = {
+                "News": ["Political", "Sports", "Entertainment", "Technology", "Business"],
+                "AG News": ["World", "Sports", "Business", "Sci/Tech"],
+                "Tourism": ["Accommodation", "Transportation", "Tourist Attractions", 
+                            "Food & Dining", "Local Experience", "Adventure Activities",
+                            "Wellness & Spa", "Eco-Friendly Practices", "Family-Friendly",
+                            "Luxury Tourism"],
+                "Restaurant reviews": ["Italian", "French", "American"],
+                "E-Commerce reviews": ["Mobile Phones & Accessories", "Laptops & Computers","Kitchen & Dining",
+                                       "Beauty & Personal Care", "Home & Furniture", "Clothing & Fashion",
+                                      "Shoes & Handbags", "Health & Wellness", "Electronics & Gadgets",
+                                       "Books & Stationery","Toys & Games", "Sports & Fitness",
+                                       "Grocery & Gourmet Food","Watches & Accessories", "Baby Products"]
+            }
+        
+            num_classes = st.slider("Number of classes", 3, 15, 3)
+        
+            # Get defaults for selected domain, or empty list
+            defaults = default_labels_by_domain.get(domain, [])
+        
+            labels = []
+            errors = []
+            cols = st.columns(3)
+        
+            for i in range(num_classes):
+                with cols[i % 3]:
+                    default_value = defaults[i] if i < len(defaults) else ""
+                    label_input = st.text_input(f"Class {i+1}", default_value)
+                    normalized_label = label_input.strip().title()
+        
+                    if not normalized_label:
+                        errors.append(f"Class {i+1} name is required.")
+                    else:
+                        labels.append(normalized_label)
+        
+            # Check for duplicates (case-insensitive)
+            if len(labels) != len(set(labels)):
+                errors.append("Labels names must be unique (case-insensitive, normalized to Title Case).")
+
+            # Show validation results
+            if errors:
+                for error in errors:
+                    st.error(error)
+            else:
+                st.success("All Labels names are valid and unique!")
+            labels_valid = not errors  # Will be True only if there are no label errors     
+
+                    ##############
+    #new 22/4/2025
+    # add additional attributes
+        add_attributes = st.checkbox("Add additional attributes (optional)")
+        additional_attributes = []
+        
+        if add_attributes:
+            num_attributes = st.slider("Number of attributes to add", 1, 5, 1)
+            for i in range(num_attributes):
+                st.markdown(f"#### Attribute {i+1}")
+                attr_name = st.text_input(f"Name of attribute {i+1}", key=f"attr_name_{i}")
+                attr_topics = st.text_input(f"Topics (comma-separated) for {attr_name}", key=f"attr_topics_{i}")
+                if attr_name and attr_topics:
+                    topics_list = [topic.strip() for topic in attr_topics.split(",") if topic.strip()]
+                    additional_attributes.append({"attribute": attr_name, "topics": topics_list})
+
+################
+        
+        # Generation parameters
+        col1, col2 = st.columns(2)
+        with col1:
+            min_words = st.number_input("Min words", 1, 100, 20)
+        with col2:
+            max_words = st.number_input("Max words", min_words, 100, 50)
+
+        # Few-shot examples
+        use_few_shot = st.toggle("Use few-shot examples")
+        few_shot_examples = []
+        if use_few_shot:
+            num_examples = st.slider("Number of few-shot examples", 1, 10, 1)
+            for i in range(num_examples):
+                with st.expander(f"Example {i+1}"):
+                    content = st.text_area(f"Content", key=f"few_shot_content_{i}")
+                    label = st.selectbox(f"Label", labels, key=f"few_shot_label_{i}")
+                    if content and label:
+                        few_shot_examples.append({"content": content, "label": label})
+
+        num_to_generate = st.number_input("Number of examples", 1, 100, 10)
+        #sytem role after
+         # System role customization
+        #default_system_role = f"You are a professional {classification_type} expert, your role is to generate text examples for {domain} domain. Always generate unique diverse examples and do not repeat the generated data. The generated text should be between {min_words} to {max_words} words long."
+        # System role customization
+        default_system_role = (
+    f"You are a seasoned expert in {classification_type}, specializing in the {domain} domain. "
+    f" Your primary responsibility is to generate high-quality, diverse, and unique text examples "
+    f"tailored to this domain. Please ensure that each example adheres to the specified length "
+    f"requirements, ranging from {min_words} to {max_words} words, and avoid any repetition in the generated content."
+)
+        system_role = st.text_area("Modify System Role (optional)", 
+                                value=default_system_role,
+                                key="system_role_input")
+        st.session_state['system_role'] = system_role if system_role else default_system_role
+        # Labels initialization
+        #labels = []
+        
+        
+        user_prompt = st.text_area("User Prompt (optional)")
+
+        # Updated prompt template including system role
+        prompt_template = PromptTemplate(
+            input_variables=["system_role", "classification_type", "domain", "num_examples", 
+                           "min_words", "max_words", "labels", "user_prompt", "few_shot_examples", "additional_attributes"],
+            template=(
+               "{system_role}\n"
+                 "- Use the following parameters:\n"
+                "- Generate {num_examples} examples\n"
+                "- Each example should be between {min_words} to {max_words} words long\n"
+                "- Use these labels: {labels}.\n"
+                "- Use the following additional attributes:\n"
+                "- {additional_attributes}\n"
+                "- Generate the examples in this format: 'Example text. Label: label'\n"
+                "- Do not include word counts or any additional information\n"
+                "- Always use your creativity and intelligence to generate unique and diverse text data\n"
+                "- In sentiment analysis, ensure that the sentiment classification is clearly identified as Positive, Negative, or Neutral. Do not leave the sentiment ambiguous.\n"
+                "- In binary sentiment analysis, classify text strictly as either Positive or Negative. Do not include or imply Neutral as an option.\n"
+                "- Write unique examples every time.\n"
+                "- DO NOT REPEAT your gnerated text. \n"
+                "- For each Output, describe it once and move to the next.\n"
+                "- List each Output only once, and avoid repeating details.\n"
+                "- Additional instructions: {user_prompt}\n\n"
+                "- Use the following examples as a reference in the generation process\n\n {few_shot_examples}. \n"
+                "- Think step by step, generate numbered examples, and check each newly generated example to ensure it has not been generated before. If it has, modify it"
+                
+             )
+         )
+        #    template=(
+        #         "{system_role}\n"
+        #         "- Use the following parameters:\n"
+        #         "- Generate {num_examples} examples\n"
+        #         "- Each example should be between {min_words} to {max_words} words long\n"
+        #         "- Use these labels: {labels}.\n"
+        #         "- Use the following additional attributes:\n"
+        #         "{additional_attributes}\n"
+        #         #"- Format each example like this: 'Example text. Label: [label]. Attribute1: [topic1]. Attribute2: [topic2]'\n"
+        #         "- Generate the examples in this format: 'Example text. Label: label'\n"
+        #         "- Additional instructions: {user_prompt}\n"
+        #         "- Use these few-shot examples if provided:\n{few_shot_examples}\n"
+        #         "- Think step by step and ensure examples are unique and not repeated."
+        #     )
+        # )
+        ##########new 22/4/2025
+        formatted_attributes = "\n".join([
+            f"- {attr['attribute']}: {', '.join(attr['topics'])}" for attr in additional_attributes
+        ])
+#######################
+        
+        # Generate system prompt
+        system_prompt = prompt_template.format(
+            system_role=st.session_state['system_role'],
+            classification_type=classification_type,
+            domain=domain,
+            num_examples=num_to_generate,
+            min_words=min_words,
+            max_words=max_words,
+            labels=", ".join(labels),
+            user_prompt=user_prompt,
+            few_shot_examples="\n".join([f"{ex['content']}\nLabel: {ex['label']}" for ex in few_shot_examples]) if few_shot_examples else "",
+            additional_attributes=formatted_attributes
+        )
+        
+
+        # Store system prompt in session state
+        st.session_state['system_prompt'] = system_prompt
+
+        # Display system prompt
+        st.write("System Prompt:")
+        st.text_area("Current System Prompt", value=st.session_state['system_prompt'], 
+                    height=400, disabled=True)
+        
+
+        if st.button("🎯 Generate Examples"):
+            #
+            errors = []
+            if domain_selection == "Custom" and not domain.strip():
+                st.warning("Custom domain name is required.")
+            elif len(labels) != len(set(labels)):
+                st.warning("Class names must be unique.")
+            elif any(not lbl.strip() for lbl in labels):
+                st.warning("All class labels must be filled in.")
+            #else:
+                #st.success("Generating examples for domain: {domain}")
+                    
+            #if not custom_domain_valid:
+                #st.warning("Custom domain name is required.")
+            #elif not labels_valid:
+                #st.warning("Please fix the label errors before generating examples.")
+            #else:
+                # Proceed to generate examples
+                #st.success(f"Generating examples for domain: {domain}")
+                
+            with st.spinner("Generating examples..."):
+                try:
+                    stream = client.chat.completions.create(
+                        model=selected_model,
+                        messages=[{"role": "system", "content": st.session_state['system_prompt']}],
+                        temperature=temperature,
+                        stream=True,
+                        #max_tokens=80000,
+                        max_tokens=4000,
+                        top_p=0.9,
+                       # repetition_penalty=1.2,
+                        #frequency_penalty=0.5,      # Discourages frequent words
+                        #presence_penalty=0.6,  
+                    )
+ #st.session_state['system_prompt'] = system_prompt
+                    #new 24 march
+                    st.session_state.messages.append({"role": "user", "content": system_prompt})
+                 # # ####################
+                    response = st.write_stream(stream)
+                    st.session_state.messages.append({"role": "assistant", "content": response})
+                        # Initialize session state variables if they don't exist
+                    if 'system_prompt' not in st.session_state:
+                        st.session_state.system_prompt = system_prompt
+                    
+                    if 'response' not in st.session_state:
+                        st.session_state.response = response
+                    
+                    if 'generated_examples' not in st.session_state:
+                        st.session_state.generated_examples = []
+                    
+                    if 'generated_examples_csv' not in st.session_state:
+                        st.session_state.generated_examples_csv = None
+                    
+                    if 'generated_examples_json' not in st.session_state:
+                        st.session_state.generated_examples_json = None
+                    
+                    # Parse response and generate examples list
+                    examples_list = []
+                    for line in response.split('\n'):
+                        if line.strip():
+                            parts = line.rsplit('Label:', 1)
+                            if len(parts) == 2:
+                                text = parts[0].strip()
+                                label = parts[1].strip()
+                                if text and label:
+                                    examples_list.append({
+                                        'text': text,
+                                        'label': label,
+                                        'system_prompt': st.session_state.system_prompt,
+                                        'system_role': st.session_state.system_role,
+                                        'task_type': 'Data Generation',
+                                        'Use few-shot example?': 'Yes' if use_few_shot else 'No',
+                                    })
+
+                                    # example_dict = {
+                                    #     'text': text,
+                                    #     'label': label,
+                                    #     'system_prompt': st.session_state.system_prompt,
+                                    #     'system_role': st.session_state.system_role,
+                                    #     'task_type': 'Data Generation',
+                                    #     'Use few-shot example?': 'Yes' if use_few_shot else 'No',
+                                    # }
+                                    # for attr in additional_attributes:
+                                    #     example_dict[attr['attribute']] = random.choice(attr['topics'])
+                                    
+                                    # examples_list.append(example_dict)
+                                   
+
+                    if examples_list:
+                        # Update session state with new data
+                        st.session_state.generated_examples = examples_list
+                        
+                        # Generate CSV and JSON data
+                        df = pd.DataFrame(examples_list)
+                        st.session_state.generated_examples_csv = df.to_csv(index=False).encode('utf-8')
+                        st.session_state.generated_examples_json = json.dumps(examples_list, indent=2).encode('utf-8')
+
+                       # Vertical layout with centered "or" between buttons
+                        st.download_button(
+                            "📥 Download Generated Examples (CSV)",
+                            st.session_state.generated_examples_csv,
+                            "generated_examples.csv",
+                            "text/csv",
+                            key='download-csv-persistent'
+                        )
+                        
+                        # Add space and center the "or"
+                        st.markdown("""
+                        <div style='text-align: left; margin:15px 0; font-weight: 600; color: #666;'>. . . . . .         or</div>
+                        """, unsafe_allow_html=True)
+                        
+                        st.download_button(
+                            "📥 Download Generated Examples (JSON)",
+                            st.session_state.generated_examples_json,
+                            "generated_examples.json",
+                            "application/json",
+                            key='download-json-persistent'
+                        )
+                        # # Display the labeled examples
+                        # st.markdown("##### 📋 Labeled Examples Preview")
+                        # st.dataframe(df, use_container_width=True)
+                        
+                    if st.button("Continue"):
+                        if follow_up == "Generate more examples":
+                            st.experimental_rerun()
+                        elif follow_up == "Data Labeling":
+                            st.session_state.task_choice = "Data Labeling"
+                            st.experimental_rerun()
+
+                except Exception as e:
+                    st.error("An error occurred during generation.")
+                    st.error(f"Details: {e}")
+
+    
+# Lableing Process
+    elif st.session_state.task_choice == "Data Labeling":
+        st.header("🏷️ Data Labeling")
+        
+        domain_selection = st.selectbox("Domain", ["Restaurant reviews", "E-Commerce reviews", "News", "AG News", "Tourism", "Custom"])
+            # 2. Handle custom domain input
+        custom_domain_valid = True  # Assume valid until proven otherwise
+        
+        if domain_selection == "Custom":
+            domain = st.text_input("Specify custom domain")
+            if not domain.strip():
+                st.error("Please specify a domain name.")
+                custom_domain_valid = False
+        else:
+            domain = domain_selection
+
+
+        # Classification type selection
+        classification_type = st.selectbox(
+            "Classification Type",
+            ["Sentiment Analysis", "Binary Classification", "Multi-Class Classification", "Named Entity Recognition (NER)"]
+        )
+#NNew edit
+        # Labels setup based on classification type
+        labels = []
+        labels_valid = False
+        errors = []
+
+        if classification_type == "Sentiment Analysis":
+            st.write("### Sentiment Analysis Labels (Fixed)")
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                label_1 = st.text_input("First class", "Positive", disabled=True)
+            with col2:
+                label_2 = st.text_input("Second class", "Negative", disabled=True)
+            with col3:
+                label_3 = st.text_input("Third class", "Neutral", disabled=True)
+            labels = ["Positive", "Negative", "Neutral"]
+
+
+        elif classification_type == "Binary Classification":
+            st.write("### Binary Classification Labels")
+            col1, col2 = st.columns(2)
+        
+            with col1:
+                label_1 = st.text_input("First class", "Positive")
+            with col2:
+                label_2 = st.text_input("Second class", "Negative")
+        
+            errors = []
+            labels = [label_1.strip(), label_2.strip()]
+            
+
+            # Strip and lower-case labels for validation
+            label_1 = labels[0].strip()
+            label_2 = labels[1].strip()
+            
+            # Check for empty class names
+            if not label_1:
+                errors.append("First class name is required.")
+            if not label_2:
+                errors.append("Second class name is required.")
+            
+            # Check for duplicates (case insensitive)
+            if label_1.lower() == label_2.lower() and label_1 and label_2:
+                errors.append("Class names must be different.")
+            
+            # Show errors or success
+            if errors:
+                for error in errors:
+                    st.error(error)
+            else:
+                st.success("Binary class names are valid and unique!")
+
+                               
+        elif classification_type == "Multi-Class Classification":
+                st.write("### Multi-Class Classification Labels")
+            
+                default_labels_by_domain = {
+                    "News": ["Political", "Sports", "Entertainment", "Technology", "Business"],
+                    "AG News": ["World", "Sports", "Business", "Sci/Tech"],
+                    "Tourism": ["Accommodation", "Transportation", "Tourist Attractions", 
+                                "Food & Dining", "Local Experience", "Adventure Activities",
+                                "Wellness & Spa", "Eco-Friendly Practices", "Family-Friendly",
+                                "Luxury Tourism"],
+                    "Restaurant reviews": ["Italian", "French", "American"],
+                    "E-Commerce reviews": ["Mobile Phones & Accessories", "Laptops & Computers","Kitchen & Dining",
+                                       "Beauty & Personal Care", "Home & Furniture", "Clothing & Fashion",
+                                      "Shoes & Handbags", "Health & Wellness", "Electronics & Gadgets",
+                                       "Books & Stationery","Toys & Games", "Sports & Fitness",
+                                       "Grocery & Gourmet Food","Watches & Accessories", "Baby Products"]
+            }
+        
+              
+            
+                # Ask user how many classes they want to define
+                num_classes = st.slider("Select the number of classes (labels)", min_value=3, max_value=10, value=3)
+            
+                # Use default labels based on selected domain, if available
+                defaults = default_labels_by_domain.get(domain, [])
+            
+                labels = []
+                errors = []
+                cols = st.columns(3)  # For nicely arranged label inputs
+            
+                for i in range(num_classes):
+                    with cols[i % 3]:  # Distribute inputs across columns
+                        default_value = defaults[i] if i < len(defaults) else ""
+                        label_input = st.text_input(f"Label {i + 1}", default_value)
+                        normalized_label = label_input.strip().title()
+            
+                        if not normalized_label:
+                            errors.append(f"Label {i + 1} is required.")
+                        else:
+                            labels.append(normalized_label)
+            
+                # Check for duplicates (case-insensitive)
+                normalized_set = {label.lower() for label in labels}
+                if len(labels) != len(normalized_set):
+                    errors.append("Label names must be unique (case-insensitive).")
+            
+                # Show validation results
+                if errors:
+                    for error in errors:
+                        st.error(error)
+                else:
+                    st.success("All label names are valid and unique!")
+            
+                labels_valid = not errors  # True if no validation errors
+
+        elif classification_type == "Named Entity Recognition (NER)":
+            # # NER entity options
+            # ner_entities = [
+            #     "PERSON - Names of people, fictional characters, historical figures",
+            #     "ORG - Companies, institutions, agencies, teams",
+            #     "LOC - Physical locations (mountains, oceans, etc.)",
+            #     "GPE - Countries, cities, states, political regions",
+            #     "DATE - Calendar dates, years, centuries",
+            #     "TIME - Times, durations",
+            #     "MONEY - Monetary values with currency"
+            # ]
+            # selected_entities = st.multiselect(
+            #      "Select entities to recognize", 
+            #     ner_entities,
+            #     default=["PERSON - Names of people, fictional characters, historical figures",
+            #              "ORG - Companies, institutions, agencies, teams",
+            #             "LOC - Physical locations (mountains, oceans, etc.)",
+            #             "GPE - Countries, cities, states, political regions",
+            #             "DATE - Calendar dates, years, centuries",
+            #             "TIME - Times, durations",
+            #             "MONEY - Monetary values with currency"],
+            #             key="ner_entity_selection"
+            # )
+            #new 22/4/2025
+            #if classification_type == "Named Entity Recognition (NER)":
+            use_few_shot = True
+            #new 22/4/2025
+            few_shot_examples = [
+                {"content": "Mount Everest is the tallest mountain in the world.", "label": "LOC: Mount Everest"},
+                {"content": "The President of the United States visited Paris last summer.", "label": "GPE: United States, GPE: Paris"},
+                {"content": "Amazon is expanding its offices in Berlin.", "label": "ORG: Amazon, GPE: Berlin"},
+                {"content": "J.K. Rowling wrote the Harry Potter books.", "label": "PERSON: J.K. Rowling"},
+                {"content": "Apple was founded in California in 1976.", "label": "ORG: Apple, GPE: California, DATE: 1976"},
+                {"content": "The Nile is the longest river in Africa.", "label": "LOC: Nile, GPE: Africa"},
+                {"content": "He arrived at 3 PM for the meeting.", "label": "TIME: 3 PM"},
+                {"content": "She bought the dress for $200.", "label": "MONEY: $200"},
+                {"content": "The event is scheduled for July 4th.", "label": "DATE: July 4th"},
+                {"content": "The World Health Organization is headquartered in Geneva.", "label": "ORG: World Health Organization, GPE: Geneva"}
+            ]
+###########
+        
+            st.write("### Named Entity Recognition (NER) Entities")
+
+            # Predefined standard entities
+            ner_entities = [
+                "PERSON - Names of people, fictional characters, historical figures",
+                "ORG - Companies, institutions, agencies, teams",
+                "LOC - Physical locations (mountains, oceans, etc.)",
+                "GPE - Countries, cities, states, political regions",
+                "DATE - Calendar dates, years, centuries",
+                "TIME - Times, durations",
+                "MONEY - Monetary values with currency"
+            ]
+            
+            # User can add custom NER types
+            custom_ner_entities = []
+            if st.checkbox("Add custom NER entities?"):
+                num_custom_ner = st.slider("Number of custom NER entities", 1, 10, 1)
+                for i in range(num_custom_ner):
+                    st.markdown(f"#### Custom Entity {i+1}")
+                    custom_type = st.text_input(f"Entity type {i+1}", key=f"custom_ner_type_{i}")
+                    custom_description = st.text_input(f"Description for {custom_type}", key=f"custom_ner_desc_{i}")
+                    if custom_type and custom_description:
+                        custom_ner_entities.append(f"{custom_type.upper()} - {custom_description}")
+            
+            # Combine built-in and custom NERs
+            all_ner_options = ner_entities + custom_ner_entities
+            
+            selected_entities = st.multiselect(
+                "Select entities to recognize", 
+                all_ner_options,
+                default=ner_entities
+            )
+            
+            # Extract entity type names (before the dash)
+            labels = [entity.split(" - ")[0].strip() for entity in selected_entities]
+
+            if not labels:
+                st.warning("Please select at least one entity type.")
+                labels = ["PERSON"]
+
+            ##########
+        
+            # # Extract just the entity type (before the dash)
+            # labels = [entity.split(" - ")[0] for entity in selected_entities]
+        
+            # if not labels:
+            #     st.warning("Please select at least one entity type")
+            #     labels = ["PERSON"]  # Default if nothing selected
+
+            
+                            
+
+
+    #NNew edit
+            # elif classification_type == "Multi-Class Classification":
+            #     st.write("### Multi-Class Classification Labels")
+            
+            #     default_labels_by_domain = {
+            #         "News": ["Political", "Sports", "Entertainment", "Technology", "Business"],
+            #         "AG News": ["World", "Sports", "Business", "Sci/Tech"],
+            #         "Tourism": ["Accommodation", "Transportation", "Tourist Attractions", 
+            #                     "Food & Dining", "Local Experience", "Adventure Activities",
+            #                     "Wellness & Spa", "Eco-Friendly Practices", "Family-Friendly",
+            #                     "Luxury Tourism"],
+            #         "Restaurant reviews": ["Italian", "French", "American"]
+            #     }
+            #     num_classes = st.slider("Number of classes", 3, 10, 3)
+            
+            #     # Get defaults for selected domain, or empty list
+            #     defaults = default_labels_by_domain.get(domain, [])
+            
+            #     labels = []
+            #     errors = []
+            #     cols = st.columns(3)
+            
+            #     for i in range(num_classes):
+            #         with cols[i % 3]:
+            #             default_value = defaults[i] if i < len(defaults) else ""
+            #             label_input = st.text_input(f"Class {i+1}", default_value)
+            #             normalized_label = label_input.strip().title()
+            
+            #             if not normalized_label:
+            #                 errors.append(f"Class {i+1} name is required.")
+            #             else:
+            #                 labels.append(normalized_label)
+            
+            #     # Check for duplicates (case-insensitive)
+            #     if len(labels) != len(set(labels)):
+                #     errors.append("Labels names must be unique (case-insensitive, normalized to Title Case).")
+    
+                # # Show validation results
+                # if errors:
+                #     for error in errors:
+                #         st.error(error)
+                # else:
+                #     st.success("All Labels names are valid and unique!")
+                # labels_valid = not errors  # Will be True only if there are no label errors
+
+                   
+
+            
+        # else:
+        #     num_classes = st.slider("Number of classes", 3, 23, 3, key="label_num_classes")
+        #     labels = []
+        #     cols = st.columns(3)
+        #     for i in range(num_classes):
+        #         with cols[i % 3]:
+        #             label = st.text_input(f"Class {i+1}", f"Class_{i+1}", key=f"label_class_{i}")
+        #             labels.append(label)
+
+        use_few_shot = st.toggle("Use few-shot examples for labeling")
+        few_shot_examples = []
+        if use_few_shot:
+            num_few_shot = st.slider("Number of few-shot examples", 1, 10, 1)
+            for i in range(num_few_shot):
+                with st.expander(f"Few-shot Example {i+1}"):
+                    content = st.text_area(f"Content", key=f"label_few_shot_content_{i}")
+                    label = st.selectbox(f"Label", labels, key=f"label_few_shot_label_{i}")
+                    if content and label:
+                        few_shot_examples.append(f"{content}\nLabel: {label}")
+
+        num_examples = st.number_input("Number of examples to classify", 1, 100, 1)
+    
+        examples_to_classify = []
+        if num_examples <= 10:
+            for i in range(num_examples):
+                example = st.text_area(f"Example {i+1}", key=f"example_{i}")
+                if example:
+                    examples_to_classify.append(example)
+        else:
+            examples_text = st.text_area(
+                "Enter examples (one per line)",
+                height=300,
+                help="Enter each example on a new line"
+            )
+            if examples_text:
+                examples_to_classify = [ex.strip() for ex in examples_text.split('\n') if ex.strip()]
+                if len(examples_to_classify) > num_examples:
+                    examples_to_classify = examples_to_classify[:num_examples]
+                    
+        #New Wedyan
+        #default_system_role = f"You are a professional {classification_type} expert, your role is to classify the provided text examples for {domain} domain."
+         # System role customization  
+        default_system_role = (f"You are a highly skilled {classification_type} expert."
+        f" Your task is to accurately classify the provided text examples within the {domain} domain."
+        f" Ensure that all classifications are precise, context-aware, and aligned with domain-specific standards and best practices."
+    )
+        system_role = st.text_area("Modify System Role (optional)", 
+                                value=default_system_role,
+                                key="system_role_input")
+        st.session_state['system_role'] = system_role if system_role else default_system_role
+        # Labels initialization
+        #labels = []
+        ####
+
+        user_prompt = st.text_area("User prompt (optional)", key="label_instructions")
+
+        few_shot_text = "\n\n".join(few_shot_examples) if few_shot_examples else ""
+        examples_text = "\n".join([f"{i+1}. {ex}" for i, ex in enumerate(examples_to_classify)])
+    
+        # Customize prompt template based on classification type
+        if classification_type == "Named Entity Recognition (NER)":
+            # label_prompt_template = PromptTemplate(
+            #     input_variables=["system_role", "labels", "few_shot_examples", "examples", "domain", "user_prompt"],
+            #     template=(
+            #         "{system_role}\n"
+            #         #"- You are a professional Named Entity Recognition (NER) expert in {domain} domain. Your role is to identify and extract the following entity types: {labels}.\n"
+            #         "- For each text example provided, identify all entities of the requested types.\n"
+            #         "- Use the following entities: {labels}.\n"
+            #         "- Return each example followed by the entities you found in this format: 'Example text.\n \n Entities:\n [ENTITY_TYPE: entity text\n\n, ENTITY_TYPE: entity text\n\n, ...] or [No entities found]'\n"
+            #         "- If no entities of the requested types are found, indicate 'No entities found' in this text.\n"
+            #         "- Be precise about entity boundaries - don't include unnecessary words.\n"
+            #         "- Do not provide any additional information or explanations.\n"
+            #         "- Additional instructions:\n {user_prompt}\n\n"
+            #         "- Use user few-shot examples as guidance if provided:\n{few_shot_examples}\n\n"
+            #         "- Examples to analyze:\n{examples}\n\n"
+            #         "Output:\n"
+            #     )
+            # )
+            #new 22/4/2025
+            # label_prompt_template = PromptTemplate(
+            #     input_variables=["system_role", "labels", "few_shot_examples", "examples", "domain", "user_prompt"],
+            #     template=(
+            #         "{system_role}\n"
+            #         "- You are performing Named Entity Recognition (NER) in the domain of {domain}.\n"
+            #         "- Use the following entity types: {labels}.\n\n"
+            #         "### Reasoning Steps:\n"
+            #         "1. Read the example carefully.\n"
+            #         "2. For each named entity mentioned, determine its meaning and role in the sentence.\n"
+            #         "3. Think about the **context**: Is it a physical location (LOC)? A geopolitical region (GPE)? A person (PERSON)?\n"
+            #         "4. Based on the definition of each label, assign the most **specific and correct** label.\n\n"
+            #         "For example:\n"
+            #         "- 'Mount Everest' → LOC (it's a mountain)\n"
+            #         "- 'France' → GPE (it's a country)\n"
+            #         "- 'Microsoft' → ORG\n"
+            #         "- 'John Smith' → PERSON\n\n"
+            #         "- Return each example followed by the entities you found in this format:\n"
+            #         "'Example text.'\nEntities: [ENTITY_TYPE: entity text, ENTITY_TYPE: entity text, ...] or [No entities found]\n"
+            #         "- If no entities of the requested types are found, return 'No entities found'.\n"
+            #         "- Be precise about entity boundaries - don't include extra words.\n"
+            #         "- Do not explain or justify your answers.\n\n"
+            #         "Additional instructions:\n{user_prompt}\n\n"
+            #         "Few-shot examples:\n{few_shot_examples}\n\n"
+            #         "Examples to label:\n{examples}\n"
+            #         "Output:\n"
+            #     )
+            #)
+            # label_prompt_template = PromptTemplate(
+            #     input_variables=["system_role", "labels", "few_shot_examples", "examples", "domain", "user_prompt"],
+            #     template=(
+            #         "{system_role}\n"
+            #         "- You are an expert at Named Entity Recognition (NER) for domain: {domain}.\n"
+            #         "- Use these entity types: {labels}.\n\n"
+            #         "### Output Format:\n"
+            #         # "Return each example followed by the entities you found in this format: 'Example text.\n Entities:\n [ENTITY_TYPE: entity text\n\"
+            #         "Return each example followed by the entities you found in this format: 'Example text.\n 'Entity types:\n "Then group the entities under each label like this:\n" "
+            #         #"Then Start with this line exactly: 'Entity types\n'\n"
+            #         #"Then group the entities under each label like this:\n"
+            #         "\n PERSON – Angela Merkel, John Smith\n\n"
+            #         "\ ORG – Google, United Nations\n\n"
+            #         "\n DATE – January 1st, 2023\n\n"
+            #         "\n ... and so on.\n\n"
+            #         "If entity {labels} not found, do not write it in your response\n"
+            #         "- Do NOT output them inline after the text.\n"
+            #         "- Do NOT repeat the sentence.\n"
+            #         "- If no entities are found for a type, skip it.\n"
+            #         "- Keep the format consistent.\n\n"
+            #         "User Instructions:\n{user_prompt}\n\n"
+            #         "Few-shot Examples:\n{few_shot_examples}\n\n"
+            #         "Examples to analyze:\n{examples}"
+            #       )
+            # )
+
+            
+            label_prompt_template = PromptTemplate(
+                input_variables=["system_role", "labels", "few_shot_examples", "examples", "domain", "user_prompt"],
+                template=(
+                    "{system_role}\n"
+                    "- You are an expert at Named Entity Recognition (NER) for domain: {domain}.\n"
+                    "- Use these entity types: {labels}.\n\n"
+                    "### Output Format:\n"
+                    "Return each example followed by the entities you found in this format:\n"
+                    "'Example text.\nEntity types:\n"
+                    "Then group the entities under each label like this:\n"
+                    "\nPERSON – Angela Merkel, John Smith\n"
+                    "ORG – Google, United Nations\n"
+                    "DATE – January 1st, 2023\n"
+                    "... and so on.\n\n"
+                    "Each new entities group should be in a new line.\n"
+                    "If entity type {labels} is not found, do not write it in your response.\n"
+                    "- Do NOT output them inline after the text.\n"
+                    "- Do NOT repeat the sentence.\n"
+                    "- If no entities are found for a type, skip it.\n"
+                    "- Keep the format consistent.\n\n"
+                    "User Instructions:\n{user_prompt}\n\n"
+                    "Few-shot Examples:\n{few_shot_examples}\n\n"
+                    "Examples to analyze:\n{examples}"
+                )
+            )
+
+#######
+        else:
+                label_prompt_template = PromptTemplate(
+
+                input_variables=["system_role", "classification_type", "labels", "few_shot_examples", "examples","domain", "user_prompt"],
+                template=(
+                    #"- Let'\s think step by step:"
+                    "{system_role}\n"
+                   # "- You are a professional {classification_type} expert in {domain} domain. Your role is to classify the following examples using these labels: {labels}.\n"
+                    "- Use the following instructions:\n"
+                    "- Use the following labels: {labels}.\n"
+                    "- Return the classified text followed by the label in this format: 'text. Label: [label]'\n"
+                    "- Do not provide any additional information or explanations\n"
+                    "- User prompt:\n {user_prompt}\n\n"
+                    "- Use user provided examples as guidence in the classification process:\n\n {few_shot_examples}\n"
+                    "- Examples to classify:\n{examples}\n\n"
+                    "- Think step by step then classify the examples"
+                    #"Output:\n"
+                ))
+            
+        # Check if few_shot_examples is already a formatted string
+           # Check if few_shot_examples is already a formatted string
+        if isinstance(few_shot_examples, str):
+            formatted_few_shot = few_shot_examples
+        # If it's a list of already formatted strings
+        elif isinstance(few_shot_examples, list) and all(isinstance(ex, str) for ex in few_shot_examples):
+            formatted_few_shot = "\n".join(few_shot_examples)
+        # If it's a list of dictionaries with 'content' and 'label' keys
+        elif isinstance(few_shot_examples, list) and all(isinstance(ex, dict) and 'content' in ex and 'label' in ex for ex in few_shot_examples):
+            formatted_few_shot = "\n".join([f"{ex['content']}\nLabel: {ex['label']}" for ex in few_shot_examples])
+        else:
+            formatted_few_shot = ""
+# #new 22/4/2025
+#         few_shot_examples = [
+#             {"content": "Mount Everest is the tallest mountain in the world.", "label": "LOC: Mount Everest"},
+#             {"content": "The President of the United States visited Paris last summer.", "label": "GPE: United States, GPE: Paris"},
+#             {"content": "Amazon is expanding its offices in Berlin.", "label": "ORG: Amazon, GPE: Berlin"},
+#             {"content": "J.K. Rowling wrote the Harry Potter books.", "label": "PERSON: J.K. Rowling"},
+#             {"content": "Apple was founded in California in 1976.", "label": "ORG: Apple, GPE: California, DATE: 1976"},
+#             {"content": "The Nile is the longest river in Africa.", "label": "LOC: Nile, GPE: Africa"},
+#             {"content": "He arrived at 3 PM for the meeting.", "label": "TIME: 3 PM"},
+#             {"content": "She bought the dress for $200.", "label": "MONEY: $200"},
+#             {"content": "The event is scheduled for July 4th.", "label": "DATE: July 4th"},
+#             {"content": "The World Health Organization is headquartered in Geneva.", "label": "ORG: World Health Organization, GPE: Geneva"}
+#         ]
+# ###########
+# new 22/4/2025
+        #formatted_few_shot = "\n".join([f"{ex['content']}\nEntities: [{ex['label']}]" for ex in few_shot_examples])
+        formatted_few_shot = "\n\n".join([f"{ex['content']}\n\nEntity types\n{ex['label']}" for ex in few_shot_examples])
+
+        ###########
+        system_prompt = label_prompt_template.format(
+            system_role=st.session_state['system_role'],
+            classification_type=classification_type,
+            domain=domain,
+            examples="\n".join(examples_to_classify),
+            labels=", ".join(labels),
+            user_prompt=user_prompt,
+            few_shot_examples=formatted_few_shot
+        )
+
+        # Step 2: Store the system_prompt in st.session_state
+        st.session_state['system_prompt'] = system_prompt           
+#::contentReference[oaicite:0]{index=0}
+        st.write("System Prompt:")
+        #st.code(system_prompt)
+        #st.code(st.session_state['system_prompt'])
+        st.text_area("System Prompt", value=st.session_state['system_prompt'], height=300, max_chars=None, key=None, help=None, disabled=True)
+            
+        
+
+        if st.button("🏷️ Label Data"):
+            if examples_to_classify:
+                with st.spinner("Labeling data..."):
+                    #Generate the system prompt based on classification type
+                    if classification_type == "Named Entity Recognition (NER)":
+                        system_prompt = label_prompt_template.format(
+                            system_role=st.session_state['system_role'],
+                            labels=", ".join(labels),
+                            domain = domain,
+                            few_shot_examples=few_shot_text,
+                            examples=examples_text,
+                            user_prompt=user_prompt
+                    #new 
+                            #'Use few-shot example?': 'Yes' if use_few_shot else 'No',
+                       )
+                    # if classification_type == "Named Entity Recognition (NER)":
+                    #     # Step 1: Split the full response by example
+                    #     raw_outputs = [block.strip() for block in response.strip().split("Entity types") if block.strip()]
+                    #     inputs = [ex.strip() for ex in examples_to_classify]
+                    
+                    #     # Step 2: Match inputs with NER output blocks
+                    #     labeled_examples = []
+                    #     for i, (text, output_block) in enumerate(zip(inputs, raw_outputs)):
+                    #         labeled_examples.append({
+                    #             'text': text,
+                    #             'entities': f"Entity types\n{output_block.strip()}",
+                    #             'system_prompt': st.session_state.system_prompt,
+                    #             'system_role': st.session_state.system_role,
+                    #             'task_type': 'Named Entity Recognition (NER)',
+                    #             'Use few-shot example?': 'Yes' if use_few_shot else 'No',
+                    #         })
+                    
+                    # if classification_type == "Named Entity Recognition (NER)":
+                    #     # Step 1: Split the full response by example
+                    #     raw_outputs = [block.strip() for block in response.strip().split("Entity types") if block.strip()]
+                    #     inputs = [ex.strip() for ex in examples_to_classify]
+                    
+                    #     # Step 2: Match inputs with NER output blocks
+                    #     labeled_examples = []
+                    #     for i, (text, output_block) in enumerate(zip(inputs, raw_outputs)):
+                    #         labeled_examples.append({
+                    #             'text': text,
+                    #             'entities': f"Entity types\n{output_block.strip()}",
+                    #             'system_prompt': st.session_state.system_prompt,
+                    #             'system_role': st.session_state.system_role,
+                    #             'task_type': 'Named Entity Recognition (NER)',
+                    #             'Use few-shot example?': 'Yes' if use_few_shot else 'No',
+                    #         })
+
+        
+                    # import re
+
+                    # if classification_type == "Named Entity Recognition (NER)":
+                    #     # Use regex to split on "Entity types" while keeping it attached to each block
+                    #     blocks = re.split(r"(Entity types)", response.strip())
+                        
+                    #     # Recombine 'Entity types' with each block after splitting
+                    #     raw_outputs = [
+                    #         (blocks[i] + blocks[i+1]).strip()
+                    #         for i in range(1, len(blocks) - 1, 2)
+                    #     ]
+                        
+                    #     inputs = [ex.strip() for ex in examples_to_classify]
+                    
+                    #     labeled_examples = []
+                    #     for i, (text, output_block) in enumerate(zip(inputs, raw_outputs)):
+                    #         labeled_examples.append({
+                    #             'text': text,
+                    #             'entities': output_block,
+                    #             'system_prompt': st.session_state.system_prompt,
+                    #             'system_role': st.session_state.system_role,
+                    #             'task_type': 'Named Entity Recognition (NER)',
+                    #             'Use few-shot example?': 'Yes' if use_few_shot else 'No',
+                    #         })
+
+
+                    else:
+                        system_prompt = label_prompt_template.format(
+                            classification_type=classification_type,
+                            system_role=st.session_state['system_role'],
+                            domain = domain,
+                            labels=", ".join(labels),
+                            few_shot_examples=few_shot_text,
+                            examples=examples_text,
+                            user_prompt=user_prompt
+                        )
+                    try:
+                        stream = client.chat.completions.create(
+                            model=selected_model,
+                            messages=[{"role": "system", "content": system_prompt}],
+                            temperature=temperature,
+                            stream=True,
+                            #max_tokens=20000,
+                            max_tokens=4000,
+                            top_p = 0.9,
+                          
+                        )
+                        #new 24 March
+                        # Append user message
+                        st.session_state.messages.append({"role": "user", "content": system_prompt})
+                        #################
+                        response = st.write_stream(stream)
+                        st.session_state.messages.append({"role": "assistant", "content": response})
+                         # Display the labeled examples
+                        #    # Optional: If you want to add it as a chat-style message log
+                        # preview_str = st.session_state.labeled_preview.to_markdown(index=False)
+                        # st.session_state.messages.append({"role": "assistant", "content": f"Here is a preview of the labeled examples:\n\n{preview_str}"})
+                                                                                                    
+
+                        # # Stream response and append assistant message
+                        # #14/4/2024
+                        # response = st.write_stream(stream)
+                        # st.session_state.messages.append({"role": "assistant", "content": response})
+
+                          # Initialize session state variables if they don't exist
+                        if 'system_prompt' not in st.session_state:
+                            st.session_state.system_prompt = system_prompt
+                        
+                        if 'response' not in st.session_state:
+                            st.session_state.response = response
+                        
+                        if 'generated_examples' not in st.session_state:
+                            st.session_state.generated_examples = []
+                        
+                        if 'generated_examples_csv' not in st.session_state:
+                            st.session_state.generated_examples_csv = None
+                        
+                        if 'generated_examples_json' not in st.session_state:
+                            st.session_state.generated_examples_json = None
+                    
+
+                      
+                    
+                        # Save labeled examples to CSV
+                        #new 14/4/2025
+                        #labeled_examples = []
+                        # if classification_type == "Named Entity Recognition (NER)":
+                        #     labeled_examples = []
+                        #     for line in response.split('\n'):
+                        #         if line.strip():
+                        #             parts = line.rsplit('Entities:', 1)
+                        #             if len(parts) == 2:
+                        #                 text = parts[0].strip()
+                        #                 entities = parts[1].strip()
+                        #                 if text and entities:
+                        #                     labeled_examples.append({
+                        #                         'text': text,
+                        #                         'entities': entities,
+                        #                         'system_prompt': st.session_state.system_prompt,
+                        #                         'system_role': st.session_state.system_role,
+                        #                         'task_type': 'Named Entity Recognition (NER)',
+                        #                         'Use few-shot example?': 'Yes' if use_few_shot else 'No',
+                        #                     })
+
+                                            #new 22/4/2025
+                        labeled_examples = []
+                        if classification_type == "Named Entity Recognition (NER)":
+                            labeled_examples = [{
+                                'ner_output': response.strip(),
+                                'system_prompt': st.session_state.system_prompt,
+                                'system_role': st.session_state.system_role,
+                                'task_type': 'Named Entity Recognition (NER)',
+                                'Use few-shot example?': 'Yes' if use_few_shot else 'No',
+                            }]
+
+                                            ######
+                       
+                                            
+                        else:
+                            labeled_examples = []
+                            for line in response.split('\n'):
+                                if line.strip():
+                                    parts = line.rsplit('Label:', 1)
+                                    if len(parts) == 2:
+                                        text = parts[0].strip()
+                                        label = parts[1].strip()
+                                        if text and label:
+                                            labeled_examples.append({
+                                                'text': text,
+                                                'label': label,
+                                                'system_prompt': st.session_state.system_prompt,
+                                                'system_role': st.session_state.system_role,
+                                                'task_type': 'Data Labeling',
+                                                'Use few-shot example?': 'Yes' if use_few_shot else 'No',  
+                                            })
+                       # Save and provide download options
+                        if labeled_examples:
+                            # Update session state
+                            st.session_state.labeled_examples = labeled_examples
+                        
+                            # Convert to CSV and JSON
+                            df = pd.DataFrame(labeled_examples)
+                            #new 22/4/2025
+                            # CSV
+                            st.session_state.labeled_examples_csv = df.to_csv(index=False).encode('utf-8')
+                            
+                            # JSON
+                            st.session_state.labeled_examples_json = json.dumps({
+                                "metadata": {
+                                    "domain": domain,
+                                    "labels": labels,
+                                    "used_few_shot": use_few_shot,
+                                    "task_type": "Named Entity Recognition (NER)",
+                                    "timestamp": datetime.now().isoformat()
+                                },
+                                "examples": labeled_examples
+                            }, indent=2).encode('utf-8')
+
+                            ############
+                            # CSV
+                            # st.session_state.labeled_examples_csv = df.to_csv(index=False).encode('utf-8')
+                            
+                            # # JSON
+                            # st.session_state.labeled_examples_json = json.dumps({
+                            #     "metadata": {
+                            #         "domain": domain,
+                            #         "labels": labels,
+                            #         "used_few_shot": use_few_shot,
+                            #         "task_type": "Named Entity Recognition (NER)",
+                            #         "timestamp": datetime.now().isoformat()
+                            #     },
+                            #     "examples": labeled_examples
+                            # }, indent=2).encode('utf-8')
+                            
+                                                        ########
+                            # st.session_state.labeled_examples_csv = df.to_csv(index=False).encode('utf-8')
+                            # st.session_state.labeled_examples_json = json.dumps(labeled_examples, indent=2).encode('utf-8')
+                        
+                            # Download buttons
+                            st.download_button(
+                                "📥 Download Labeled Examples (CSV)",
+                                st.session_state.labeled_examples_csv,
+                                "labeled_examples.csv",
+                                "text/csv",
+                                key='download-labeled-csv'
+                            )
+                        
+                            st.markdown("""
+                            <div style='text-align: left; margin:15px 0; font-weight: 600; color: #666;'>. . . . . .         or</div>
+                            """, unsafe_allow_html=True)
+                        
+                            st.download_button(
+                                "📥 Download Labeled Examples (JSON)",
+                                st.session_state.labeled_examples_json,
+                                "labeled_examples.json",
+                                "application/json",
+                                key='download-labeled-json'
+                            )
+                            # Display the labeled examples
+                            st.markdown("##### 📋 Labeled Examples Preview")
+                            st.dataframe(df, use_container_width=True)
+                            # Display section
+                            #st.markdown("### 📋 Labeled Examples Preview")
+                            #st.dataframe(st.session_state.labeled_preview, use_container_width=True)
+
+                                                                            
+                                                                        
+                        # if labeled_examples:
+                        #     df = pd.DataFrame(labeled_examples)
+                        #     csv = df.to_csv(index=False).encode('utf-8')
+                        #     st.download_button(
+                        #         "📥 Download Labeled Examples",
+                        #         csv,
+                        #         "labeled_examples.csv",
+                        #         "text/csv",
+                        #         key='download-labeled-csv'
+                        #     )
+                        # # Add space and center the "or"
+                        # st.markdown("""
+                        # <div style='text-align: left; margin:15px 0; font-weight: 600; color: #666;'>. . . . . .         or</div>
+                        # """, unsafe_allow_html=True)
+                        
+                        # if labeled_examples:
+                        #     df = pd.DataFrame(labeled_examples)
+                        #     csv = df.to_csv(index=False).encode('utf-8')
+                        #     st.download_button(
+                        #         "📥 Download Labeled Examples",
+                        #         csv,
+                        #         "labeled_examples.json",
+                        #         "text/json",
+                        #         key='download-labeled-JSON'
+                        #     )
+                            
+                        # Add follow-up interaction options
+                        #st.markdown("---")
+                        #follow_up = st.radio(
+                            #"What would you like to do next?",
+                             #["Label more data", "Data Generation"],
+                           # key="labeling_follow_up"
+                      #  )
+                    
+                        if st.button("Continue"):
+                            if follow_up == "Label more data":
+                                st.session_state.examples_to_classify = []
+                                st.experimental_rerun()
+                            elif follow_up == "Data Generation":
+                                st.session_state.task_choice = "Data Labeling"
+                                st.experimental_rerun()
+                            
+                    except Exception as e:
+                        st.error("An error occurred during labeling.")
+                        st.error(f"Details: {e}")
+            else:
+                st.warning("Please enter at least one example to classify.")
+
+    #st.session_state.messages.append({"role": "assistant", "content": response})
+       
+        
+                   
+
+# Footer
+st.markdown("---")
+st.markdown(
+    """
+    <div style='text-align: center'>
+        <p>Made with ❤️ by Wedyan AlSakran 2025</p>
+    </div>
+    """, 
+    unsafe_allow_html=True
+)