| import csv |
| import json |
| import os |
| import re |
| import time |
| import xml.etree.ElementTree as ET |
| from urllib.parse import parse_qs, urlparse |
|
|
| from bs4 import BeautifulSoup |
| import docx |
| import gradio as gr |
| from langchain_community.vectorstores import FAISS |
| from langchain_core.messages import AIMessage, HumanMessage, SystemMessage |
| from langchain_huggingface import ( |
| ChatHuggingFace, |
| HuggingFaceEmbeddings, |
| HuggingFaceEndpoint, |
| ) |
| import nltk |
| from nltk.tokenize import word_tokenize |
| import openpyxl |
| import pptx |
| import PyPDF2 |
| import requests |
| from youtube_transcript_api import YouTubeTranscriptApi |
| from youtube_transcript_api._errors import ( |
| NoTranscriptFound, |
| TranscriptsDisabled, |
| VideoUnavailable, |
| ) |
|
|
| nltk.download("punkt") |
| nltk.download("punkt_tab") |
| nltk.download("omw-1.4") |
| nltk.download("wordnet") |
|
|
|
|
| def read_csv(file_path): |
| with open( |
| file_path, |
| "r", |
| encoding="utf-8", |
| errors="ignore", |
| newline="" |
| ) as csvfile: |
| csv_reader = csv.reader(csvfile) |
| csv_data = [row for row in csv_reader] |
|
|
| return " ".join( |
| [" ".join(row) for row in csv_data] |
| ) |
|
|
|
|
| def read_text(file_path): |
| with open( |
| file_path, |
| "r", |
| encoding="utf-8", |
| errors="ignore" |
| ) as f: |
| return f.read() |
|
|
|
|
| def read_pdf(file_path): |
| text_data = [] |
|
|
| with open(file_path, "rb") as pdf_file: |
| pdf_reader = PyPDF2.PdfReader(pdf_file) |
|
|
| for page in pdf_reader.pages: |
| page_text = page.extract_text() |
|
|
| if page_text: |
| text_data.append(page_text) |
|
|
| return "\n".join(text_data) |
|
|
|
|
| def read_docx(file_path): |
| doc = docx.Document(file_path) |
|
|
| return "\n".join( |
| paragraph.text |
| for paragraph in doc.paragraphs |
| ) |
|
|
|
|
| def read_pptx(file_path): |
| ppt = pptx.Presentation(file_path) |
| text_data = "" |
|
|
| for slide in ppt.slides: |
| for shape in slide.shapes: |
| if hasattr(shape, "text"): |
| text_data += shape.text + "\n" |
|
|
| return text_data |
|
|
|
|
| def read_xlsx(file_path): |
| workbook = openpyxl.load_workbook(file_path) |
| sheet = workbook.active |
| text_data = "" |
|
|
| for row in sheet.iter_rows(values_only=True): |
| text_data += ( |
| " ".join( |
| str(cell) |
| for cell in row |
| if cell is not None |
| ) |
| + "\n" |
| ) |
|
|
| return text_data |
|
|
|
|
| def read_json(file_path): |
| with open( |
| file_path, |
| "r", |
| encoding="utf-8" |
| ) as f: |
| json_data = json.load(f) |
|
|
| return json.dumps( |
| json_data, |
| ensure_ascii=False |
| ) |
|
|
|
|
| def read_html(file_path): |
| with open( |
| file_path, |
| "r", |
| encoding="utf-8", |
| errors="ignore" |
| ) as f: |
| html_content = f.read() |
|
|
| soup = BeautifulSoup( |
| html_content, |
| "html.parser" |
| ) |
|
|
| return soup.get_text( |
| separator="\n" |
| ) |
|
|
|
|
| def read_xml(file_path): |
| tree = ET.parse(file_path) |
| root = tree.getroot() |
|
|
| return ET.tostring( |
| root, |
| encoding="unicode" |
| ) |
|
|
|
|
| def extract_youtube_video_id(url): |
| if not url: |
| return None |
|
|
| url = str(url).strip() |
|
|
| url = url.replace("\\", "") |
| url = url.replace("\n", "") |
| url = url.replace("\\n", "") |
|
|
| markdown_match = re.search( |
| r"\]\(\s*(https?://[^)\s]+)", |
| url, |
| flags=re.IGNORECASE |
| ) |
|
|
| if markdown_match: |
| url = markdown_match.group(1) |
|
|
| url_match = re.search( |
| r"https?://(?:www\.)?(?:youtube\.com|youtu\.be)[^\s<>\"']+", |
| url, |
| flags=re.IGNORECASE |
| ) |
|
|
| if url_match: |
| url = url_match.group(0) |
|
|
| url = url.rstrip( |
| ".,!?;:)]}" |
| ) |
|
|
| parsed = urlparse(url) |
|
|
| hostname = ( |
| parsed.hostname or "" |
| ).lower() |
|
|
| if hostname in ( |
| "youtu.be", |
| "www.youtu.be" |
| ): |
| video_id = ( |
| parsed.path |
| .lstrip("/") |
| .split("/")[0] |
| ) |
|
|
| return ( |
| video_id |
| .replace("\\", "") |
| .strip() |
| or None |
| ) |
|
|
| if hostname in ( |
| "youtube.com", |
| "www.youtube.com", |
| "m.youtube.com" |
| ): |
|
|
| if parsed.path == "/watch": |
|
|
| video_ids = parse_qs( |
| parsed.query |
| ).get("v") |
|
|
| if video_ids: |
|
|
| video_id = ( |
| video_ids[0] |
| .replace("\\", "") |
| .strip() |
| ) |
|
|
| return video_id or None |
|
|
| for prefix in ( |
| "/shorts/", |
| "/embed/", |
| "/live/" |
| ): |
|
|
| if parsed.path.startswith(prefix): |
|
|
| video_id = ( |
| parsed.path[ |
| len(prefix): |
| ] |
| .split("/")[0] |
| .replace("\\", "") |
| .strip() |
| ) |
|
|
| return video_id or None |
|
|
| return None |
|
|
|
|
| def is_youtube_url(url): |
| return ( |
| extract_youtube_video_id(url) |
| is not None |
| ) |
|
|
|
|
| def fetch_transcript_text(video_id): |
| video_id = ( |
| str(video_id) |
| .replace("\\", "") |
| .strip() |
| ) |
|
|
| print( |
| "CLEAN YOUTUBE VIDEO ID:", |
| repr(video_id) |
| ) |
|
|
| try: |
|
|
| print( |
| "FETCHING YOUTUBE TRANSCRIPT:", |
| repr(video_id) |
| ) |
|
|
| api = YouTubeTranscriptApi() |
|
|
| transcript_list = api.list( |
| video_id |
| ) |
|
|
| transcript = None |
|
|
| try: |
|
|
| transcript = ( |
| transcript_list.find_transcript( |
| ["en"] |
| ) |
| ) |
|
|
| except Exception: |
|
|
| try: |
|
|
| transcript = ( |
| transcript_list.find_transcript( |
| ["ar"] |
| ) |
| ) |
|
|
| except Exception: |
|
|
| for item in transcript_list: |
|
|
| transcript = item |
| break |
|
|
| if transcript is None: |
|
|
| raise NoTranscriptFound( |
| video_id, |
| ["en", "ar"], |
| transcript_list |
| ) |
|
|
| fetched = transcript.fetch() |
|
|
| if hasattr( |
| fetched, |
| "snippets" |
| ): |
|
|
| text = " ".join( |
| snippet.text |
| for snippet in fetched.snippets |
| ) |
|
|
| else: |
|
|
| text = " ".join( |
| snippet.text |
| for snippet in fetched |
| ) |
|
|
| text = text.strip() |
|
|
| if not text: |
|
|
| raise RuntimeError( |
| "Transcript was retrieved " |
| "but contains no text." |
| ) |
|
|
| print( |
| "YOUTUBE TRANSCRIPT SUCCESS:", |
| len(text), |
| "characters" |
| ) |
|
|
| return text |
|
|
| except ( |
| NoTranscriptFound, |
| TranscriptsDisabled, |
| VideoUnavailable |
| ): |
|
|
| raise |
|
|
| except Exception as e: |
|
|
| print( |
| "YOUTUBE API ERROR:", |
| repr(e) |
| ) |
|
|
| raise |
|
|
|
|
| def process_youtube_video(url): |
| video_id = extract_youtube_video_id( |
| url |
| ) |
|
|
| if not video_id: |
|
|
| return ( |
| "Invalid YouTube video URL. " |
| "Please provide a valid YouTube " |
| "video link." |
| ) |
|
|
| print( |
| "YOUTUBE VIDEO ID:", |
| repr(video_id) |
| ) |
|
|
| try: |
|
|
| transcript = fetch_transcript_text( |
| video_id |
| ) |
|
|
| if transcript: |
| return transcript |
|
|
| return ( |
| "The YouTube transcript was retrieved " |
| "but contains no readable text." |
| ) |
|
|
| except NoTranscriptFound: |
|
|
| return ( |
| "No English or Arabic transcript " |
| "was found for this YouTube video." |
| ) |
|
|
| except TranscriptsDisabled: |
|
|
| return ( |
| "Transcripts are disabled for this " |
| "YouTube video." |
| ) |
|
|
| except VideoUnavailable: |
|
|
| return ( |
| "The YouTube video is unavailable." |
| ) |
|
|
| except Exception as e: |
|
|
| print( |
| "YOUTUBE TRANSCRIPT ERROR:", |
| repr(e) |
| ) |
|
|
| return ( |
| "Unable to retrieve the YouTube " |
| "transcript.\n\n" |
| f"Error: {str(e)}" |
| ) |
|
|
|
|
| def read_web_page(url): |
| try: |
|
|
| url = str(url).strip() |
|
|
| response = requests.get( |
| url, |
| headers={ |
| "User-Agent": ( |
| "Mozilla/5.0 " |
| "(Windows NT 10.0; Win64; x64) " |
| "AppleWebKit/537.36 " |
| "(KHTML, like Gecko) " |
| "Chrome/151.0.0.0 " |
| "Safari/537.36" |
| ) |
| }, |
| timeout=20, |
| allow_redirects=True |
| ) |
|
|
| if response.status_code >= 400: |
|
|
| return ( |
| "Unable to access webpage. " |
| f"HTTP status: {response.status_code}" |
| ) |
|
|
| content_type = ( |
| response.headers |
| .get("content-type", "") |
| .lower() |
| ) |
|
|
| if "text/plain" in content_type: |
| return response.text |
|
|
| soup = BeautifulSoup( |
| response.text, |
| "html.parser" |
| ) |
|
|
| for element in soup([ |
| "script", |
| "style", |
| "noscript", |
| "svg" |
| ]): |
|
|
| element.decompose() |
|
|
| text_data = soup.get_text( |
| separator="\n" |
| ) |
|
|
| text_data = "\n".join( |
| line.strip() |
| for line in text_data.splitlines() |
| if line.strip() |
| ) |
|
|
| if not text_data: |
|
|
| return ( |
| "The webpage was accessed successfully " |
| "but contains no readable text." |
| ) |
|
|
| return text_data |
|
|
| except requests.exceptions.Timeout: |
|
|
| return ( |
| "The webpage request timed out. " |
| "Please try another link." |
| ) |
|
|
| except requests.exceptions.RequestException as e: |
|
|
| return ( |
| f"Unable to access webpage: {e}" |
| ) |
|
|
| except Exception as e: |
|
|
| return ( |
| "An error occurred while reading " |
| f"the webpage: {e}" |
| ) |
|
|
|
|
| def read_data( |
| file_path_or_url, |
| languages=["en", "ar"] |
| ): |
|
|
| if not file_path_or_url: |
| return "Unsupported type or format." |
|
|
| file_path_or_url = str( |
| file_path_or_url |
| ).strip() |
|
|
| if is_youtube_url( |
| file_path_or_url |
| ): |
|
|
| return process_youtube_video( |
| file_path_or_url |
| ) |
|
|
| if file_path_or_url.startswith( |
| ("http://", "https://") |
| ): |
|
|
| return read_web_page( |
| file_path_or_url |
| ) |
|
|
| lower_path = ( |
| file_path_or_url.lower() |
| ) |
|
|
| if lower_path.endswith(".csv"): |
|
|
| return read_csv( |
| file_path_or_url |
| ) |
|
|
| elif lower_path.endswith(".txt"): |
|
|
| return read_text( |
| file_path_or_url |
| ) |
|
|
| elif lower_path.endswith(".pdf"): |
|
|
| return read_pdf( |
| file_path_or_url |
| ) |
|
|
| elif lower_path.endswith(".docx"): |
|
|
| return read_docx( |
| file_path_or_url |
| ) |
|
|
| elif lower_path.endswith(".pptx"): |
|
|
| return read_pptx( |
| file_path_or_url |
| ) |
|
|
| elif lower_path.endswith(".xlsx"): |
|
|
| return read_xlsx( |
| file_path_or_url |
| ) |
|
|
| elif lower_path.endswith(".json"): |
|
|
| return read_json( |
| file_path_or_url |
| ) |
|
|
| elif lower_path.endswith(".html"): |
|
|
| return read_html( |
| file_path_or_url |
| ) |
|
|
| elif lower_path.endswith(".xml"): |
|
|
| return read_xml( |
| file_path_or_url |
| ) |
|
|
| return "Unsupported type or format." |
|
|
|
|
| def normalize_text(text): |
|
|
| if not isinstance( |
| text, |
| str |
| ): |
| text = str(text) |
|
|
| text = re.sub( |
| r"\\n", |
| " ", |
| text |
| ) |
|
|
| text = re.sub( |
| r"\\", |
| "", |
| text |
| ) |
|
|
| text = text.lower() |
| text = text.strip() |
|
|
| punctuation = ( |
| r"""!()[]{};:'"\<>/?$%^&*_`~=""" |
| ) |
|
|
| for punc in punctuation: |
|
|
| text = text.replace( |
| punc, |
| "" |
| ) |
|
|
| text = re.sub( |
| r"[A-Za-z0-9]*@[A-Za-z]*\.?[A-Za-z0-9]*", |
| "", |
| text |
| ) |
|
|
| words = word_tokenize( |
| text |
| ) |
|
|
| return " ".join(words) |
|
|
|
|
| llm = HuggingFaceEndpoint( |
| repo_id="Qwen/Qwen2.5-Coder-32B-Instruct", |
| task="text-generation", |
| max_new_tokens=4096, |
| temperature=0.6, |
| top_p=0.9, |
| top_k=40, |
| repetition_penalty=1.2, |
| do_sample=True, |
| ) |
|
|
| chat_model = ChatHuggingFace( |
| llm=llm |
| ) |
|
|
| model_name = ( |
| "sentence-transformers/all-mpnet-base-v2" |
| ) |
|
|
| embedding_llm = HuggingFaceEmbeddings( |
| model_name=model_name |
| ) |
|
|
| db = FAISS.load_local( |
| "faiss_index", |
| embedding_llm, |
| allow_dangerous_deserialization=True |
| ) |
|
|
|
|
| def print_like_dislike( |
| x: gr.LikeData |
| ): |
|
|
| print( |
| x.index, |
| x.value, |
| x.liked |
| ) |
|
|
|
|
| def user( |
| user_message, |
| history |
| ): |
|
|
| if not len(user_message): |
|
|
| raise gr.Error( |
| "Chat messages cannot be empty" |
| ) |
|
|
| history.append({ |
| "role": "user", |
| "content": user_message |
| }) |
|
|
| return "", history |
|
|
|
|
| def user2( |
| user_message, |
| history, |
| link |
| ): |
|
|
| if ( |
| not len(user_message) |
| or not len(link) |
| ): |
|
|
| raise gr.Error( |
| "Chat messages or links cannot be empty" |
| ) |
|
|
| link = str(link).strip() |
|
|
| user_message = str( |
| user_message |
| ).strip() |
|
|
| combined_message = ( |
| f"URL: {link}\n" |
| f"QUESTION: {user_message}" |
| ) |
|
|
| history.append({ |
| "role": "user", |
| "content": combined_message |
| }) |
|
|
| return "", history, link |
|
|
|
|
| def user3( |
| user_message, |
| history, |
| file_path |
| ): |
|
|
| if ( |
| not len(user_message) |
| or not file_path |
| ): |
|
|
| raise gr.Error( |
| "Chat messages or files cannot be empty" |
| ) |
|
|
| combined_message = ( |
| f"{file_path}\n" |
| f"{user_message}" |
| ) |
|
|
| history.append({ |
| "role": "user", |
| "content": combined_message |
| }) |
|
|
| return "", history, file_path |
|
|
|
|
| messages1_state = [ |
| SystemMessage( |
| content="You are a helpful assistant." |
| ), |
| HumanMessage( |
| content="Hi AI, how are you today?" |
| ), |
| AIMessage( |
| content=( |
| "I'm great thank you. " |
| "How can I help you?" |
| ) |
| ), |
| ] |
|
|
|
|
| def Chat_Message( |
| history, |
| messages1 |
| ): |
|
|
| user_msg_text = ( |
| history[-1]["content"] |
| ) |
|
|
| message = HumanMessage( |
| content=user_msg_text |
| ) |
|
|
| if isinstance( |
| messages1[-1], |
| HumanMessage |
| ): |
|
|
| messages1 = messages1[:-2] |
|
|
| messages1.append( |
| message |
| ) |
|
|
| if len(messages1) >= 8: |
|
|
| messages1 = messages1[-8:] |
|
|
| try: |
|
|
| response = chat_model.invoke( |
| messages1 |
| ) |
|
|
| except Exception as e: |
|
|
| error_message = str(e) |
|
|
| print( |
| "CHAT ERROR:", |
| repr(e) |
| ) |
|
|
| raise gr.Error( |
| "Error occurred during response" |
| ) from e |
|
|
| messages1.append( |
| AIMessage( |
| content=response.content |
| ) |
| ) |
|
|
| history.append({ |
| "role": "assistant", |
| "content": "" |
| }) |
|
|
| for character in response.content: |
|
|
| history[-1]["content"] += character |
|
|
| time.sleep( |
| 0.0025 |
| ) |
|
|
| yield history, messages1 |
|
|
|
|
| def Internet_Search( |
| history, |
| messages2 |
| ): |
|
|
| message = str( |
| history[-1]["content"] |
| ) |
|
|
| if isinstance( |
| messages2[-1], |
| HumanMessage |
| ): |
|
|
| messages2 = messages2[:-2] |
|
|
| similar_docs = db.similarity_search( |
| message, |
| k=3 |
| ) |
|
|
| if similar_docs: |
|
|
| source_knowledge = "\n".join( |
| [ |
| x.page_content |
| for x in similar_docs |
| ] |
| ) |
|
|
| else: |
|
|
| source_knowledge = "" |
|
|
| augmented_prompt = f""" |
| You are an AI designed to help understand |
| and extract information from provided Search Content. |
| |
| Based on the user's Query, you may need to summarize |
| the text, answer specific questions, or provide guidance. |
| |
| Query: |
| {message} |
| |
| Search Content: |
| {source_knowledge} |
| |
| If the query is not related to specific Search Content, |
| engage in general conversation or provide relevant |
| information from other sources. |
| """ |
|
|
| msg = HumanMessage( |
| content=augmented_prompt |
| ) |
|
|
| messages2.append( |
| msg |
| ) |
|
|
| if len(messages2) >= 4: |
|
|
| messages2 = messages2[-4:] |
|
|
| try: |
|
|
| response = chat_model.invoke( |
| messages2 |
| ) |
|
|
| except Exception as e: |
|
|
| print( |
| "INTERNET SEARCH ERROR:", |
| repr(e) |
| ) |
|
|
| raise gr.Error( |
| "Error occurred during response" |
| ) from e |
|
|
| messages2.append( |
| AIMessage( |
| content=response.content |
| ) |
| ) |
|
|
| history.append({ |
| "role": "assistant", |
| "content": "" |
| }) |
|
|
| for character in response.content: |
|
|
| history[-1]["content"] += character |
|
|
| time.sleep( |
| 0.0025 |
| ) |
|
|
| yield history, messages2 |
|
|
|
|
| def generate_chart_config( |
| description |
| ): |
|
|
| system_instructions = """ |
| You are a Chart.js configuration generator. |
| |
| Return ONLY valid JSON. |
| |
| The JSON must have this structure: |
| |
| { |
| "type": "bar", |
| "data": { |
| "labels": [], |
| "datasets": [ |
| { |
| "label": "", |
| "data": [] |
| } |
| ] |
| }, |
| "options": {} |
| } |
| |
| Rules: |
| |
| - Output JSON only. |
| - No markdown. |
| - No code fences. |
| - No explanation. |
| - Use valid JSON double quotes. |
| - Do not use trailing commas. |
| - The top-level object must contain "type". |
| - The top-level object must contain "data". |
| - "data" must contain "labels". |
| - "data" must contain "datasets". |
| - The chart must be valid for Chart.js. |
| """ |
|
|
| prompt = [ |
| SystemMessage( |
| content=system_instructions |
| ), |
| HumanMessage( |
| content=( |
| "Create a Chart.js chart for " |
| "this request:\n" |
| f"{description}" |
| ) |
| ), |
| ] |
|
|
| print( |
| "CHART DESCRIPTION:", |
| description |
| ) |
|
|
| response = chat_model.invoke( |
| prompt |
| ) |
|
|
| raw = str( |
| response.content |
| ).strip() |
|
|
| print( |
| "RAW CHART MODEL RESPONSE:", |
| raw |
| ) |
|
|
| raw = re.sub( |
| r"^```json\s*", |
| "", |
| raw, |
| flags=re.IGNORECASE |
| ) |
|
|
| raw = re.sub( |
| r"^```\s*", |
| "", |
| raw |
| ) |
|
|
| raw = re.sub( |
| r"\s*```$", |
| "", |
| raw |
| ) |
|
|
| raw = raw.strip() |
|
|
| start = raw.find("{") |
| end = raw.rfind("}") |
|
|
| if ( |
| start == -1 |
| or end == -1 |
| ): |
|
|
| raise ValueError( |
| "Model did not return a JSON object.\n" |
| f"Raw response:\n{raw}" |
| ) |
|
|
| raw = raw[ |
| start:end + 1 |
| ] |
|
|
| config = json.loads( |
| raw |
| ) |
|
|
| if "type" not in config: |
|
|
| raise ValueError( |
| "Chart config missing 'type'" |
| ) |
|
|
| if "data" not in config: |
|
|
| raise ValueError( |
| "Chart config missing 'data'" |
| ) |
|
|
| if "labels" not in config["data"]: |
|
|
| raise ValueError( |
| "Chart config missing 'data.labels'" |
| ) |
|
|
| if "datasets" not in config["data"]: |
|
|
| raise ValueError( |
| "Chart config missing 'data.datasets'" |
| ) |
|
|
| if not isinstance( |
| config["data"]["datasets"], |
| list |
| ): |
|
|
| raise ValueError( |
| "'data.datasets' must be a list" |
| ) |
|
|
| return config |
|
|
|
|
| def Chart_Generator( |
| history, |
| messages3 |
| ): |
|
|
| message = str( |
| history[-1]["content"] |
| ) |
|
|
| if isinstance( |
| messages3[-1], |
| HumanMessage |
| ): |
|
|
| messages3 = messages3[:-2] |
|
|
| if "#chart" in message.lower(): |
|
|
| chart_description = re.split( |
| r"#chart", |
| message, |
| maxsplit=1, |
| flags=re.IGNORECASE |
| )[1].strip() |
|
|
| if not chart_description: |
|
|
| combined_content = ( |
| "Please provide chart details " |
| "after #chart." |
| ) |
|
|
| else: |
|
|
| chart_config = None |
|
|
| try: |
|
|
| chart_config = ( |
| generate_chart_config( |
| chart_description |
| ) |
| ) |
|
|
| except Exception as e: |
|
|
| print( |
| "CHART GENERATION ERROR:", |
| repr(e) |
| ) |
|
|
| combined_content = ( |
| "Chart generation failed.\n\n" |
| f"Error: {str(e)}" |
| ) |
|
|
| if chart_config: |
|
|
| try: |
|
|
| config_json = json.dumps( |
| chart_config, |
| separators=(",", ":") |
| ) |
|
|
| encoded_config = ( |
| requests.utils.quote( |
| config_json, |
| safe="" |
| ) |
| ) |
|
|
| chart_url = ( |
| "https://quickchart.io/chart" |
| f"?c={encoded_config}" |
| "&bkg=white" |
| ) |
|
|
| chart_response = requests.get( |
| chart_url, |
| timeout=30 |
| ) |
|
|
| if ( |
| chart_response.status_code |
| != 200 |
| ): |
|
|
| combined_content = ( |
| "QuickChart failed to " |
| "generate the chart.\n\n" |
| f"HTTP Status: " |
| f"{chart_response.status_code}" |
| ) |
|
|
| else: |
|
|
| image_html = ( |
| f'<img src="{chart_url}" ' |
| 'alt="Generated Chart" ' |
| 'style="display:block; ' |
| 'margin:auto; ' |
| 'max-width:100%; ' |
| 'max-height:100%;">' |
| ) |
|
|
| chart_summary_prompt = ( |
| "The following Chart.js " |
| "configuration was generated:\n\n" |
| f"{json.dumps(chart_config, indent=2)}\n\n" |
| "Briefly describe what this chart " |
| "represents." |
| ) |
|
|
| analysis_messages = [ |
| SystemMessage( |
| content=( |
| "You are analyzing chart " |
| "configuration data, not " |
| "an image. Be concise." |
| ) |
| ), |
| HumanMessage( |
| content=chart_summary_prompt |
| ), |
| ] |
|
|
| try: |
|
|
| response = ( |
| chat_model.invoke( |
| analysis_messages |
| ) |
| ) |
|
|
| analysis_text = ( |
| response.content |
| ) |
|
|
| except Exception: |
|
|
| analysis_text = ( |
| "Chart generated successfully." |
| ) |
|
|
| combined_content = ( |
| f"{image_html}" |
| f"<br>{analysis_text}" |
| ) |
|
|
| messages3.append( |
| HumanMessage( |
| content=( |
| "The user requested this chart:\n" |
| f"{chart_description}" |
| ) |
| ) |
| ) |
|
|
| messages3.append( |
| AIMessage( |
| content=( |
| "A chart was generated with " |
| "the following Chart.js configuration:\n\n" |
| f"{json.dumps(chart_config, indent=2)}\n\n" |
| "Chart URL:\n" |
| f"{chart_url}" |
| ) |
| ) |
| ) |
|
|
| messages3 = messages3[-6:] |
|
|
| except Exception as e: |
|
|
| combined_content = ( |
| "Chart configuration was generated, " |
| "but QuickChart could not be reached.\n\n" |
| f"Error: {str(e)}" |
| ) |
|
|
| else: |
|
|
| prompt = HumanMessage( |
| content=message |
| ) |
|
|
| messages3.append( |
| prompt |
| ) |
|
|
| if len(messages3) >= 6: |
|
|
| messages3 = messages3[-6:] |
|
|
| try: |
|
|
| response = chat_model.invoke( |
| messages3 |
| ) |
|
|
| except Exception as e: |
|
|
| print( |
| "CHART TAB CHAT ERROR:", |
| repr(e) |
| ) |
|
|
| raise gr.Error( |
| "Error occurred during response" |
| ) from e |
|
|
| messages3.append( |
| AIMessage( |
| content=response.content |
| ) |
| ) |
|
|
| combined_content = ( |
| response.content |
| ) |
|
|
| history.append({ |
| "role": "assistant", |
| "content": "" |
| }) |
|
|
| for character in combined_content: |
|
|
| history[-1]["content"] += character |
|
|
| time.sleep( |
| 0.0025 |
| ) |
|
|
| yield history, messages3 |
|
|
|
|
| def extract_url_from_text(text): |
|
|
| if not text: |
| return None |
|
|
| if isinstance( |
| text, |
| list |
| ): |
|
|
| parts = [] |
|
|
| for item in text: |
|
|
| if isinstance( |
| item, |
| dict |
| ): |
|
|
| parts.append( |
| str( |
| item.get( |
| "text", |
| "" |
| ) |
| ) |
| ) |
|
|
| else: |
|
|
| parts.append( |
| str(item) |
| ) |
|
|
| text = " ".join(parts) |
|
|
| elif isinstance( |
| text, |
| dict |
| ): |
|
|
| text = str( |
| text.get( |
| "text", |
| "" |
| ) |
| ) |
|
|
| else: |
|
|
| text = str(text) |
|
|
| text = text.replace( |
| "\\n", |
| " " |
| ) |
|
|
| text = text.replace( |
| "\\", |
| "" |
| ) |
|
|
| markdown_matches = re.findall( |
| r"\]\(\s*(https?://[^)\s]+)", |
| text, |
| flags=re.IGNORECASE |
| ) |
|
|
| if markdown_matches: |
|
|
| return markdown_matches[0].rstrip( |
| ".,!?;:)]}" |
| ) |
|
|
| url_matches = re.findall( |
| r"https?://[^\s<>\"']+", |
| text, |
| flags=re.IGNORECASE |
| ) |
|
|
| if url_matches: |
|
|
| return url_matches[0].rstrip( |
| ".,!?;:)]}" |
| ) |
|
|
| return None |
|
|
|
|
| def extract_user_query_from_link_message( |
| content, |
| link |
| ): |
|
|
| if isinstance( |
| content, |
| list |
| ): |
|
|
| parts = [] |
|
|
| for item in content: |
|
|
| if isinstance( |
| item, |
| dict |
| ): |
|
|
| parts.append( |
| str( |
| item.get( |
| "text", |
| "" |
| ) |
| ) |
| ) |
|
|
| else: |
|
|
| parts.append( |
| str(item) |
| ) |
|
|
| content = " ".join(parts) |
|
|
| elif isinstance( |
| content, |
| dict |
| ): |
|
|
| content = str( |
| content.get( |
| "text", |
| "" |
| ) |
| ) |
|
|
| else: |
|
|
| content = str(content) |
|
|
| content = content.replace( |
| "\\n", |
| "\n" |
| ) |
|
|
| content = content.replace( |
| "\\", |
| "" |
| ) |
|
|
| content = content.strip() |
|
|
| question_match = re.search( |
| r"QUESTION\s*:\s*(.*)$", |
| content, |
| flags=re.IGNORECASE | re.DOTALL |
| ) |
|
|
| if question_match: |
|
|
| return question_match.group( |
| 1 |
| ).strip() |
|
|
| if link: |
|
|
| question = content.replace( |
| link, |
| "" |
| ) |
|
|
| question = re.sub( |
| r"URL\s*:\s*", |
| "", |
| question, |
| flags=re.IGNORECASE |
| ) |
|
|
| return question.strip() |
|
|
| return content |
|
|
|
|
| def Link_Scratch( |
| history, |
| messages4 |
| ): |
|
|
| combined_message = ( |
| history[-1]["content"] |
| ) |
|
|
| if isinstance( |
| messages4[-1], |
| HumanMessage |
| ): |
|
|
| messages4 = messages4[:-2] |
|
|
| link = extract_url_from_text( |
| combined_message |
| ) |
|
|
| user_message = ( |
| extract_user_query_from_link_message( |
| combined_message, |
| link |
| ) |
| ) |
|
|
| print( |
| "RAW LINK REQUEST:", |
| repr(combined_message) |
| ) |
|
|
| print( |
| "LINK INPUT:", |
| repr(link) |
| ) |
|
|
| print( |
| "USER QUERY:", |
| repr(user_message) |
| ) |
|
|
| if not link: |
|
|
| response_message = ( |
| "Please provide a valid URL " |
| "starting with http:// or https://" |
| ) |
|
|
| else: |
|
|
| result = read_data( |
| link |
| ) |
|
|
| print( |
| "LINK READ RESULT TYPE:", |
| type(result) |
| ) |
|
|
| print( |
| "LINK READ RESULT PREVIEW:", |
| str(result)[:2000] |
| ) |
|
|
| error_results = [ |
| "Unsupported type or format.", |
| "Invalid YouTube video URL. " |
| "Please provide a valid YouTube video link.", |
| "No English or Arabic transcript " |
| "was found for this YouTube video.", |
| "Transcripts are disabled for this " |
| "YouTube video.", |
| "The YouTube video is unavailable." |
| ] |
|
|
| if ( |
| isinstance( |
| result, |
| str |
| ) |
| and ( |
| result in error_results |
| or result.startswith( |
| "Unable to access webpage" |
| ) |
| or result.startswith( |
| "An error occurred while reading" |
| ) |
| or result.startswith( |
| "Unable to retrieve the YouTube transcript" |
| ) |
| or result.startswith( |
| "No English or Arabic transcript" |
| ) |
| or result.startswith( |
| "Transcripts are disabled" |
| ) |
| or result.startswith( |
| "The YouTube video is unavailable" |
| ) |
| ) |
| ): |
|
|
| response_message = result |
|
|
| else: |
|
|
| content_data = normalize_text( |
| result |
| ) |
|
|
| if not content_data: |
|
|
| response_message = ( |
| "The provided link is empty or " |
| "does not contain any meaningful words." |
| ) |
|
|
| else: |
|
|
| augmented_prompt = f""" |
| You are an AI designed to help understand |
| and extract information from provided Link Content. |
| |
| Based on the user's Query, answer using the provided Link Content. |
| |
| Query: |
| {user_message} |
| |
| Link Content: |
| {content_data} |
| |
| Answer the user's query using the Link Content. |
| """ |
|
|
| message = HumanMessage( |
| content=augmented_prompt |
| ) |
|
|
| messages4.append( |
| message |
| ) |
|
|
| messages4 = messages4[-1:] |
|
|
| try: |
|
|
| response = chat_model.invoke( |
| messages4 |
| ) |
|
|
| except Exception as e: |
|
|
| print( |
| "LINK LLM ERROR:", |
| repr(e) |
| ) |
|
|
| raise gr.Error( |
| "Error occurred during response" |
| ) from e |
|
|
| messages4.append( |
| AIMessage( |
| content=response.content |
| ) |
| ) |
|
|
| response_message = ( |
| response.content |
| ) |
|
|
| history.append({ |
| "role": "assistant", |
| "content": "" |
| }) |
|
|
| for character in response_message: |
|
|
| history[-1]["content"] += character |
|
|
| time.sleep( |
| 0.0025 |
| ) |
|
|
| yield history, messages4 |
|
|
|
|
| def insert_line_breaks( |
| text, |
| every=8 |
| ): |
|
|
| return "\n".join( |
| text[i:i + every] |
| for i in range( |
| 0, |
| len(text), |
| every |
| ) |
| ) |
|
|
|
|
| def display_file_name( |
| file |
| ): |
|
|
| supported_extensions = [ |
| ".csv", |
| ".txt", |
| ".pdf", |
| ".docx", |
| ".pptx", |
| ".xlsx", |
| ".json", |
| ".html", |
| ".xml" |
| ] |
|
|
| file_extension = os.path.splitext( |
| file.name |
| )[1] |
|
|
| if ( |
| file_extension.lower() |
| in supported_extensions |
| ): |
|
|
| file_name = os.path.basename( |
| file.name |
| ) |
|
|
| file_name_with_breaks = ( |
| insert_line_breaks( |
| file_name |
| ) |
| ) |
|
|
| icon_url = ( |
| "https://img.icons8.com/" |
| "ios-filled/50/0000FF/file.png" |
| ) |
|
|
| return ( |
| "<div style='display:flex;" |
| "align-items:center;'>" |
| "<img " |
| f"src='{icon_url}' " |
| "alt='file-icon' " |
| "style='width:20px;" |
| "height:20px;" |
| "margin-right:5px;'>" |
| "<b style='color:blue;'>" |
| f"{file_name_with_breaks}" |
| "</b></div>" |
| ) |
|
|
| raise gr.Error( |
| "( Supported File Types Only : " |
| "PDF , CSV , TXT , DOCX , PPTX , " |
| "XLSX , JSON , HTML , XML )" |
| ) |
|
|
|
|
| def File_Interact( |
| history, |
| filepath, |
| messages5 |
| ): |
|
|
| combined_message = str( |
| history[-1]["content"] |
| ) |
|
|
| if isinstance( |
| messages5[-1], |
| HumanMessage |
| ): |
|
|
| messages5 = messages5[:-2] |
|
|
| link = "" |
| user_message = "" |
|
|
| if "\n" in combined_message: |
|
|
| link, user_message = ( |
| combined_message.split( |
| "\n", |
| 1 |
| ) |
| ) |
|
|
| user_message = ( |
| user_message.strip() |
| ) |
|
|
| result = read_data( |
| filepath |
| ) |
|
|
| if result == "Unsupported type or format.": |
|
|
| response_message = result |
|
|
| else: |
|
|
| content_data = normalize_text( |
| result |
| ) |
|
|
| if not content_data: |
|
|
| response_message = ( |
| "The file is empty or does not " |
| "contain any meaningful words." |
| ) |
|
|
| else: |
|
|
| augmented_prompt = f""" |
| You are an AI designed to help understand |
| and extract information from provided File Content. |
| |
| Based on the user's Query, you may need to summarize |
| the text, answer specific questions, or provide guidance. |
| |
| Query: |
| {user_message} |
| |
| File Content: |
| {content_data} |
| |
| If the query is not related to specific File Content, |
| engage in general conversation or provide relevant |
| information from other sources. |
| """ |
|
|
| message = HumanMessage( |
| content=augmented_prompt |
| ) |
|
|
| messages5.append( |
| message |
| ) |
|
|
| messages5 = messages5[-1:] |
|
|
| try: |
|
|
| response = chat_model.invoke( |
| messages5 |
| ) |
|
|
| except Exception as e: |
|
|
| print( |
| "FILE LLM ERROR:", |
| repr(e) |
| ) |
|
|
| raise gr.Error( |
| "Error occurred during response" |
| ) from e |
|
|
| messages5.append( |
| AIMessage( |
| content=response.content |
| ) |
| ) |
|
|
| response_message = ( |
| response.content |
| ) |
|
|
| history.append({ |
| "role": "assistant", |
| "content": "" |
| }) |
|
|
| for character in response_message: |
|
|
| history[-1]["content"] += character |
|
|
| time.sleep( |
| 0.0025 |
| ) |
|
|
| yield history, messages5 |
|
|
|
|
| def Explore_WebSite( |
| history, |
| messages6 |
| ): |
|
|
| message = history[-1]["content"] |
|
|
| if isinstance( |
| messages6[-1], |
| HumanMessage |
| ): |
|
|
| messages6 = messages6[:-2] |
|
|
| links = [ |
| "https://huggingface.co/mou3az" |
| ] |
|
|
| result = "\n".join( |
| [ |
| read_data(link) |
| for link in links |
| ] |
| ) |
|
|
| content_data = normalize_text( |
| result |
| ) |
|
|
| augmented_prompt = f""" |
| You are an AI designed to help understand |
| and extract information from provided WebSite Content. |
| |
| Based on the user's Query, you may need to summarize |
| the text, answer specific questions, or provide guidance. |
| |
| Query: |
| {message} |
| |
| WebSite Content: |
| {content_data} |
| |
| If the query is not related to specific WebSite Content, |
| engage in general conversation or provide relevant |
| information from other sources. |
| """ |
|
|
| msg = HumanMessage( |
| content=augmented_prompt |
| ) |
|
|
| messages6.append( |
| msg |
| ) |
|
|
| if len(messages6) >= 4: |
|
|
| messages6 = messages6[-4:] |
|
|
| try: |
|
|
| response = chat_model.invoke( |
| messages6 |
| ) |
|
|
| except Exception as e: |
|
|
| print( |
| "WEBSITE ERROR:", |
| repr(e) |
| ) |
|
|
| raise gr.Error( |
| "Error occurred during response" |
| ) from e |
|
|
| messages6.append( |
| AIMessage( |
| content=response.content |
| ) |
| ) |
|
|
| history.append({ |
| "role": "assistant", |
| "content": "" |
| }) |
|
|
| for character in response.content: |
|
|
| history[-1]["content"] += character |
|
|
| time.sleep( |
| 0.0025 |
| ) |
|
|
| yield history, messages6 |
|
|
|
|
| with gr.Blocks() as demo: |
|
|
| with gr.Row(): |
|
|
| gr.Markdown( |
| """ |
| <span style='font-weight: bold; |
| color: blue; |
| font-size: large;'> |
| Choose Your Mode |
| </span> |
| """ |
| ) |
|
|
| gr.Markdown( |
| """ |
| <div style='margin-left: -120px;'> |
| <span style='font-weight: bold; |
| color: blue; |
| font-size: xx-large;'> |
| IT ASSISTANT |
| </span> |
| </div> |
| """ |
| ) |
|
|
| with gr.Tab("Chat-Message"): |
|
|
| messages1 = gr.State( |
| messages1_state |
| ) |
|
|
| chatbot = gr.Chatbot( |
| elem_id="chatbot", |
| height=500, |
| placeholder=( |
| "<span style='font-weight:bold;" |
| "color:blue;" |
| "font-size:x-large;'>" |
| "Feel Free To Ask Me Anything " |
| "Or Start A Conversation On Any Topic..." |
| "</span>" |
| ) |
| ) |
|
|
| with gr.Row(): |
|
|
| msg = gr.Textbox( |
| show_label=False, |
| placeholder="Type a message...", |
| scale=10, |
| container=False |
| ) |
|
|
| submit = gr.Button( |
| "Send", |
| scale=1 |
| ) |
|
|
| clear = gr.ClearButton([ |
| msg, |
| chatbot, |
| messages1 |
| ]) |
|
|
| msg.submit( |
| user, |
| [msg, chatbot], |
| [msg, chatbot], |
| queue=True |
| ).then( |
| Chat_Message, |
| [chatbot, messages1], |
| [chatbot, messages1] |
| ) |
|
|
| submit.click( |
| user, |
| [msg, chatbot], |
| [msg, chatbot], |
| queue=True |
| ).then( |
| Chat_Message, |
| [chatbot, messages1], |
| [chatbot, messages1] |
| ) |
|
|
| chatbot.like( |
| print_like_dislike, |
| None, |
| None |
| ) |
|
|
| with gr.Tab("Internet-Search"): |
|
|
| messages2 = gr.State( |
| messages1_state |
| ) |
|
|
| chatbot = gr.Chatbot( |
| elem_id="chatbot", |
| height=500, |
| placeholder=( |
| "<span style='font-weight:bold;" |
| "color:blue;" |
| "font-size:x-large;'>" |
| "Demand What You Seek, " |
| "And I'll Search The Internet " |
| "For The Most Relevant Information..." |
| "</span>" |
| ) |
| ) |
|
|
| with gr.Row(): |
|
|
| msg = gr.Textbox( |
| show_label=False, |
| placeholder="Type a message...", |
| scale=10, |
| container=False |
| ) |
|
|
| submit = gr.Button( |
| "Send", |
| scale=1 |
| ) |
|
|
| clear = gr.ClearButton([ |
| msg, |
| chatbot, |
| messages2 |
| ]) |
|
|
| msg.submit( |
| user, |
| [msg, chatbot], |
| [msg, chatbot], |
| queue=True |
| ).then( |
| Internet_Search, |
| [chatbot, messages2], |
| [chatbot, messages2] |
| ) |
|
|
| submit.click( |
| user, |
| [msg, chatbot], |
| [msg, chatbot], |
| queue=True |
| ).then( |
| Internet_Search, |
| [chatbot, messages2], |
| [chatbot, messages2] |
| ) |
|
|
| chatbot.like( |
| print_like_dislike, |
| None, |
| None |
| ) |
|
|
| with gr.Tab("Chart-Generator"): |
|
|
| messages3 = gr.State( |
| messages1_state |
| ) |
|
|
| chatbot = gr.Chatbot( |
| elem_id="chatbot", |
| height=500, |
| placeholder=( |
| "<span style='font-weight:bold;" |
| "color:blue;" |
| "font-size:x-large;'>" |
| "Request Any Chart Or Graph " |
| "By Giving The Data Or A Description, " |
| "And I'll Create It..." |
| "</span>" |
| ) |
| ) |
|
|
| with gr.Row(): |
|
|
| msg = gr.Textbox( |
| show_label=False, |
| placeholder=( |
| "To generate a chart: " |
| "type #chart [your chart description]. " |
| "To discuss the chart: " |
| "type your message directly..." |
| ), |
| scale=10, |
| container=False |
| ) |
|
|
| submit = gr.Button( |
| "Send", |
| scale=1 |
| ) |
|
|
| clear = gr.ClearButton([ |
| msg, |
| chatbot, |
| messages3 |
| ]) |
|
|
| msg.submit( |
| user, |
| [msg, chatbot], |
| [msg, chatbot], |
| queue=True |
| ).then( |
| Chart_Generator, |
| [chatbot, messages3], |
| [chatbot, messages3] |
| ) |
|
|
| submit.click( |
| user, |
| [msg, chatbot], |
| [msg, chatbot], |
| queue=True |
| ).then( |
| Chart_Generator, |
| [chatbot, messages3], |
| [chatbot, messages3] |
| ) |
|
|
| chatbot.like( |
| print_like_dislike, |
| None, |
| None |
| ) |
|
|
| with gr.Tab("Link-Scratch"): |
|
|
| messages4 = gr.State( |
| messages1_state |
| ) |
|
|
| chatbot = gr.Chatbot( |
| elem_id="chatbot", |
| height=500, |
| placeholder=( |
| "<span style='font-weight:bold;" |
| "color:blue;" |
| "font-size:x-large;'>" |
| "Provide A Link Of Web page " |
| "Or YouTube Video And Inquire " |
| "About Its Details..." |
| "</span>" |
| ) |
| ) |
|
|
| with gr.Row(): |
|
|
| msg1 = gr.Textbox( |
| show_label=False, |
| placeholder="Paste your link...", |
| scale=4, |
| container=False |
| ) |
|
|
| msg2 = gr.Textbox( |
| show_label=False, |
| placeholder="Type a message...", |
| scale=7, |
| container=False |
| ) |
|
|
| submit = gr.Button( |
| "Send", |
| scale=1 |
| ) |
|
|
| clear = gr.ClearButton([ |
| msg2, |
| chatbot, |
| msg1, |
| messages4 |
| ]) |
|
|
| msg1.submit( |
| user2, |
| [msg2, chatbot, msg1], |
| [msg2, chatbot, msg1], |
| queue=True |
| ).then( |
| Link_Scratch, |
| [chatbot, messages4], |
| [chatbot, messages4] |
| ) |
|
|
| msg2.submit( |
| user2, |
| [msg2, chatbot, msg1], |
| [msg2, chatbot, msg1], |
| queue=True |
| ).then( |
| Link_Scratch, |
| [chatbot, messages4], |
| [chatbot, messages4] |
| ) |
|
|
| submit.click( |
| user2, |
| [msg2, chatbot, msg1], |
| [msg2, chatbot, msg1], |
| queue=True |
| ).then( |
| Link_Scratch, |
| [chatbot, messages4], |
| [chatbot, messages4] |
| ) |
|
|
| chatbot.like( |
| print_like_dislike, |
| None, |
| None |
| ) |
|
|
| with gr.Tab("File-Interact"): |
|
|
| messages5 = gr.State( |
| messages1_state |
| ) |
|
|
| chatbot = gr.Chatbot( |
| elem_id="chatbot", |
| height=500, |
| placeholder=( |
| "<span style='font-weight:bold;" |
| "color:blue;" |
| "font-size:x-large;'>" |
| "Upload A File And Explore " |
| "Questions Related To Its Content..." |
| "</span><br>" |
| "( Supported File Types Only : " |
| "PDF , CSV , TXT , DOCX , PPTX , " |
| "XLSX , JSON , HTML , XML )" |
| ) |
| ) |
|
|
| with gr.Column(): |
|
|
| with gr.Row(): |
|
|
| filepath = gr.UploadButton( |
| "Upload a file", |
| file_count="single", |
| scale=1 |
| ) |
|
|
| msg = gr.Textbox( |
| show_label=False, |
| placeholder=( |
| "Wait until the file has been " |
| "uploaded, then type a message...." |
| ), |
| scale=7, |
| container=False |
| ) |
|
|
| submit = gr.Button( |
| "Send", |
| scale=1 |
| ) |
|
|
| with gr.Row(): |
|
|
| file_output = gr.HTML( |
| "<div style='height:20px;" |
| "width:30px;'></div>" |
| ) |
|
|
| clear = gr.ClearButton( |
| [ |
| msg, |
| filepath, |
| chatbot, |
| file_output, |
| messages5 |
| ], |
| scale=6 |
| ) |
|
|
| filepath.upload( |
| display_file_name, |
| inputs=filepath, |
| outputs=file_output |
| ) |
|
|
| msg.submit( |
| user3, |
| [msg, chatbot, file_output], |
| [msg, chatbot, file_output], |
| queue=True |
| ).then( |
| File_Interact, |
| [chatbot, filepath, messages5], |
| [chatbot, messages5] |
| ) |
|
|
| submit.click( |
| user3, |
| [msg, chatbot, file_output], |
| [msg, chatbot, file_output], |
| queue=True |
| ).then( |
| File_Interact, |
| [chatbot, filepath, messages5], |
| [chatbot, messages5] |
| ) |
|
|
| chatbot.like( |
| print_like_dislike, |
| None, |
| None |
| ) |
|
|
| with gr.Tab("Explore-WebSite"): |
|
|
| messages6 = gr.State( |
| messages1_state |
| ) |
|
|
| chatbot = gr.Chatbot( |
| elem_id="chatbot", |
| height=500, |
| placeholder=( |
| "<span style='font-weight:bold;" |
| "color:blue;" |
| "font-size:x-large;'>" |
| "Explore Any Information About " |
| "Courses or Blogs In Our Web Site..." |
| "</span>" |
| ) |
| ) |
|
|
| with gr.Row(): |
|
|
| msg = gr.Textbox( |
| show_label=False, |
| placeholder="Type a message...", |
| scale=10, |
| container=False |
| ) |
|
|
| submit = gr.Button( |
| "Send", |
| scale=1 |
| ) |
|
|
| clear = gr.ClearButton([ |
| msg, |
| chatbot, |
| messages6 |
| ]) |
|
|
| msg.submit( |
| user, |
| [msg, chatbot], |
| [msg, chatbot], |
| queue=True |
| ).then( |
| Explore_WebSite, |
| [chatbot, messages6], |
| [chatbot, messages6] |
| ) |
|
|
| submit.click( |
| user, |
| [msg, chatbot], |
| [msg, chatbot], |
| queue=True |
| ).then( |
| Explore_WebSite, |
| [chatbot, messages6], |
| [chatbot, messages6] |
| ) |
|
|
| chatbot.like( |
| print_like_dislike, |
| None, |
| None |
| ) |
|
|
|
|
| demo.queue( |
| max_size=10, |
| default_concurrency_limit=4 |
| ) |
|
|
| demo.launch( |
| max_file_size="5mb", |
| max_threads=50, |
| theme=gr.themes.Soft() |
| ) |
