major commit for change to interface to gradio Blocks

.gitignore

@@ -0,0 +1,116 @@
+
+
+
+.idea/
+
+config.py
+
+.gradio
+.gradio/
+.gradio/*
+
+#
+# Project specific excludes
+#
+
+*.log
+*.key 
+*.env
+
+*.csv
+*.xlsx
+
+med_news.txt
+
+example_sergio.sh
+example_sergio_summary.sh
+
+screenlog.0
+
+/DONS/
+/UCI_ML_Repository/
+/cached/
+/DONS/*
+/UCI_ML_Repository/*
+/cached/*
+
+/prove/
+/prove/*
+
+*.json
+
+/__pycache__/
+/__pychache__/*
+
+/vast_api_logs/
+/vast_api_logs/*
+
+*.tpl
+
+
+./.settings/
+
+
+
+
+*.Rhistory
+*.Rproj
+*.RData
+
+tomcat
+
+#
+# Default excludes
+#
+
+# Binaries
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+*.war
+*.ear
+*.sar
+*.class
+
+# Maven 
+target/
+
+# IntelliJ project files 
+*.iml
+*.iws
+*.ipr
+.idea/
+
+# eclipse project file
+.settings/
+.classpath
+.project
+
+# NetBeans specific
+nbproject/private/
+build/
+nbbuild/
+dist/
+nbdist/
+nbactions.xml
+nb-configuration.xml
+
+
+# OS
+.DS_Store
+
+# Misc
+*.swp
+release.properties
+pom.xml.releaseBackup
+pom.xml.tag
+__pycache__
+
+.Rproj.user
+
+/bin/

app-demo-myMultiNER.py

@@ -0,0 +1,826 @@
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "1,6" # to use the GPUs 3,4 only
+
+os.environ["HF_HUB_CACHE"] = "/eos/jeodpp/home/users/consose/cache/huggingface/hub"
+os.environ["HUGGINGFACE_HUB_CACHE"] = "/eos/jeodpp/home/users/consose/cache/huggingface/hub"
+os.environ["HF_HOME"] = "/eos/jeodpp/home/users/consose/cache/huggingface/hub"
+
+from transformers import file_utils
+print(file_utils.default_cache_path)
+
+import pandas as pd
+from tqdm import tqdm
+from gliner import GLiNER
+import logging
+from jinja2 import Template
+from collections import Counter
+
+from transformers import pipeline, AutoTokenizer
+
+#os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:512"
+os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'expandable_segments:True'
+
+#import html
+
+import torch
+torch.cuda.empty_cache()  # Clear cache ot torch
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"Device: {device}...")
+if device.type == "cuda":
+    print("GPU number:", torch.cuda.current_device())
+
+import datasets
+
+import argparse
+import json
+import random
+import numpy as np
+
+import tiktoken
+from langchain.text_splitter import TokenTextSplitter
+
+import gradio as gr
+import re
+from common import strtobool, token_counter, encoding_getter, strip_quotes
+from nerBio import annotate, entitiesFusion, is_cross_inside, elinking
+from llmqueryNer import call_model, call_model_with_caching, process_list, setup_gptjrc, api_call_gptjrc, model_list_gptjrc
+
+
+from joblib import Memory
+
+cachedir = 'cached'
+mem = Memory(cachedir, verbose=False)
+
+# this is to completely delete the cache:
+# mem.clear(warn=False)
+
+
+
+
+
+examples = [
+["He said the disease was 1st detected to have spread to Malaysia from Africa in 1997. " , None],
+["He said the disease which was 1st detected in Johor had spread to Negeri Sembilan, Melaka, Perak, Selangor and the latest Kedah.  He said the disease was 1st detected to have spread to Malaysia from Africa in 1997. ", None],
+["The Health Ministry has detected about 4000 suspected chikungunya cases nationwide this year [2008], Minister Datuk Liow Tiong Lai said Wednesday [17 Dec 2008]. ", None],
+["The Health Ministry has detected about 4000 suspected chikungunya cases nationwide this year [2008], Minister Datuk Liow Tiong Lai said Wednesday [17 Dec 2008]. He said the disease which was 1st detected in Johor had spread to Negeri Sembilan, Melaka, Perak, Selangor and the latest Kedah. \"So far, the chikungunya disease is still under control nationwide,\" he told reporters after visiting Sultanah Nur Zahirah Hospital here. Present was Terengganu Health Director Dr. Nordiyanah Hassan. Liow said that so far, there is no specific medicine to treat the chikungunya fever disease spread by _Aedes_ mosquito. \"So, I would like to call on the public to be careful particularly during the wet season now because _Aedes_ mosquito is easy to breed,\" he said. To contain the spread of the disease, he said, the ministry had taken several measures including intensifying the campaign to rid of _Aedes_ mosquito and holding lectures on the outbreak. He said the disease was 1st detected to have spread to Malaysia from Africa in 1997. Meanwhile, he said 63 health projects costing RM458 million [USD 131 230 211] had been approved for implementation in Terengganu under the Ninth Malaysia Plan and some had started.", None],
+["Carcinoma", None],
+["The doctor diagnosed the patient with basal cell carcinoma, a common type of skin cancer.", None],
+["West Nile virus", None],
+["Legionellosis", None],
+["Eight years ago I started with Fosamax for 3-4 years and then took Actonel. In March, I decided not to take Actonel any longer. I had been on it for too long and was fearful of esophageal cancer and bone breakage. Now my doctor wants me to take the Prolia injections, which I am not going to do. I am not going to continue with any drugs. My bone density recently done was in the minuses. I do work with a personal trainer and execise daily. I am searching for alternative ways to deal with this problem.", None],
+["Does Chicago have any stores and does Joe live here?", None],
+["Cholera has been reported every week since November 1994. By 5 November 1995 at total of 12,344 with 245 deaths have been notified. Of these, 879 cases with 4 deaths were reported for the period 9 October to 5 November 1995. Control efforts have not succeeded in preventing the spread of the epidemic and when cases were detected on Sao Nicolau and Sal Islands in the period 9 October to 5 November all nine inhabited islands of Cap Verde had become infected. The last cholera epidemic in Cap Verde occurred in 1979. (See also Weekly Epidemiological Record No. 44, 3 November 1995) Côte d'Ivoire: A cholera outbreak which started in September 1995 caused 2,027 cases and 150 deaths up to 12 November 1995. The first cases were reported in Department de l'Ouest on 18 September 1995. Cases were subsequently reported in Department de Nord and most recently in Department du Centre and Department de Sud. The WHO Representative assisted in the organization of a team to visit the area and evaluate the situation as well as arranging for medical supplies. (1.12.95) Iran, Islamic Republic of,: Kordestan Province has been declared free of cholera. (1.12.95) Iraq: An outbreak of cholera reported from Sulaimaniyah Governorate in Northern Iraq has resulted in 519 cases, 264 of which have been confirmed, and 3 deaths to date. Vibrio cholerae O1 serotype Ogawa has been isolated. At the request of the Iraqi Ministry of Health, a WHO consultant has been sent to the area to assess and monitor the situation, provide guidance to the health authorities, and coordinate inputs by non-governmental organizations. WHO has also made available essential treatment supplies. An intensive media campaign to raise public awareness about essential preventive measures has been successful in containing the spread of the outbreak. (1.12.95) Senegal: Despite the fact that cholera has been endemic in countries bordering Senegal for the past two years, no cases were reported from Senegal until mid- August 1995. Between 15 August and 17 November 1995, 852 case and 43 deaths were notified. A further 731 cases with 37 deaths have been reported for the period 1 September to 12 November. Most cases were in the Departments of Dakar and Pikine in the Dakar Region and recently also Departments of Mbacke and Touba in Diourbel Region. ", None],
+]
+
+
+
+models_List = ["FacebookAI/xlm-roberta-large-finetuned-conll03-english",  "Babelscape/wikineural-multilingual-ner",  "blaze999/Medical-NER", "urchade/gliner_large-v2.1", "urchade/gliner_large_bio-v0.1", "NCBO/BioPortal" ] # "urchade/gliner_large-v2.1",  "knowledgator/gliner-multitask-large-v0.5"
+#models_List = ["Babelscape/wikineural-multilingual-ner",  "blaze999/Medical-NER", "urchade/gliner_large-v2.1", "NCBO/BioPortal" ]
+#models_List = ["NCBO/BioPortal" ]
+
+#categories_List = ["MED","LOC","PER","ORG","DATE","MISC"]
+categories_List = ["MED","LOC","PER","ORG","DATE","MISC", "CONC", "BIOP", "ACTI", "ANAT", "CHEM",  "DEVI", "DISO", "GENE", "GEOG", "LIVB", "OBJC", "OCCU", "ORGA", "PHEN", "PHYS" , "PROC"]
+
+POSSIBLE_KGchoices_List = ["AI", "AIO", "AEO", "BFO", "BIM", "BCGO", "CL", "CHIRO", "CHEBI", "DCM", "FMA", "GO", "GENO",
+             "GeoSPARQL", "HL7", "DOID", "HP", "HP_O", "IDO", "IAO", "ICD10", "LOINC", "MESH",
+             "MONDO", "NCIT", "NCBITAXON", "NCBITaxon_", "NIFCELL", "NIFSTD", "GML", "OBCS", "OCHV", "OHPI",
+             "OPB", "TRANS", "PLOSTHES", "RADLEX", "RO", "STY", "SO", "SNOMED", "STATO",
+             "SYMP", "FoodOn", "UBERON", "ORDO", "HOOM", "VO", "OGMS", "EuroSciVoc"]
+
+
+modelGliner=None
+modelGlinerBio=None
+
+num_cores_Gliner_forDemo = 0  # 0 means use the GPU for Gliner !
+tokenizerGliner = AutoTokenizer.from_pretrained('microsoft/deberta-v3-large')
+
+
+encod = encoding_getter('microsoft/deberta-v3-large')
+text_splitter = TokenTextSplitter(
+    # separators=separators,
+    encoding_name=encod.name,
+    chunk_size=80000,
+    chunk_overlap=50,
+    length_function=len,
+    add_start_index=True,
+)
+
+pipe_dict = {}
+for modelName in models_List:
+    tsk = "token-classification"
+    if (("/gliner" in modelName) == False) and (("NCBO" in modelName) == False):
+        pipe = pipeline(
+            tsk,
+            model=modelName,
+            aggregation_strategy="simple",
+            device=device,
+        )
+        pipe_dict[modelName] = pipe
+    elif ("/gliner" in modelName):
+        if not tokenizerGliner:
+            tokenizerGliner = AutoTokenizer.from_pretrained('microsoft/deberta-v3-large')
+        if "_bio-" in modelName:
+            if num_cores_Gliner_forDemo > 0:
+                modelGlinerBio = GLiNER.from_pretrained(modelName)  # "urchade/gliner_large_bio-v0.1")
+            else:
+                modelGlinerBio = GLiNER.from_pretrained(modelName, map_location=device)
+        else:
+            if num_cores_Gliner_forDemo > 0:
+                modelGliner = GLiNER.from_pretrained(
+                    modelName)  # "knowledgator/gliner-multitask-large-v0.5" - "urchade/gliner_large-v2.1"
+            else:
+                modelGliner = GLiNER.from_pretrained(modelName, map_location=device)
+
+
+#### GPT@JRC API
+#if args.service_provider == "gptjrc":
+key_gptjrc = ""
+fkeyname = "GPTJRC-APItoken.key"
+if os.path.exists(fkeyname):
+    with open(fkeyname) as f:
+        key_gptjrc = f.read()
+else:
+    key_gptjrc = os.environ['key_gptjrc']
+setup_gptjrc(key_gptjrc)
+#####
+
+
+# Add this function to handle dropdown selection
+def get_urls(word, df_annotated_combined):
+    # Filter the DataFrame to get rows where 'ALLURIScontext' is not empty or None
+    #valid_entries = df_annotated_combined[df_annotated_combined['ALLURIScontext'].apply(lambda x: x is not None and x != [])]
+    valid_entries = df_annotated_combined[df_annotated_combined['ALLURIScontext'].apply(lambda x: x is not None and x != [] and (
+                isinstance(x, list) and (isinstance(x, list) and len(x) > 0) and (not (len(x) == 1 and not str(x[0]).strip()))))]
+
+    # Check if the word is in the filtered DataFrame
+    if word in valid_entries['word'].values:
+        urls = valid_entries.loc[valid_entries['word'] == word, 'ALLURIScontext'].values[0]
+
+        if 'namedEntity' in df_annotated_combined.columns:
+            firsturlinlist = df_annotated_combined.loc[df_annotated_combined['word'] == word, 'namedEntity']
+            firsturlinlist = firsturlinlist.iloc[0] if not firsturlinlist.empty else None
+            if firsturlinlist and firsturlinlist in urls:
+                # Remove the URL from its current position
+                urls.remove(firsturlinlist)
+                # Insert the URL at the first position
+                urls.insert(0, firsturlinlist)
+
+        html_links = "<br>".join([f'<a href="https://expl-rels-dev-vast.apps.ocpt.jrc.ec.europa.eu/?concept={url}" target="_blank">{url}</a>' for url in urls])
+        #html_links = "<br>".join([f'<a href="https://api-vast.jrc.service.ec.europa.eu/describe//?url={url}" target="_blank">{url}</a>' for url in urls])
+        return html_links
+    return ""
+
+
+
+
+###@mem.cache
+def nerBio(text, ModelsSelection, CategoriesSelection, ScoreFilt, EntityLinking, KGchoices, state: dict):
+
+    if EntityLinking:
+        EnableNEL="True"
+    else:
+        EnableNEL="False"
+
+    if not text:
+        html_output = f"<div class='gr-textbox' style='white-space: pre-wrap; overflow-wrap: break-word; padding: 10px; border: 1px solid #ddd; border-radius: 5px; font-family: monospace; font-size: 12px; line-height: 24px;'>{text}</div>"
+        state = {
+            "text": "",
+            "df_annotated_dict": dict(),
+            "KGchoices": KGchoices
+        }
+        return {"text": text, "entities": []}, html_output, state, [], ""
+
+    df_annotated = pd.DataFrame()
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--model_id", type=str, default=models_List[0], help="model to use")
+
+    parser.add_argument("--debug", type=str, default="True", help="set debug mode")
+
+    parser.add_argument("--source_column", type=str, default="ContextToAnnotate")
+
+    parser.add_argument("--entities_filter_threshold", type=int, default=ScoreFilt)
+
+    parser.add_argument("--SEED", type=int, default=41)
+    parser.add_argument("--batch_size", type=int, default=32)  # 4 - 8 - 16
+    parser.add_argument("--num_cores_Gliner", type=int, default=num_cores_Gliner_forDemo, help="parallel processing for Gliner annotation")  # 0 means use the GPU for Gliner !
+
+    parser.add_argument("--entity_linking", type=str, default=EnableNEL, help="whether to make entities linking or not")
+    parser.add_argument("--geonameskey_filename", type=str, default="GEONAMES-API.key", help="file location where it is stored the geonames api key")
+    parser.add_argument("--virtuosokey_filename", type=str, default="VIRTUOSO-dba.key", help="file location where it is stored the virtuoso endpoint dba pwd")
+    parser.add_argument("--bioportalkey_filename", type=str, default="NCBO-BioPortal.key", help="file location where it is stored the NCBO  BioPortal api key")
+
+    # consose 20250205:
+    # KGchoices = None
+    # KGchoices = ['SNOMED', 'LOINC', 'ICD10', 'NCIT']
+    # KGchoices = ['SNOMED', 'LOINC', 'ICD10', 'MESH', 'NCIT']  # restricts the input to these values only
+    if KGchoices:
+        KGchoices.sort()
+    parser.add_argument("--KG_restriction", nargs='+', choices=KGchoices, default=KGchoices,
+                        help="List of ontologies to which restrict the entity linking task.")
+    #consose 20250502:
+    if Counter(KGchoices) == Counter(POSSIBLE_KGchoices_List):
+        parser.add_argument("--USE_CACHE", type=str, default="False",
+                            help="whether to use cache for the NER and NEL tasks or not")
+    else:
+        #print("Lists do not have the same elements")
+        parser.add_argument("--USE_CACHE", type=str, default="False",
+                            help="whether to use cache for the NER and NEL tasks or not")
+
+    parser.add_argument("--num_cores_eLinking", type=int, default=10, help="parallel processing for the entity linking process")
+
+    parser.add_argument("--computeEntityContext", type=str, default="False",
+                        help="whether to extract a readable context from the extracted triples for the concept")
+    parser.add_argument("--computeEntityGlobalContext", type=str, default="False",
+                        help="whether to extract a readable context from the extracted triples of all the entities extracted from the endpoint for the concept")
+    parser.add_argument("--UseRetrieverForContextCreation", type=str, default="True",
+                        help="whether to use a retriever for the creation of the context of the entities from the triples coming from the KGs")
+
+    parser.add_argument("--service_provider", type=str, default="gptjrc", help="llm service provider")
+    parser.add_argument("--model_name", type=str, default="llama-3.1-70b-instruct", help="llm to use")
+    parser.add_argument("--tokens_max", type=int, default=80000, help="max number of tokens to supply to the llm")
+
+    parser.add_argument("--temperature", type=int, default=0.01)
+
+
+    args = parser.parse_args()
+
+    df_ToAnnotate = pd.DataFrame()
+
+    previous_text = ""
+    previous_df_annotated_dict = dict()
+    previous_kg_choices = []
+    if state:
+        previous_text = state.get("text", "")
+        previous_df_annotated_dict = state.get("df_annotated_dict", {})
+        previous_kg_choices = state.get("KGchoices", [])
+
+    #print("Are all models in any row of the 'model' column, case-insensitively?", all_models_in_any_row)
+    #if (not history_dict) or (history_dict[args.source_column][0] != text) or (all_models_in_any_row == False):
+    #if (not history_dict) or (history_dict[args.source_column][0] != text):
+    if (not previous_df_annotated_dict) or (previous_text != text) or (sorted(previous_kg_choices) != sorted(KGchoices) ):
+
+        for model_id in models_List:  # always do all the annotations, only filter them afterwards
+        #for model_id in ModelsSelection:
+
+            # if history_dict and (history_dict[args.source_column][0] == text):
+            #     if model_id in hhist['model'].unique():
+            #         continue
+
+            parser.set_defaults(model_id=model_id)
+
+            args = parser.parse_args()
+
+            print("ARGS:")
+            print(args)
+
+            # %% n machine learning tasks, particularly when dealing with models that have stochasticity involved (like text generation), it's important to set seeds for random number generators to ensure reproducibility of results. In the case of using models from the transformers library, you need to set seeds for both Python's random module, NumPy, and PyTorch to ensure that the results are the same every time you run the code.
+            # Before you create the pipeline and run the text generation, set the seeds like this:
+            random.seed(args.SEED)
+            np.random.seed(args.SEED)
+            torch.manual_seed(args.SEED)
+            torch.cuda.manual_seed_all(args.SEED)
+            ###
+
+            df_ToAnnotate = pd.DataFrame({ "ToLink": [None], args.source_column: [text]})
+
+            if "SentenceRef" not in df_ToAnnotate.columns:
+                df_ToAnnotate["SentenceRef"] = None
+                df_ToAnnotate = df_ToAnnotate[['SentenceRef'] + [col for col in df_ToAnnotate.columns if
+                                                                 col != 'SentenceRef']]  # this moves it to the first position
+
+            df_ToAnnotate['SentenceRef'] = df_ToAnnotate.index + 1
+            df_ToAnnotate['SentenceRef'] = df_ToAnnotate['SentenceRef'].argsort().groupby(df_ToAnnotate[args.source_column]).transform('min').astype(int)
+            df_ToAnnotate['SentenceRef'] = df_ToAnnotate['SentenceRef'].rank(method='dense').astype(int)
+
+            # device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+            # if strtobool(args.debug):
+            #     print(f"Device: {device}...")
+            #     if device.type == "cuda":
+            #         print("GPU number:", torch.cuda.current_device())
+
+            pipeToUse = None
+            if (("gliner" in args.model_id) == False) and (("NCBO" in args.model_id)== False) :
+                pipeToUse = pipe_dict[args.model_id]
+
+            new_annotations = annotate(df_ToAnnotate, args, pipeToUse, tokenizerGliner, modelGliner, modelGlinerBio, device)
+            if not new_annotations.empty:
+                if df_annotated.empty:
+                    # If df_annotated is empty, just assign new_annotations to it
+                    df_annotated = new_annotations
+                else:
+                    # If df_annotated is not empty, concatenate new_annotations to it
+                    df_annotated = pd.concat([df_annotated, new_annotations], ignore_index=True)
+
+        state = {
+            "text": text,
+            "df_annotated_dict": df_annotated.to_dict(),
+            "KGchoices": KGchoices
+        }
+
+    else:
+
+        print("ARGS:")
+        print(args)
+
+        # %% n machine learning tasks, particularly when dealing with models that have stochasticity involved (like text generation), it's important to set seeds for random number generators to ensure reproducibility of results. In the case of using models from the transformers library, you need to set seeds for both Python's random module, NumPy, and PyTorch to ensure that the results are the same every time you run the code.
+        # Before you create the pipeline and run the text generation, set the seeds like this:
+        random.seed(args.SEED)
+        np.random.seed(args.SEED)
+        torch.manual_seed(args.SEED)
+        torch.cuda.manual_seed_all(args.SEED)
+        ###
+
+        history = pd.DataFrame(previous_df_annotated_dict)
+        df_annotated = history.copy()
+
+        state = {
+            "text": text,
+            "df_annotated_dict": df_annotated.to_dict(),
+            "KGchoices": KGchoices
+        }
+
+
+    quoted_text = text.startswith('"') & text.endswith('"')
+    if (not df_annotated.empty) or quoted_text:
+
+        if (not df_annotated.empty):
+            # filter now per models selection
+            df_annotated = df_annotated[df_annotated['model'].str.lower().isin([model.lower() for model in ModelsSelection])]
+            if df_annotated.empty and quoted_text==False:
+                html_output = f"<div class='gr-textbox' style='white-space: pre-wrap; overflow-wrap: break-word; padding: 10px; border: 1px solid #ddd; border-radius: 5px; font-family: monospace; font-size: 12px; line-height: 24px;'>{text}</div>"
+                return {"text": text, "entities": []}, html_output, state, [], ""
+
+        df_annotated_combined = pd.DataFrame()
+        if (not df_annotated.empty):
+            df_annotated_combined = entitiesFusion(df_annotated,args)
+            if df_annotated_combined.empty and quoted_text==False:
+                html_output = f"<div class='gr-textbox' style='white-space: pre-wrap; overflow-wrap: break-word; padding: 10px; border: 1px solid #ddd; border-radius: 5px; font-family: monospace; font-size: 12px; line-height: 24px;'>{text}</div>"
+                return {"text": text, "entities": []}, html_output, state, [], ""
+            else:
+                if (not df_annotated.empty):
+                    df_annotated_combined = is_cross_inside(df_annotated_combined, args, 0.999)  #I cut all the cross inside with the 0.99. to avoid the linking
+
+
+        cache_prefix_fp = "LLMQUERYNER"
+        cache_nameLLMs = cache_prefix_fp + "___" + "__".join(
+            [args.service_provider, args.model_name, str(args.temperature)]).replace(
+            " ", "_") + ".json"
+
+        load_map_query_input_output = None
+        if strtobool(args.USE_CACHE):
+            if os.path.exists(cache_nameLLMs):
+                with open(cache_nameLLMs) as f:
+                    load_map_query_input_output = json.load(f)
+            else:
+                load_map_query_input_output = {}
+
+        ### entity linking part:
+        if strtobool(args.entity_linking):
+
+            cache_map_geonames = None
+            if strtobool(args.USE_CACHE):
+                cache_filename = "CACHE_geonames.json"
+                if os.path.exists(cache_filename):
+                    with open(cache_filename) as f:
+                        cache_map_geonames = json.load(f)
+                else:
+                    cache_map_geonames = {}
+
+            key_geonames = ""
+            if args.geonameskey_filename:
+                fkeyname = args.geonameskey_filename
+                with open(fkeyname) as f:
+                    key_geonames = f.read()
+            else:
+                key_geonames = os.environ['key_geonames']
+
+            cache_map_virtuoso = None
+            if strtobool(args.USE_CACHE):
+                cacheVirtuoso_filename = "CACHE_virtuoso.json"
+                if os.path.exists(cacheVirtuoso_filename):
+                    with open(cacheVirtuoso_filename) as f:
+                        cache_map_virtuoso = json.load(f)
+                else:
+                    cache_map_virtuoso = {}
+
+            key_virtuoso = ""
+            if args.virtuosokey_filename:
+                fkeyname = args.virtuosokey_filename
+                with open(fkeyname) as f:
+                    key_virtuoso = f.read()
+            else:
+                key_virtuoso = os.environ['key_virtuoso']
+
+
+            # Here for the EXACT MATCHING "" - if the desired term has not been identified in the NER, add to the dataframe:
+
+            if df_ToAnnotate.empty:
+                df_ToAnnotate = pd.DataFrame({"ToLink": [None], args.source_column: [text]})
+
+                if "SentenceRef" not in df_ToAnnotate.columns:
+                    df_ToAnnotate["SentenceRef"] = None
+                    df_ToAnnotate = df_ToAnnotate[['SentenceRef'] + [col for col in df_ToAnnotate.columns if
+                                                                     col != 'SentenceRef']]  # this moves it to the first position
+
+                df_ToAnnotate['SentenceRef'] = df_ToAnnotate.index + 1
+                df_ToAnnotate['SentenceRef'] = df_ToAnnotate['SentenceRef'].argsort().groupby(
+                    df_ToAnnotate[args.source_column]).transform('min').astype(int)
+                df_ToAnnotate['SentenceRef'] = df_ToAnnotate['SentenceRef'].rank(method='dense').astype(int)
+
+            # Define the condition to find missing SentenceRefs
+            missing_sentence_refs = ~df_ToAnnotate['SentenceRef'].isin(df_annotated_combined['SentenceRef'])
+
+            # Define the condition to check if ContextToAnnotate starts and ends with quotes
+            quoted_context = df_ToAnnotate[args.source_column].str.startswith('"') & df_ToAnnotate[
+                args.source_column].str.endswith('"')
+
+            # Combine both conditions
+            condition = missing_sentence_refs & quoted_context
+
+            # Select rows from df_ToAnnotate that meet the condition
+            rows_to_add = df_ToAnnotate[condition]
+
+            rows_to_add['model'] = "Forced"
+            rows_to_add['entity_group'] = "MISC"
+            rows_to_add['word'] = rows_to_add[args.source_column]
+            rows_to_add['word'] = rows_to_add[args.source_column].apply(strip_quotes)
+            rows_to_add['score'] = 1.0
+            rows_to_add['start'] = int(1)
+            rows_to_add['end'] = rows_to_add['word'].apply(len) + int(1)
+            rows_to_add['IsGeo'] = None
+            rows_to_add['IsBio'] = None
+            rows_to_add['IsCrossInside'] = 0.0
+
+            if df_annotated_combined.empty:
+                df_annotated_combined = pd.DataFrame(columns=df_ToAnnotate.columns)
+
+            # Append these rows to df_annotated_combined
+            df_annotated_combined = pd.concat([df_annotated_combined, rows_to_add], ignore_index=True)
+
+            df_annotated_combined['start'] = df_annotated_combined['start'].astype(int)
+            df_annotated_combined['end'] = df_annotated_combined['end'].astype(int)
+
+            df_annotated_combined = df_annotated_combined.sort_values(
+                by=['SentenceRef', 'start', 'ToLink', 'word', 'score'],
+                ascending=[True, True, True, True, False])
+
+            # Now df_annotated_combined contains the additional rows
+
+            df_annotated_combined, cache_map_geonames_AFTER, cache_map_virtuoso_AFTER, load_map_query_input_output_AFTER = elinking(df_annotated_combined,
+                                                                                                                                 text_splitter, args, key_geonames,
+                                                                                                                                 cache_map_geonames,
+                                                                                                                                 key_virtuoso,
+                                                                                                                                 cache_map_virtuoso,
+                                                                                                                                    load_map_query_input_output,
+                                                                                                                                    device)
+
+            if strtobool(args.USE_CACHE):
+                if cache_map_geonames_AFTER is not None:
+                    with open(cache_filename, "w") as f:
+                        json.dump(cache_map_geonames_AFTER, f)
+
+                if cache_map_virtuoso_AFTER is not None:
+                    with open(cacheVirtuoso_filename, "w") as f:
+                        json.dump(cache_map_virtuoso_AFTER, f)
+
+                if load_map_query_input_output_AFTER is not None:
+                    with open(cache_nameLLMs, "w") as f:
+                        json.dump(load_map_query_input_output_AFTER, f)
+
+            ### end entity linking part
+
+
+        ### filter by selected category only
+        # #df_annotated_combined = df_annotated_combined[df_annotated_combined['entity_group'].str.lower().isin([cat.lower() for cat in CategoriesSelection])]
+        # if "MED" in CategoriesSelection:
+        #     filter_mask = df_annotated_combined['entity_group'].str.lower().isin(
+        #         [cat.lower() for cat in CategoriesSelection]) | (df_annotated_combined['IsBio'] == 1)
+        # else:
+        #     filter_mask = df_annotated_combined['entity_group'].str.lower().isin(
+        #         [cat.lower() for cat in CategoriesSelection])
+        # df_annotated_combined = df_annotated_combined[filter_mask]
+        #
+        # if "MED" in CategoriesSelection:
+        #     filter_mask = df_annotated_combined['entity_group'].str.lower().isin(
+        #         [cat.lower() for cat in CategoriesSelection]) | (df_annotated_combined['IsBio'] == 1)
+        # elif "OTHER" in CategoriesSelection:
+        #     filter_mask = ~(
+        #         df_annotated_combined['entity_group'].str.lower().isin([cat.lower() for cat in categories_List]))
+        # else:
+        #     filter_mask = df_annotated_combined['entity_group'].str.lower().isin(
+        #         [cat.lower() for cat in CategoriesSelection])
+
+        filter_mask = df_annotated_combined['entity_group'].str.lower().isin(
+            [cat.lower() for cat in CategoriesSelection])
+        if "MED" in CategoriesSelection:
+            filter_mask |= ~(df_annotated_combined['entity_group'].str.lower().isin([cat.lower() for cat in categories_List])) & (df_annotated_combined['IsBio'] == 1)
+        if "MISC" in CategoriesSelection:
+            # filter_mask |= ~(df_annotated_combined['entity_group'].str.lower().isin([cat.lower() for cat in categories_List]))
+            # filter_mask |= ~(df_annotated_combined['entity_group'].str.lower().isin([cat.lower() for cat in categories_List])) & ~(df_annotated_combined['IsBio'] == 1)  # with this cluase, I'm including not only the categories labelled as MISC, but also the other that are not MED, PER, ORG, LOC
+            filter_mask |= ~(
+                df_annotated_combined['entity_group'].str.lower().isin([cat.lower() for cat in categories_List])) & ~(
+                        df_annotated_combined[
+                            'IsBio'] == 1)  # with this cluase, I'm including not only the categories labelled as MISC, but also the other that are not MED, PER, ORG, LOC
+
+        df_annotated_combined = df_annotated_combined[filter_mask]
+        if df_annotated_combined.empty:
+            html_output = f"<div class='gr-textbox' style='white-space: pre-wrap; overflow-wrap: break-word; padding: 10px; border: 1px solid #ddd; border-radius: 5px; font-family: monospace; font-size: 12px; line-height: 24px;'>{text}</div>"
+            return {"text": text, "entities": []}, html_output, state, [], ""
+
+        ###
+
+        #df_annotated_combined = is_cross_inside(df_annotated_combined, args)
+
+        if 'IsCrossInside' in df_annotated_combined.columns:
+            df_annotated_combined = df_annotated_combined[df_annotated_combined['IsCrossInside'] != 1]
+            if df_annotated_combined.empty:
+                html_output = f"<div class='gr-textbox' style='white-space: pre-wrap; overflow-wrap: break-word; padding: 10px; border: 1px solid #ddd; border-radius: 5px; font-family: monospace; font-size: 12px; line-height: 24px;'>{text}</div>"
+                return {"text": text, "entities": []}, html_output, state, [], ""
+
+        dict_annotated_combined_NER = df_annotated_combined[["end", "entity_group", "score", "start", "word"]].to_dict(orient="records")
+
+        ### continue linking part:
+        if strtobool(args.entity_linking):
+            # ##### this is to pass the links:
+
+            # # Create a new column for the entities with links
+            df_annotated_combined['entity_with_link'] = df_annotated_combined.apply(
+                lambda row: (
+                    f"<a href='https://expl-rels-dev-vast.apps.ocpt.jrc.ec.europa.eu/?concept={row['namedEntity']}' target='_blank'>{row['word']}</a>"
+                    if row['namedEntity'] not in [None, '', 'NaN', 'nan'] and pd.notnull(row['namedEntity']) else row[
+                        'word']
+                ),
+                #lambda row: (
+                #    f"<a href='https://api-vast.jrc.service.ec.europa.eu/describe//?url={row['namedEntity']}' target='_blank'>{row['word']}</a>"
+                #    if row['namedEntity'] not in [None, '', 'NaN', 'nan'] and pd.notnull(row['namedEntity']) else row[
+                #        'word']
+                #),
+                axis=1
+            )
+
+            # Create a new dictionary with the entity information and the link
+            dict_annotated_combined_NEL = df_annotated_combined[
+                ["end", "entity_group", "score", "start", "entity_with_link"]].to_dict(orient="records")
+
+            # Sort the entities by their start index
+            dict_annotated_combined_NEL.sort(key=lambda x: x['start'])
+
+            # Create a dictionary to map entity groups to colors
+            entity_colors = {
+                "MED": "#E6E6E6",
+                "PER": "#FFC0CB",
+                "ORG": "#C6F4D6",
+                "LOC": "#FFFFCC",
+                "MISC": "#F5DEB3"
+            }
+
+            text_with_links = text
+            offset = 0
+            for entity in dict_annotated_combined_NEL:
+                start = entity["start"] + offset
+                end = entity["end"] + offset
+                entity_text = entity["entity_with_link"]
+                text_with_links = text_with_links[:start] + entity_text + text_with_links[end:]
+                offset += len(entity_text) - (end - start)
+
+            # # Create the text with entities highlighted and linked
+            # text_with_links = text
+            # offset = 0
+            # for entity in dict_annotated_combined_NEL:
+            #     start = entity["start"] + offset
+            #     end = entity["end"] + offset
+            #     entity_text = entity["entity_with_link"]
+            #     entity_group = entity["entity_group"]
+            #
+            #     color = entity_colors.get(entity_group, "#dbeafe")  # Default
+            #     darker_color = "#008080"
+            #
+            #     if "https:" in entity_text:
+            #         text_with_links = text_with_links[
+            #                           :start] + f'<span style="background-color: {color}; border-radius: 2px; padding: 2px 4px"><a style="color: {darker_color}" href="{entity_text.split(">")[1].split("<")[0]}">{entity_text.split(">")[1].split("<")[0]}</a> <span style="color: {darker_color}; font-size: 0.8em">{entity_group}</span></span>' + text_with_links[
+            #                                                                                                                                                                                                                                                                                                                                 end:]
+            #         offset += len(
+            #             f'<span style="background-color: {color}; border-radius: 2px; padding: 2px 4px"><a style="color: {darker_color}" href="{entity_text.split(">")[1].split("<")[0]}">{entity_text.split(">")[1].split("<")[0]}</a> <span style="color: {darker_color}; font-size: 0.8em">{entity_group}</span></span>') - (
+            #                               end - start)
+            #         # text_with_links = text_with_links[:start] + f'<span style="background-color: {color}"><a href="{entity_text.split(">")[1].split("<")[0]}">{entity_text.split(">")[1].split("<")[0]}</a></span>' + text_with_links[end:]
+            #         # offset += len(
+            #         #     f'<span style="background-color: {color}"><a href="{entity_text.split(">")[1].split("<")[0]}">{entity_text.split(">")[1].split("<")[0]}</a></span>') - (
+            #         #                       end - start)
+            #         #
+            #         #     text_with_links = text_with_links[:start] + entity_text + text_with_links[end:]
+            #         #     offset += len(entity_text) - (end - start)
+            #     else:
+            #         text_with_links = text_with_links[
+            #                           :start] + f'<span style="background-color: {color}; border-radius: 2px; padding: 2px 4px">{entity_text} <span style="color: {darker_color}; font-size: 0.8em">{entity_group}</span></span>' + text_with_links[end:]
+            #         offset += len(
+            #             f'<span style="background-color: {color}; border-radius: 2px; padding: 2px 4px">{entity_text} <span style="color: {darker_color}; font-size: 0.8em">{entity_group}</span></span>') - (
+            #                           end - start)
+            #         # text_with_links = text_with_links[
+            #         #                   :start] + f'<span style="background-color: {color}">{entity_text}</span>' + text_with_links[
+            #         #                                                                                               end:]
+            #         # offset += len(
+            #         #     f'<span style="background-color: {color}">{entity_text}</span>') - (end - start)
+
+
+            # Update state with the DataFrame
+            state["df_annotated_combined_dict"] = df_annotated_combined.to_dict()
+
+            if 'ALLURIScontext' in df_annotated_combined.columns:
+                # words_for_dropdown = df_annotated_combined[
+                #     df_annotated_combined['ALLURIScontext'].apply(lambda x: x is not None and x != [])][
+                #     'word'].unique().tolist()
+                words_for_dropdown = df_annotated_combined[df_annotated_combined['ALLURIScontext'].apply(lambda x: x is not None and x != [] and (isinstance(x, list) and len(x) > 0) and (isinstance(x, list) and (not (len(x) == 1 and not str(x[0]).strip())) ))]['word'].unique().tolist()
+                words_for_dropdown = list({entry.lower(): entry for entry in words_for_dropdown}.values())
+                words_for_dropdown.insert(0, "")
+            else:
+                words_for_dropdown = []
+
+            html_output = f"<div class='gr-textbox' style='white-space: pre-wrap; overflow-wrap: break-word; padding: 10px; border: 1px solid #ddd; border-radius: 5px; font-family: monospace; font-size: 12px; line-height: 24px;'>{text_with_links}</div>"
+
+            #return {"text": text, "entities": dict_annotated_combined_NER}, html_output, state
+            return {"text": text, "entities": dict_annotated_combined_NER}, html_output, state, gr.update(choices=words_for_dropdown), ""
+
+        else:
+            html_output = f"<div class='gr-textbox' style='white-space: pre-wrap; overflow-wrap: break-word; padding: 10px; border: 1px solid #ddd; border-radius: 5px; font-family: monospace; font-size: 12px; line-height: 24px;'>{text}</div>"
+            return {"text": text, "entities": dict_annotated_combined_NER}, html_output, state, [], ""
+
+    else:
+
+        html_output = f"<div class='gr-textbox' style='white-space: pre-wrap; overflow-wrap: break-word; padding: 10px; border: 1px solid #ddd; border-radius: 5px; font-family: monospace; font-size: 12px; line-height: 24px;'>{text}</div>"
+        return {"text": text, "entities": []}, html_output, state, [], ""
+
+
+# "FacebookAI/xlm-roberta-large-finetuned-conll03-english",  "Babelscape/wikineural-multilingual-ner",  "blaze999/Medical-NER", "urchade/gliner_large-v2.1", "urchade/gliner_large_bio-v0.1"
+
+
+def update_urls(selected_word, state):
+    if "df_annotated_combined_dict" in state:
+    # Convert the state dictionary back into a DataFrame
+        df = pd.DataFrame(state["df_annotated_combined_dict"])
+
+        # # Filter the DataFrame to get rows where 'ALLURIScontextFromNCBO' is not empty or None
+        # valid_entries = df[df['ALLURIScontext'].apply(lambda x: x is not None and x != [])]
+        # # Filter the DataFrame to get rows where 'ALLURIScontext' is not None, not an empty list, and not an empty string
+        valid_entries = df[df['ALLURIScontext'].apply(lambda x: x is not None and x != []  and (isinstance(x, list) and len(x) > 0) and (isinstance(x, list) and (not (len(x) == 1 and not str(x[0]).strip())) ))]
+
+        # Check if the selected word is in the filtered DataFrame
+        if selected_word in valid_entries['word'].values:
+            urls = valid_entries.loc[valid_entries['word'] == selected_word, 'ALLURIScontext'].values[0]
+            if 'namedEntity' in df.columns:
+                firsturlinlist = df.loc[df['word'] == selected_word, 'namedEntity']
+                firsturlinlist = firsturlinlist.iloc[0] if not firsturlinlist.empty else None
+                if firsturlinlist and firsturlinlist in urls:
+                    # Remove the URL from its current position
+                    urls.remove(firsturlinlist)
+                    # Insert the URL at the first position
+                    urls.insert(0, firsturlinlist)
+
+            # Convert list of URLs to HTML string with clickable links
+            html_links = "<br>".join([f'<a href="https://expl-rels-dev-vast.apps.ocpt.jrc.ec.europa.eu/?concept={url}" target="_blank">{url}</a>' for url in urls])
+            #html_links = "<br>".join([f'<a href="https://api-vast.jrc.service.ec.europa.eu/describe//?url={url}" target="_blank">{url}</a>' for url in urls])
+            return html_links
+        return ""
+
+    else:
+        return ""
+
+
+# demo = gr.Interface(
+#     fn=nerBio,
+#     inputs=[
+#         gr.Textbox(label= "Input text", placeholder="Enter text here..."),
+#         gr.CheckboxGroup(models_List, label="ModelsSelection", value=models_List),
+#         gr.CheckboxGroup(categories_List, label="CategoriesSelection", value=categories_List),
+#         gr.Slider(minimum=0, maximum=1.0, step=0.1, label="Score", value=0.7),
+#         gr.Checkbox(label="Enable Named-Entity Linking (NEL)", value=False), #True False
+#         #gr.CheckboxGroup(POSSIBLE_KGchoices_List, label="KGchoices Selection", value=POSSIBLE_KGchoices_List, visible=True),
+#         gr.Dropdown(POSSIBLE_KGchoices_List, multiselect=True, label="KGchoices Selection", value=POSSIBLE_KGchoices_List),
+#         gr.State(value={})
+#     ],
+#     outputs=[
+#         gr.HighlightedText(label="Annotated Text"),
+#         gr.HTML(label="Linked Text", show_label=True, visible=True),  #   use gr.HTML to render the annotated text with links , visible
+#         gr.State(),
+#         gr.Dropdown(label="Annotated Concepts", interactive=True,visible=True),
+#         gr.Textbox(label="Linked Entities",interactive=False,visible=True)
+#     ],
+#     live=True,
+#     title="BioAnnotator: Biomedical Named-Entity Recognition (NER) and Linking (NEL)",
+#     description="""Interoperability – the capability of systems and organisations to cooperate across functional, sectoral and physical borders – is key for successful digital transformation.
+#     The [Interoperable Europe Act](https://interoperable-europe.ec.europa.eu/interoperable-europe/interoperable-europe-act) is an EU regulation that aims to strengthen public sector interoperability and will serve as a main EC policy framework for the years to come.
+#     Data exchange is vital for digital government policies, and semantic interoperability ensures systems understand each other despite different legacies and architectures.
+#
+#     In this demo we show in particular the *BioAnnotator*, a prototype tool performing Biomedical Named-Entity Recognition (NER) and Linking (NEL). To give it a try, please select one or more NER models and enter some text to get it processed. Please select also the entity categories you want to extract, as well as the score to use as a threshold for the NER extraction. Finally, select whether you want to perform Named-Entity Linking (NEL) and if you want to enable the filtering to some specific biomedical ontologies only (acronyms description at: https://bioportal.bioontology.org/ontologies). See also: [InventoryHealthKGs.pdf](https://jeodpp.jrc.ec.europa.eu/ftp/jrc-opendata/ETOHA/KGs/InventoryHealthKGs.pdf).
+#     """,
+#     examples=examples,
+#     cache_examples=False,
+#     article="""
+#     **Categories Legend:**
+#     - MED  | Medical
+#     - LOC  | Locations
+#     - PER  | Persons
+#     - ORG  | Organizations
+#     - MISC | Miscellanea
+#     - CONC | Concepts & Ideas
+#     - BIOP | Biological
+#     - ACTI | Activities & Behaviors
+#     - ANAT | Anatomy
+#     - CHEM | Chemicals & Drugs
+#     - DEVI | Devices
+#     - DISO | Disorders
+#     - GENE | Genes & Molecular Sequences
+#     - GEOG | Geographic Areas
+#     - LIVB | Living Beings
+#     - OBJC | Objects
+#     - OCCU | Occupations
+#     - ORGA | Organizations
+#     - PHEN | Phenomena
+#     - PHYS | Physiology
+#     - PROC | Procedures
+#     """
+# )
+
+
+# Define the Gradio interface using Blocks
+#description="This application performs biomedical named-entity recognition and linking."
+with gr.Blocks(title="BioAnnotator") as demo:
+
+    gr.Markdown("# BioAnnotator: Biomedical Named-Entity Recognition (NER) and Linking (NEL)")
+    gr.Markdown("""
+        This application performs biomedical named-entity recognition and linking.
+
+        **Description:**
+        *Interoperability* – the capability of systems and organisations to cooperate across functional, sectoral and physical borders – is key for successful digital transformation. 
+        The [Interoperable Europe Act](https://interoperable-europe.ec.europa.eu/interoperable-europe/interoperable-europe-act) is an EU regulation that aims to strengthen public sector interoperability and will serve as a main EC policy framework for the years to come. 
+        Data exchange is vital for digital government policies, and semantic interoperability ensures systems understand each other despite different legacies and architectures.
+
+        In this demo we show in particular the *BioAnnotator*, a prototype tool performing Biomedical Named-Entity Recognition (NER) and Linking (NEL). To give it a try, please select one or more NER models and enter some text to get it processed. Please select also the entity categories you want to extract, as well as the score to use as a threshold for the NER extraction. Finally, select whether you want to perform Named-Entity Linking (NEL) and if you want to enable the filtering to some specific biomedical ontologies only (acronyms description at: https://bioportal.bioontology.org/ontologies). See also: [InventoryHealthKGs.pdf](https://jeodpp.jrc.ec.europa.eu/ftp/jrc-opendata/ETOHA/KGs/InventoryHealthKGs.pdf).
+        """)
+
+
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(label="Input text", placeholder="Enter text here...")
+            models_selection = gr.CheckboxGroup(models_List, label="ModelsSelection", value=models_List)
+            categories_selection = gr.CheckboxGroup(categories_List, label="CategoriesSelection", value=categories_List)
+            score_slider = gr.Slider(minimum=0, maximum=1.0, step=0.1, label="Score", value=0.7)
+            nel_checkbox = gr.Checkbox(label="Enable Named-Entity Linking (NEL)", value=False)
+            kgchoices_selection = gr.Dropdown(POSSIBLE_KGchoices_List, multiselect=True, label="KGchoices Selection", value=POSSIBLE_KGchoices_List)
+            state = gr.State(value={})
+
+        with gr.Column():
+            annotated_text = gr.HighlightedText(label="Annotated Text")
+            linked_text = gr.HTML(label="Linked Text", show_label=True, visible=True)
+            word_dropdown = gr.Dropdown(label="Annotated Concepts", show_label=True, visible=True, interactive=True)
+            urls_html = gr.HTML(label="Linked Entities", show_label=True, visible=True)
+
+    ## Define the interactions
+    #text_input.change(fn=nerBio, inputs=[text_input, models_selection, categories_selection, score_slider, nel_checkbox, kgchoices_selection, state], outputs=[annotated_text, linked_text, state, word_dropdown, urls_html])
+    # Define the interactions for all inputs
+    inputs = [text_input, models_selection, categories_selection, score_slider, nel_checkbox, kgchoices_selection]
+    for input_component in inputs:
+        input_component.change(fn=nerBio,
+                               inputs=[text_input, models_selection, categories_selection, score_slider, nel_checkbox,
+                                       kgchoices_selection, state],
+                               outputs=[annotated_text, linked_text, state, word_dropdown, urls_html])
+
+    word_dropdown.change(fn=update_urls, inputs=[word_dropdown, state], outputs=urls_html)
+
+    # Add examples
+    gr.Examples(examples=examples,
+                inputs=[text_input, models_selection, categories_selection, score_slider, nel_checkbox,
+                        kgchoices_selection])
+
+    gr.Markdown("""
+        **Categories Legend:**
+        - MED  | Medical
+        - LOC  | Locations
+        - PER  | Persons
+        - ORG  | Organizations
+        - MISC | Miscellanea
+        - CONC | Concepts & Ideas 
+        - BIOP | Biological 
+        - ACTI | Activities & Behaviors
+        - ANAT | Anatomy
+        - CHEM | Chemicals & Drugs
+        - DEVI | Devices
+        - DISO | Disorders
+        - GENE | Genes & Molecular Sequences
+        - GEOG | Geographic Areas
+        - LIVB | Living Beings
+        - OBJC | Objects
+        - OCCU | Occupations
+        - ORGA | Organizations
+        - PHEN | Phenomena
+        - PHYS | Physiology
+        - PROC | Procedures
+        """)
+
+
+
+demo.launch()
+#demo.launch(share=True)  # Share your demo with just 1 extra parameter

common.py

@@ -5,11 +5,12 @@ import numpy as np
 import tiktoken
 from langchain.text_splitter import TokenTextSplitter
 
+# Function to cleanly strip quoted strings
 def strip_quotes(text):
     if text.startswith('"') and text.endswith('"'):
         return text[1:-1]
     return text
-    
+
 def strtobool(val):
     val = val.lower()
     if val in ('yes', 'true', 't', '1'):

llmqueryNer.py

@@ -0,0 +1,881 @@
+import os
+import sys
+
+import openai
+import json
+import time
+from tqdm import tqdm
+
+import logging
+
+from functools import partial
+import pandas as pd
+
+import tiktoken
+from langchain.text_splitter import TokenTextSplitter
+
+import argparse
+
+from common import cleanInputText, encoding_getter, tokenizer, token_counter
+
+#from llmqueryHF import api_call_HFonPremises
+
+#from dgl_client.api_cli import APIClient, InferenceClient
+
+#DGL_API_ENDPOINT = "https://www.diglife.eu/inference"
+#client_dglc = InferenceClient(backend_url=DGL_API_ENDPOINT)
+
+fkeyname = "GPTJRC-APItoken.key"
+key_gptjrc=""
+if os.path.exists(fkeyname):
+    with open(fkeyname) as f:
+        key_gptjrc = f.read()
+else:
+    key_gptjrc = os.environ['key_gptjrc']
+clientGPTJRC = openai.OpenAI(api_key=key_gptjrc, base_url="https://api-gpt.jrc.ec.europa.eu/v1")
+
+
+""" 
+query LLM API end point on list of text, seamlessly
+
+features:
+- build in retry in case of error
+- cache the results in case of crash
+- call LLM with a lambda or as regular function call
+
+supported API:
+- OpenAI
+- GPT@JRC
+- F7 (DigLife)
+
+issues:
+- the cache is written after each succesfull call, could results in slowdown for large dataset
+- for the moment deals only with openai's rate limit error, all other error will result in crash
+"""
+
+
+
+
+
+
+
+
+
+
+# ### OPENAI API
+
+def setup_openai(org=None, key=None):
+    if org is not None:
+        openai.organization = org
+    # else:
+    #     openai.organization = os.getenv("OPENAI_API_ORGANIZATION")
+
+    if key is not None:
+        openai.api_key = key
+    else:
+        openai.api_key = os.getenv("OPENAI_API_KEY")
+    #
+    print(model_list_openai())
+
+def api_call_openai(prompt: str, input_text: str, model: str, temperature: int, timeout_retry: int=5, delimiter: str = "```", InContextExamples: list[[str]] = [], debug=False,  args: argparse.Namespace=None):
+    """ call openai API, with a retry in case of RateLimitError """
+
+    if not(prompt) or prompt.strip=="" or not(input_text) or input_text.strip=="":
+        logging.warning("No text or promt supplied! Skypping it!")
+        return None
+
+    if delimiter and len(delimiter)>0:
+        input_text = delimiter + input_text + delimiter
+
+    response = None
+
+    myMessages = []
+    if InContextExamples:
+        for row in InContextExamples:
+            myMessages.append({"role": "system", "content": prompt})
+            for indCol, colVal in enumerate(row):
+                if indCol == 0:
+                    if delimiter and len(delimiter) > 0:
+                        myMessages.append({"role": "user", "content": (delimiter + colVal + delimiter)})
+                    else:
+                        myMessages.append({"role": "user", "content": colVal})
+                elif indCol == 1:
+                    myMessages.append({"role": "assistant", "content": colVal})
+
+    myMessages.append({"role": "system", "content": prompt})
+    myMessages.append({'role': 'user', 'content': input_text})
+
+    max_retries = 50
+    iteration = 1
+    while response is None and max_retries > 0:
+        try:
+            response = openai.ChatCompletion.create(
+                model=model,
+                # messages=[
+                #     {"role": "system", "content": prompt},
+                #     {'role': 'user', 'content': input_text},
+                # ],
+                messages=myMessages,
+                temperature=temperature,
+                #max_tokens=32000,  #it gives error
+                #max_response_tokens=32000 #it gives error
+            )
+        except openai.RateLimitError as e:
+            response = None
+            max_retries = max_retries - 1
+            print(e)
+            nt = token_counter((prompt + input_text), model)
+            print("Model "+str(model)+" - Length of overall prompt message ", str(nt))
+            print("current iteration ", iteration)
+            print("try other ", max_retries, " times")
+            print("sleeping", int(iteration * timeout_retry), "s")
+            print(time.sleep(int(iteration * timeout_retry)))
+            iteration = iteration + 1
+        except Exception as err:
+            response = None
+            max_retries = max_retries - 1
+            print(err)
+            nt = token_counter((prompt + input_text), model)
+            print("Model " + str(model) + " - Length of overall prompt message ", str(nt))
+            print("current iteration ", iteration)
+            print("try other ", max_retries, " times")
+            print("sleeping", int(iteration*timeout_retry), "s")
+            print(time.sleep(int(iteration*timeout_retry)))
+            iteration = iteration + 1
+
+    if (response == None) and (max_retries <= 0):
+        print("\n")
+        print(prompt + input_text)
+        print("\n")
+        print("\nTried many times and did not succeed, there is something strange. Check the problem...exiting now\n")
+        sys.exit()
+
+    return response
+
+def model_list_openai():
+    return openai.Model.list()
+
+
+### GPT@JRC API
+
+def setup_gptjrc_formerOpenAI(token=None):
+    if token is None:
+        token=os.getenv("GPTJRC_TOKEN")
+    openai.organization = ""
+    openai.api_key = token
+    #openai.api_type = "open_ai"
+    openai.api_base = "https://api-gpt.jrc.ec.europa.eu/v1"
+    #
+    print(model_list_gptjrc())
+
+
+def setup_gptjrc(token=None):
+    # if token is None:
+    #     #token=os.getenv("GPTJRC_TOKEN")
+    #     token = os.getenv("OPENAI_API_KEY")
+    #
+    # clientGPTJRC = openai.OpenAI(api_key=token, base_url = "https://api-gpt.jrc.ec.europa.eu/v1")
+
+    all_models = clientGPTJRC.models.list()
+    # for model in all_models:
+    #     print(model.id)
+
+    chat_models = [model for model in all_models.data if model.model_usage == "chat"]
+    print(f"\nGPTJRC - Found {len(chat_models)} chat models:")
+    for model in chat_models:
+        print("   " + str(model.id))
+    embed_models = [model for model in all_models.data if model.model_usage != "chat"]
+
+    print(f"\nGPTJRC - Found {len(chat_models)} embedding models:")
+    for model in embed_models:
+        print("   " + str(model.id))
+
+
+def api_call_gptjrc(prompt: str, input_text: str, model: str, temperature: int, timeout_retry: int=5, delimiter: str = "```", InContextExamples: list[[str]] = [], debug=False,  args: argparse.Namespace=None):
+
+
+    if not (prompt) or prompt.strip=="" or not(input_text) or input_text.strip=="":
+        logging.warning("No text or promt supplied! Skypping it!")
+        return None
+
+    if delimiter and len(delimiter)>0:
+        input_text = delimiter + input_text + delimiter
+
+    response = None
+
+    myMessages = []
+    if InContextExamples:
+        for row in InContextExamples:
+            myMessages.append({"role": "system", "content": prompt})
+            for indCol, colVal in enumerate(row):
+                if indCol == 0:
+                    if delimiter and len(delimiter) > 0:
+                        myMessages.append({"role": "user", "content": (delimiter + colVal + delimiter)})
+                    else:
+                        myMessages.append({"role": "user", "content": colVal})
+                elif indCol == 1:
+                    myMessages.append({"role": "assistant", "content": colVal})
+
+    myMessages.append({"role": "system", "content": prompt})
+    myMessages.append({'role': 'user', 'content': input_text})
+
+
+    max_retries = 50
+    iteration = 1
+    while response is None and max_retries>0:
+        try:
+            # if InContextExamples:
+            #     response = openai.ChatCompletion.create(
+            #         headers={"Authorization": "Bearer " + openai.api_key},
+            #         model=model,
+            #         messages=[
+            #             {"role": "system", "content": prompt},
+            #             {'role': 'user', 'content': InContextExamples[0][0]},
+            #             {'role': 'assistant', 'content': InContextExamples[0][1]},
+            #             {"role": "system", "content": prompt},
+            #             {'role': 'user', 'content': InContextExamples[1][0]},
+            #             {'role': 'assistant', 'content': InContextExamples[1][1]},
+            #             {"role": "system", "content": prompt},
+            #             {'role': 'user', 'content': InContextExamples[2][0]},
+            #             {'role': 'assistant', 'content': InContextExamples[2][1]},
+            #             {"role": "system", "content": prompt},
+            #             {'role': 'user', 'content': input_text},
+            #         ],
+            #         temperature=temperature,
+            #         # max_tokens=4000, #20000, #32000,  #it gives error
+            #         # max_response_tokens=32000 #it gives error
+            #     )
+            # else:
+
+            # former OpenAI call
+            # response = openai.ChatCompletion.create(
+            #     headers={"Authorization": "Bearer "+openai.api_key},
+            #     model=model,
+            #     # messages=[
+            #     #     {"role": "system", "content": prompt},
+            #     #     {'role': 'user', 'content': input_text},
+            #     # ],
+            #     messages=myMessages,
+            #     temperature=temperature,
+            #     #max_tokens=4000, #20000, #32000,  #it gives error
+            #     #max_response_tokens=32000 #it gives error
+            # )
+
+            response = clientGPTJRC.chat.completions.create(
+                model=model,
+                stream=False,
+                # messages=[{"role": "user", "content": "Hello!"}],
+                messages=myMessages,
+                temperature=temperature,
+            )
+
+            #print(response.choices[0].message.content)
+
+        except openai.RateLimitError as e:
+            response = None
+            max_retries = max_retries - 1
+            print(e)
+            nt = token_counter((prompt + input_text), model)
+            print("Model " + str(model) + " - Length of overall prompt message ", str(nt))
+            print("current iteration ", iteration)
+            print("try other ", max_retries, " times")
+            print("sleeping", int(iteration*timeout_retry), "s")
+            print(time.sleep(int(iteration*timeout_retry)))
+            iteration = iteration + 1
+            print("\npromt:")
+            print(prompt)
+            print("\ninput_text:")
+            print(input_text)
+            if max_retries == 45 or max_retries == 40 or max_retries == 35 or max_retries == 30 or max_retries == 25 or max_retries == 20 or max_retries == 15 or max_retries == 10 or max_retries == 5:
+                # input_text = input_text[0:-1000]
+                # input_text = input_text + delimiter
+                #
+                input_text = cleanInputText(input_text)
+                #
+                ntokens = int(token_counter(input_text, model))
+                if ntokens > 1000:  # I split the CONTEXT if it is TOO BIG, BIGGER THAN 1000 tokens let's say
+                    encod = encoding_getter(model)
+                    text_splitter = TokenTextSplitter(
+                        # separators=separators,
+                        encoding_name=encod.name,
+                        chunk_size=int(0.8 * ntokens),
+                        chunk_overlap=50,
+                        length_function=len,
+                        add_start_index=True,
+                    )
+                    texts = text_splitter.create_documents([input_text])
+                    input_text = texts[0].page_content
+                myMessages = []
+                myMessages.append({"role": "system", "content": prompt})
+                myMessages.append({'role': 'user', 'content': input_text})
+        except Exception as err:
+            response = None
+            max_retries = max_retries - 1
+            print(err)
+            nt = token_counter((prompt + input_text), model)
+            print("Model " + str(model) + " - Length of overall prompt message ", str(nt))
+            print("current iteration ", iteration)
+            print("try other ", max_retries, " times")
+            print("sleeping", int(iteration * timeout_retry), "s")
+            print(time.sleep(int(iteration * timeout_retry)))
+            iteration = iteration + 1
+            print("\npromt:")
+            print(prompt)
+            print("\ninput_text:")
+            print(input_text)
+            if max_retries == 45 or max_retries == 40 or max_retries == 35 or max_retries == 30 or max_retries == 25 or max_retries == 20 or max_retries == 15 or max_retries == 10 or max_retries == 5:
+                # input_text = input_text[0:-1000]
+                # input_text = input_text + delimiter
+                #
+                input_text = cleanInputText(input_text)
+                #
+                ntokens = int(token_counter(input_text, model))
+                if ntokens > 1000:  # I split the CONTEXT if it is TOO BIG, BIGGER THAN 1000 tokens let's say
+                    encod = encoding_getter(model)
+                    text_splitter = TokenTextSplitter(
+                        # separators=separators,
+                        encoding_name=encod.name,
+                        chunk_size=int(0.8 * ntokens),
+                        chunk_overlap=50,
+                        length_function=len,
+                        add_start_index=True,
+                    )
+                    texts = text_splitter.create_documents([input_text])
+                    input_text = texts[0].page_content
+                myMessages = []
+                myMessages.append({"role": "system", "content": prompt})
+                myMessages.append({'role': 'user', 'content': input_text})
+
+
+    if (response == None) and (max_retries <= 0):
+        print("\n")
+        print(prompt + input_text)
+        print("\n")
+        print("\nTried many times and did not succeed, there is something strange. Check the problem...exiting now\n")
+        sys.exit()
+
+    return response
+
+
+
+def model_list_gptjrc():
+    return openai.Model.list()
+
+
+### DGLC API
+
+def clean_gpt_out(output_text :str):
+
+    if "From the text below, delimited by triple quotes, extract the following items: 1 - The name of the virus that has caused the outbreak" in output_text:
+        print("debug")
+
+    if "<|assistant|>" in output_text:
+        output_text = output_text.split("<|assistant|>")[0].strip()
+    if "<|prompt|>" in output_text:
+        output_text = output_text.split("<|prompt|>")[0].strip()
+    if "<|prompter|>" in output_text:
+        output_text = output_text.split("<|prompter|>")[0].strip()
+    if "<|answer|>" in output_text:
+        output_text = output_text.split("<|answer|>")[0].strip()
+    if "<|im_end|>" in output_text:
+        output_text = output_text.split("<|im_end|>")[0].strip()
+    if "<|endofextract|>" in output_text:
+        output_text = output_text.split("<|endofextract|>")[0].strip()
+    if "<br>" in output_text:
+        output_text = output_text.split("<br>")[0].strip()
+
+    if "<|/assistant|>" in output_text:
+        output_text = output_text.split("<|/assistant|>")[0].strip()
+    if "<|/prompt|>" in output_text:
+        output_text = output_text.split("<|/prompt|>")[0].strip()
+    if "<|/prompter|>" in output_text:
+        output_text = output_text.split("<|/prompter|>")[0].strip()
+    if "<|/answer|>" in output_text:
+        output_text = output_text.split("<|/answer|>")[0].strip()
+    if "<|/im_end|>" in output_text:
+        output_text = output_text.split("<|/im_end|>")[0].strip()
+    if "<|/endofextract|>" in output_text:
+        output_text = output_text.split("<|/endofextract|>")[0].strip()
+    if "</br>" in output_text:
+        output_text = output_text.split("</br>")[0].strip()
+
+    if "</|assistant|>" in output_text:
+        output_text = output_text.split("</|assistant|>")[0].strip()
+    if "</|prompt|>" in output_text:
+        output_text = output_text.split("</|prompt|>")[0].strip()
+    if "</|prompter|>" in output_text:
+        output_text = output_text.split("</|prompter|>")[0].strip()
+    if "</|answer|>" in output_text:
+        output_text = output_text.split("</|answer|>")[0].strip()
+    if "</|im_end|>" in output_text:
+        output_text = output_text.split("</|im_end|>")[0].strip()
+    if "</|endofextract|>" in output_text:
+        output_text = output_text.split("</|endofextract|>")[0].strip()
+
+    while "```" in output_text:
+        output_text = output_text.replace("```", " ")
+
+    while "  " in output_text:
+        output_text = output_text.replace("  ", " ")
+
+    return output_text
+
+
+# def setup_dglc(key=None):
+#     if key is None:
+#         ACCESS_KEY = os.getenv("DGL_TOKEN")
+#     else:
+#         ACCESS_KEY=key
+#
+#     client_dglc.login(ACCESS_KEY)
+#
+#     #list available models
+#     models_available = model_list_dglc()
+#     print("DGLC - available models = "+str(models_available))
+#
+#     # chat_id = client_dglc.create_chat()
+#     # # Or continue the previous one
+#     # # chat_id = client_dglc.continue_chat(args.chat_id)
+#     # print("\nCHAT_ID dglc", chat_id)
+
+
+# def api_call_dglc(prompt: str, input_text: str, model: str, temperature: float, timeout_retry: int =5, delimiter: str = "```", InContextExamples: list[[str]] = [], debug=False,  args: argparse.Namespace=None):
+#
+#     # if model == "gpt-3.5-turbo":
+#     #     model = "OA_GPT3.5"
+#
+#
+#     if not(input_text) or input_text.strip=="" or not(prompt) or prompt.strip=="":
+#         logging.warning("No text or promt supplied! Skypping it!")
+#         return None
+#
+#     message = ""
+#     if InContextExamples:
+#         for row in InContextExamples:
+#             message = message + prompt
+#             for indCol, colVal in enumerate(row):
+#                 if indCol == 0:
+#                     if delimiter and len(delimiter) > 0:
+#                         message = message + delimiter + colVal + delimiter
+#                     else:
+#                         message = message + colVal
+#                 elif indCol == 1:
+#                     message = message + " \n" + colVal + " \n"
+#
+#     if delimiter and len(delimiter) > 0:
+#         message = prompt + delimiter + input_text + delimiter
+#     else:
+#         message = prompt + "\n" + input_text
+#
+#     if debug:
+#         print("\n")
+#         print(message)
+#
+#     chat_id = client_dglc.create_chat()
+#     # Or continue the previous one
+#     # chat_id = client.continue_chat(args.chat_id)
+#     if debug:
+#         print("\nCHAT_ID dglc", chat_id)
+#
+#     try:
+#         events = client_dglc.send_message(message, model, temp=temperature)
+#     except Exception as err:
+#         logging.error(f'FAILED api_call_dglc WITH MESSAGE: \'{message}\' \nMODEL: {model}; \n\tError: {err}')
+#
+#     events= None
+#     max_retries = 50
+#     iteration = 1
+#     while events is None and max_retries > 0:
+#         try:
+#             events = client_dglc.send_message(message, model, temp=temperature)
+#         except Exception as err:
+#             events = None
+#             max_retries = max_retries - 1
+#             print(err)
+#             nt = token_counter((message), model)
+#             print("Model " + str(model) + " - Length of overall prompt message ", str(nt))
+#             print("current iteration ", iteration)
+#             print("try other ", max_retries, " times")
+#             print("sleeping", int(iteration * timeout_retry), "s")
+#             print(time.sleep(int(iteration * timeout_retry)))
+#             iteration = iteration + 1
+#
+#     if (events == None) and (max_retries <= 0):
+#         print("\n")
+#         print(message)
+#         print("\n")
+#         print("\nTried many times and did not succeed, there is something strange. Check the problem...exiting now\n")
+#         sys.exit()
+#
+#     if events:
+#         event = [str(x) for x in events]
+#         # The message is streamed token by token
+#         # for event in events:
+#         #    print(event, end="", flush=True)
+#         if event:
+#             event = event[-1]
+#         else:
+#             event = None
+#
+#         if debug:
+#             print("\nAPI CALL ANSWER:")
+#             print(event)
+#             print("\n")
+#
+#     else:
+#         event = None
+#
+#     return event
+
+# def model_list_dglc():
+#     return client_dglc.get_available_models()
+
+
+### CALLING MODELS
+
+
+def call_model_with_caching(input_text: str, prompt: str, model: str, temperature: int, handler,
+                            map_query_input_output: dict, cache_fp: str, timeout_retry: int =5, delimiter: str = "```", InContextExamples: list[[str]] = [], verbose: bool = True, args: argparse.Namespace=None):
+    """ call openai's API but take care of caching of results
+    input_text: input text
+    prompt: prompt
+    model: model name (as parameter of the query)
+    temperature: temperature (0: precise, 1: creative)
+    handler: delegate function that will make the call (not necessarily only OpenAI, could be any one)
+    map_query_input_output: cache dict containing already processed data
+    cache_fp: file to which write content of cache after each call
+    """
+
+    if not(input_text) or input_text.strip=="" or not(prompt) or prompt.strip=="":
+        logging.warning("No text or promt supplied! Skypping it!")
+        return None
+
+    # try to read cache
+
+    if map_query_input_output is not None:
+        key = model + "__" + str(temperature) + "__" + prompt
+
+        if key in map_query_input_output:
+            if input_text in map_query_input_output[key]:
+                output = map_query_input_output[key][input_text]
+                # if input_text.strip() == "":
+                #     print("here")
+
+                # if handler == api_call_dglc:
+                #     output = clean_gpt_out(output) #clean output
+
+                if verbose:
+                    print("RETRIEVED CACHED RESULT FOR:\n", prompt, "\n", delimiter, input_text, delimiter, "\n=>\n", output, "\n")
+
+                return output
+
+    #  call
+
+    response = None
+
+    try:
+        response = handler(prompt, input_text, model, temperature, timeout_retry, delimiter, InContextExamples, args=args)
+    except Exception as err:
+        logging.error(f'FAILED WITH PROMPT: \'{prompt}\' \nLEN_TEXT: {len(input_text)}, \nTEXT: {(input_text)}, \nMODEL: {model}; \n\tError: {err}')
+    #else:
+    #    # logging.warning(f'INDEX: \'{SOURCE_INDEX}\' Inserted {inserted} rows out of {num_lines} rows [{round((inserted/num_lines)*100, 2)}%]')
+    #    break
+
+    if response:
+        if isinstance(response, str):
+            output_text = response
+        else:
+            #output_text = response['choices'][0]['message']['content']
+            output_text = response.choices[0].message.content
+
+            # if handler == api_call_dglc:
+        #     output_text = clean_gpt_out(output_text)  # clean output
+
+
+        # write to cache
+
+        if map_query_input_output is not None:
+            if not key in map_query_input_output:
+                map_query_input_output[key] = {}
+
+            if output_text:
+                if output_text != "":
+                    map_query_input_output[key][input_text] = output_text
+
+                    with open(cache_fp, "w") as f:
+                        json.dump(map_query_input_output, f)
+
+        if verbose:
+            print("API CALL REPLY FOR:\n", prompt, "\n", delimiter, input_text, delimiter, "\n=>\n", output_text, "\n")
+
+        return output_text
+
+    else:
+        return None
+
+
+def call_model(input_text: str, prompt: str, model: str, temperature: int, handler, timeout_retry: int =5, delimiter: str = "```", InContextExamples: list[[str]] = [],
+               verbose: bool = True, args: argparse.Namespace=None):
+    """ call openai's API but take care of caching of resuts
+    input_text: input text
+    prompt: prompt
+    model: model name (as parameter of the query)
+    temperature: temperature (0: precise, 1: creative)
+    handler: delegate function that will make the call (not necessarily only OpenAI, could be any one)
+    """
+
+
+    if not(input_text) or input_text.strip=="" or not(prompt) or prompt.strip=="":
+        logging.warning("No text or promt supplied! Skypping it!")
+        return None
+
+    return call_model_with_caching(input_text, prompt, model, temperature, handler, None, None, timeout_retry, delimiter, InContextExamples, verbose, args=args)
+
+
+
+def process_list(list_input_text: list[str], prompt: str, service_provider: str, model: str, temperature: int,
+                 cache_prefix_fp: str = None, delimiter: str = "```", InContextExamples: list[[str]] = [], args: argparse.Namespace=None):
+    """ process a list of text with a prompt and a model
+    list_input_text: list input text
+    prompt: prompt
+    service provide: either "openai" or "dglc" for the moment
+    model: model name (as parameter of the query)
+    temperature: temperature (0: precise, 1: creative)
+    cache_prefix_fp: prefix of the file to which write content of cache after each call
+    """
+
+    if cache_prefix_fp is not None:
+        cache_fp = cache_prefix_fp + "___" + "__".join([service_provider, model, str(temperature)]).replace(" ", "_") + ".json"
+
+        if os.path.exists(cache_fp):
+            with open(cache_fp) as f:
+                map_query_input_output = json.load(f)
+        else:
+            map_query_input_output = {}
+    else:
+        map_query_input_output = None
+        cache_fp = None
+
+    handler = None
+    #if service_provider.lower() == "dglc": handler = api_call_dglc
+    if service_provider.lower() == "openai": handler = api_call_openai
+    if service_provider.lower() == "gptjrc": handler = api_call_gptjrc
+    #if service_provider.lower() == "hfonpremises": handler = api_call_HFonPremises
+
+    list_output_text = []
+    for input_text in tqdm(list_input_text):
+        output_text = call_model_with_caching(input_text, prompt, model, temperature, handler, map_query_input_output,
+                                              cache_fp, delimiter=delimiter, InContextExamples=InContextExamples, args=args)
+        list_output_text.append(output_text)
+
+    return list_output_text
+
+
+
+
+if __name__ == "__main__":
+
+    USE_CACHE = False #True #False
+
+    #service_provider = "openai"
+    #model_name = "gpt-3.5-turbo-16k"
+    #
+    #
+    #service_provider = "dglc"
+    # dglc available models: 'OA_SFT_Pythia_12B', 'JRC_RHLF_13B', 'OA_GPT3.5', 'OA_GPT3'
+    # model_name = "gpt-3.5-turbo"  #OpenAI name
+    # model_name = 'JRC_RHLF_13B'
+    #model_name = "OA_SFT_Pythia_12B"   #EleutherAI-pythia-12b
+    # model_name = "OA_GPT3"
+    # model_name = "GPT@JRC_4"
+    #
+    #
+    #service_provider = "gptjrc"
+    #model_name = "gpt-35-turbo-0613"
+    #model_name = "gpt-35-turbo-16k"
+    #model_name = "gpt-4-32k"  #GPT-4 with a context length of 32,768 tokens -  around 116000
+    service_provider = "HFonPremises"
+
+    #model_name = "llama-3.1-70b-instruct"
+    #model_name = "llama-3.1-70b-instruct"
+
+    #model_name="nous-hermes-2-mixtral-8x7b-dpo"
+    #model_name = "nous-hermes-2-mixtral-8x7b-dpo"
+
+    #model_name="llama-3.1-8b-instruct"
+    #model_name = "llama-3.1-8b-instruct"
+    model_name = "llama-3.1-70b-instruct"
+
+    # temperature: temperature_value (0: precise, 1: creative)
+    temperature_value = 0.01  # 0.1
+
+    ##################################################################################################
+
+    #OpenAI ChatGPT API
+    if service_provider == "openai":
+        MyOpenAPIKey = ""
+        fkeyname="OpenAI-DigLifeAccount-APItoken.key"
+        if os.path.exists(fkeyname):
+            with open(fkeyname) as f:
+                MyOpenAPIKey = f.read()
+        else:
+            MyOpenAPIKey = os.environ['key_MyOpenAPI']
+        setup_openai(key=MyOpenAPIKey)
+
+    # # test api call
+    # r = api_call_openai("say hello world", "you will answer in Spanish", "gpt-3.5-turbo", 0)
+    # print(r)
+
+    # # test process list
+    # r = process_list(["hello world", "hello everybody"], "you will translate to Spanish", "openai", "gpt-3.5-turbo", 0)
+    # print(r)
+
+    # # process list with caching
+    # r = process_list(["hello world", "hello everybody"], "you will translate to Spanish", "openai", "gpt-3.5-turbo", 0, "UNITTEST")
+    # print(r)
+
+    #### GPT@JRC API
+    if service_provider == "gptjrc":
+        key_gptjrc = ""
+        fkeyname = "GPTJRC-APItoken.key"
+        if os.path.exists(fkeyname):
+            with open(fkeyname) as f:
+                key_gptjrc = f.read()
+        else:
+            key_gptjrc = os.environ['key_gptjrc']
+
+        os.environ['OPENAI_API_KEY'] = key_gptjrc
+        #setup_gptjrc(key_gptjrc)
+        setup_gptjrc()
+
+
+    #### DGLC API
+    if service_provider == "dglc":
+        key_dglc = ""
+        fkeyname = "DGLC-APItoken.key"
+        if os.path.exists(fkeyname):
+            with open(fkeyname) as f:
+                key_dglc = f.read()
+        else:
+            key_dglc = os.environ['key_dglc']
+        # setup_dglc(key=key_dglc)
+
+    # TEST OF DGLC API CALL
+    # input_text = "this morning a rabbit killed a hunter"
+    # print("\ntext = \n"+input_text)
+    # prompt = "please reformulate the text, add more details, the text should be between 200 and 500 characters:"
+    # print("\nquestion = \n" + prompt)
+    # model= "OA_SFT_Pythia_12B" #not available in OpenAI
+    # print("\nmodel = \n" + model)
+    # print("\n")
+    #
+    # r = api_call_dglc(prompt, input_text, model, 0.5)
+    # if r:
+    #     print(r)
+    #
+    # print("\nDone!\n")
+
+
+    ###########################################################################
+
+
+    if USE_CACHE:
+        # cache_prefix_fp: prefix of the file to which write content of cache after each call
+        cache_prefix_fp = "LLMQUERYTEST"
+        cache_name = cache_prefix_fp + "___" + "__".join([service_provider, model_name, str(temperature_value)]).replace(" ", "_") + ".json"
+
+        if os.path.exists(cache_name):
+            with open(cache_name) as f:
+                load_map_query_input_output = json.load(f)
+        else:
+            load_map_query_input_output = {}
+
+    myPromt = f"""
+        translate in Spanish the text below, delimited by triple  \
+        Text: 
+        """
+
+    myDelimiter = "```"
+
+    ###
+
+    #example for counting number of tokens of the overall prompt for the model
+
+    # input_text = "one, two, three, a step fortward Mary"
+    # overall_string = myPromt + myDelimiter + input_text + myDelimiter
+    # nt = token_counter(overall_string, model_name)
+    # print("\nNumber of Tokens in the example = "+str(nt))
+
+    encod = encoding_getter(model_name)
+    print("\nencodName = " + str(encod.name))
+
+    InContextExamples = []
+    # InContextExamples = [["ADENOVIRUS - USA (02): (NEW JERSEY) UPDATE A ProMED-mail post http://www.promedmail.org ProMED-mail is a program of the International Society for Infectious Diseases http://www.isid.org Date: Sun 28 Oct 2018 3:12 PM Source: CBS news [edited] https://www.cbsnews.com/news/adenovirus-outbreak-new-jersey-wanaque-center- facility-9th-child-dies-2018-10-28/ Another child has died amid a deadly virus outbreak at a New Jersey rehabilitation, bringing the total number of deaths to 9, officials said [Sun 28 Oct 2018]. The state\'s Department of Health said the victim was a \"medically fragile\" child who had a confirmed case of adenovirus. The unidentified child died Saturday evening [27 Oct 2018] at the Wanaque Center for Nursing and Rehabilitation in Haskell, the department said. There have been 25 cases associated with the outbreak. \"This is a tragic situation, and our thoughts are with the families who are grieving right now,\" Health Commissioner Dr Shereef Elnahal said in a statement. \"We are working every day to ensure all infection control protocols are continuously followed and closely monitoring the situation at the facility.\" Adenoviruses are a family of viruses that account for about 5 to 10 percent of fevers in young children, but most patients recover. The infections can affect the tissue linings of the respiratory tract, eyes, intestines, urinary tract and nervous system, causing illnesses ranging from a cold to bronchitis to pneumonia to pink eye. The children at Wanaque appear to have been more susceptible to serious infections due to their other medical conditions. Children at the center are severely disabled, with some living in comas, and for many, it is their permanent home, the Bergen Record reports. Many will never walk or talk, and some have spent virtually their whole lives there, according to the paper. . Communicated by: ProMED-mail Rapporteur Kunihiko Iizuka [Human adenoviruses (HAdVs) are non-enveloped, linear double-stranded DNA viruses encapsidated within a protein shell and have been categorized into 6 species (A-F) that contain 51 immunologically distinct serotypes (Fields virology. 5th ed. Philadelphia (PA): Lippincott-Raven; 2007. p. 2395-436). HAdVs most commonly cause acute respiratory disease; however, depending on the infecting HAdV serotype and tropism resulting from differential host receptor use, the wide variety of symptoms can include pneumonia, febrile upper respiratory illness, conjunctivitis, cystitis, and gastroenteritis (Principles and practice of infectious diseases. 5th ed. Vol 2. Philadelphia (PA): Churchill Livingstone; 2005. p. 1835-41). The severity of disease appears dependent on the immunocompetence and cardiopulmonary health of the host, and the spectrum of disease can range from subclinical to severe respiratory distress and death. Immunocompromised patients (such as bone marrow transplant recipients) are particularly susceptible to HAdV infection, resulting in severe illness and deaths, whereas illness in immunocompetent patients generally resolves without major complication. The outbreak report above involves young children that are in a healthcare facility and immunocompromised on account of underlying co- morbid conditions. Adenovirus associated morbidity and mortality in this setting would require intensive infection control measures. In immunocompromised patients, several drugs, such as cidofovir, ribavirin, ganciclovir, and vidarabine, have been used to treat adenovirus infections. Most of these agents are virostatic, may induce drug resistance, and have significant risks of toxicities, as well as risks to healthcare staff [e.g., aerosolized ribavirin - Mod.ML]. - Mod.UBA HealthMap/ProMED map available at: New Jersey, United States: https://promedmail.org/promed-post?place=6117463,232 ] See Also Adenovirus - USA: (NJ) children, fatal 20181025.6108470 .uba/mj/ml",
+    #                          "{\"virus\": \"ADENOVIRUS\", \"country\": \"USA\", \"date\": \"2018-10-28\", \"cases\": \"25\", \"deaths\": \"9\"}"],
+    #                      ["NIPAH VIRUS - INDIA (14): (KERALA) * A ProMED-mail post http://www.promedmail.org ProMED-mail is a program of the International Society for Infectious Diseases http://www.isid.org Date: Tue 3 Jul 2018 Source: MediBulletin [edited] https://medibulletin.com/2018/07/03/bats-indicted-in-kerala-nipah-outbreak- icmr-sends-paper-to-lancet/ Putting to rest suspense about the source of the Nipah virus infections in Kerala, scientists from the Indian Council of Medical Research have now found the virus in bats that were caught from the affected areas. At least 17 people died of Nipah infection in Mallapuram and Kozhikode districts of Kerala over April and May [2018]. While the 1st batch of bats caught from the well in Kozhikode in the house from where the 1st case was reported, had tested negative; of the 2nd batch of 52 fruit bats, 19.2 percent were found to carry the virus. The findings will be published in The Lancet. Health minister J P Nadda was informed about the findings in a meeting last week. In the meeting, scientists from ICMR and public health officials also told the minister that circumstances have now improved enough for the state to be declared Nipah free. The incubation period of Nipah is 5 to 14 days. The last case was in May [2018] and now that 2 incubation periods have elapsed without any fresh cases, the specter of the dreaded disease seems to be finally receding. . Communicated by: ProMED-mail <[email protected]> [It is good to learn that there have been no additional cases of Nipah virus infection in Kerala. As was mentioned earlier, it is not surprising that the bats taken from the well were negative for the virus. Giant fruit bats (flying foxes genus _Pteropus_), the reservoir of Nipah virus in Bangladesh and Malaysia, do not roost in wells. They roost in tree tops. The species sampled in the 2nd batch of bats was not mentioned, but were likely flying foxes. It is fortunate that virus positive bats were found in this 2nd sampling. As commented earlier, bats \"may only be infectious for a week or 2, and then they clear the virus and they\'re no longer infectious,\" said Jonathan Epstein, a veterinarian and epidemiologist at EcoHealth Alliance, New York, who has, for over a decade, studied Nipah outbreaks and the bats that cause them, in Malaysia, India and Bangladesh. \"That\'s why these outbreaks are relatively rare events, given the fact that these bats are so abundant and so common but very few of them are ever actually shedding virus at a given time.\" Epstein and others conducted an experimental study of _Pteropus_ bats in 2011 and found that the time window in which the bats are capable of passing on the infection to other animals or humans is quite small. In fact, the virus can\'t be found in experimentally infected bats after a few weeks. The few bats in an infected population that could be shedding the virus may be doing so in low quantities and for a short duration. \"Finding that bats don\'t have Nipah virus at the time of sampling certainly doesn\'t mean that it didn\'t come from those bats, particularly _P. medius_,\" Epstein said. \"The overwhelming abundance of evidence really shows that this bat is the reservoir for Nipah virus on the subcontinent in Bangladesh and in India.\" - Mod.TY Maps of India can be accessed at: http://www.mapsofindia.com/maps/india/india-political-map.htm HealthMap/ProMED map available at: Kerala State, India: https://promedmail.org/promed-post?place=5887151,308 ] See Also Nipah virus - India (13): (KL) 20180611.5851326 Nipah virus - India (12) 20180603.5836554 Nipah virus - India (11): (KL) 20180602.5835342 Nipah virus - India (10): (KL) 20180602.5833137 Nipah virus - India (09): (WB ex KL) susp. 20180530.5829184 Nipah virus - India (08): (KR ex KL) susp. 20180529.5826769 Nipah virus - India (07) 20180528.5822566 Nipah virus - India (06): (KL,KA) 20180526.5819777 Nipah virus - India (05): (KL,TG) 20180525.5817917 Nipah virus - India (04): (KL, KA) 20180524.5815473 Nipah virus - India (03): (KL) conf. 20180522.5812214 Nipah virus - India (02): (KL) conf 20180521.5809003 Nipah virus - India: (KL) susp 20180521.5807513 2007 . Nipah virus, fatal - India (West Bengal) (02) 20070511.1514 Nipah virus, fatal - India (West Bengal) 20070508.1484 Undiagnosed deaths - Bangladesh, India (04) 20070504.1451 .ty/ao/jh",
+    #                          "{\"virus\": \"Nipah virus\", \"country\": \"India\", \"date\": \"2018-07-03\", \"cases\": \"None\", \"deaths\": \"17\"}"],
+    #                      ["UNDIAGNOSED RESPIRATORY ILLNESS - USA: (NEW YORK), ex MIDDLE EAST, FLIGHT PASSENGERS AND CREW, REQUEST FOR INFORMATION * A ProMED-mail post http://www.promedmail.org ProMED-mail is a program of the International Society for Infectious Diseases http://www.isid.org [1] Date: Wed 5 Sep 2018 Source: Stat News [edited] https://www.statnews.com/2018/09/05/plane-quarantined-at-kennedy-airport-amid- reports-of-100-ill-passengers/ An Emirates Airline flight was held in quarantine for a period at New York\'s John F. Kennedy International Airport after a large number of passengers were reported feeling ill during the flight. The airline said in a statement that about 10 passengers on the flight from Dubai to New York had become ill on board. But the Centers for Disease Control and Prevention [CDC] said the estimated number was about 100. Passengers and some crew complained of illness including cough, according to the CDC; some had developed a fever. \"CDC public health officers are working with port authority, EMS, and CBP officials to evaluate passengers including taking temperatures and making arrangements for transport to local hospitals,\" the CDC said. \"Passengers who are not ill will be allowed to continue with their travel plans, and if necessary will be followed up with by health officials.\" A spokesman for New York Mayor Bill de Blasio said 19 passengers had taken ill - 10 were sent to a hospital and another 9 refused medical attention. There were approximately 521 passengers on the flight. A number of the passengers on the flight were returning from the Hajj, the annual mass pilgrimage to Mecca, in Saudi Arabia, a source told STAT. It was unclear if the people who were ill were the same passengers who had attended. Saudi Arabia has reported cases of MERS, Middle East respiratory syndrome, which passes to people from camels. But the fact that so many people became ill during the flight would make MERS seem an unlikely cause. [Byline: Helen Branswell] . Communicated by: Meghan May University of New England <[email protected]> [2] Date: Wed 5 Sep 2018 Source: BBC [edited] https://www.bbc.com/news/world-us-canada-45425412 A total of 19 people have been taken ill after an Emirates airline plane landed in New York, officials say. The plane was quarantined at JFK airport as those on board were checked by health officials. As many as 10 were taken to hospital but others refused treatment. The US Centers for Disease Control and Prevention (CDC) said that initially about 100 people including some crew had complained of illness. Flight 203 from Dubai landed at 09:10 (13.10 GMT) with 521 passengers. Emergency vehicles were seen on the runway as it landed. Soon afterwards, Emirates airline tweeted that the sick passengers were being attended to and those who were unaffected would be allowed to leave the plane. The CDC said in a statement that is was \"aware of an Emirates flight from Dubai that arrived this morning at JFK\". \"Approximately 100 passengers, including some crew on the flight, complained of illness including cough and some with fever. \"CDC public health officers are working with. officials to evaluate passengers including taking temperatures and making arrangements for transport to local hospitals those that need care.\" Later Eric Phillips, spokesman for New York Mayor Bill de Blasio, confirmed that all the passengers were off the plane and the sick people had been taken to hospital. He said that some of the passengers had originally come from the Saudi Arabian city of Mecca, which was currently experiencing a flu outbreak, and that the passengers\' symptoms were \"pointing to the flu\". . Communicated by: ProMED-mail <[email protected]> [3] Date: Wed 5 Sep 2018, 10:55 AM ET Source: NPR [edited] https://www.npr.org/2018/09/05/644826743/emirates-airline-says- about-10-passengers-fell-ill-on-flight-to-new-york Health and safety officials are investigating an illness that struck people on an Emirates Airline flight from Dubai, United Arab Emirates, to New York\'s John F. Kennedy International Airport on Wednesday morning. A total of 7 crew members and 3 passengers were taken to the hospital, Emirates Airline said. It added that [Wed 5 Sep 2018] return flight from New York to Dubai would leave 3 hours late. The Centers for Disease Control and Prevention said around 100 people on the overnight Flight 203 had complained of illness. For some, the symptoms were limited to a cough; others had a fever. An Emirates A380 in quarantine at JFK Airport right now awaiting CDC officials after about 100 passengers became ill with fevers over 100 degrees and coughing. Flight 203 had just arrived from Dubai. Ten people were taken off the plane for treatment at Jamaica Hospital Medical Center, said Eric Phillips, press secretary for New York City Mayor Bill de Blasio. He said 9 others were found to be sick but refused medical attention. The aircraft was carrying around 521 passengers. Health officials allowed people to disembark only after checking each one for symptoms, Phillips stated, adding, \"The plane\'s been quarantined and the CDC is on the scene.\" As for what the sickness might be, Phillips referred to a \"flu outbreak\" in Mecca, Saudi Arabia, and said that might be a possibility, stating, \"It appears some of the ill passengers came from Mecca before getting on in Dubai.\" [One] passenger called it the \"worst flight ever,\" saying on Twitter that the plane \"was basically a flying infirmary. Many of these people should never have been allowed to board.\" By around noon, 432 passengers had been cleared and allowed to go to the customs area, according to Phillips. A few others who showed symptoms were held for treatment and possible transport to the hospital. NPR\'s Rob Stein reports that the Centers for Disease Control and Prevention is working with local authorities. The Airbus A380 jet was isolated on the tarmac at JFK, as officials took stock of the situation. Images from the scene showed a row of ambulances alongside the aircraft. [Another] passenger said via Twitter that CDC staff came onto the plane and that everyone aboard was asked to fill out a form providing their contact information for the next 3 weeks. [Byline: Bill Chappell] . Communicated by: ProMED-mail <[email protected]> [Mention a plane load of individuals with febrile respiratory symptoms coming from the Middle East and immediate panic of \"could this be MERS-CoV?\" Equally or more serious than this is an outbreak of influenza. According to the media coverage, there is an ongoing outbreak of influenza in Mecca (Makkah) (Saudi Arabia, where Hajji\'s congregate) now, concurrent with the Hajj, and a rapid onset of respiratory symptoms is more likely to be influenza than it is MERS- CoV. We still do not have information as to the origins of the ill passengers to know if they were beginning their trips in Mecca and were returning Hajji\'s or if they began their travels elsewhere. Presumably the crew members began their working journeys in Dubai, but may have commuted in from elsewhere in or outside of the region (and there is mention of ill crew members). Returning to the possibility that this is related to the Hajj, a mass gathering of more than 2 million individuals from all over the world, making a religious pilgrimage to Mecca, it is interesting to review the Saudi Hajj/Umrah health requirements. While some vaccines are mandatory (meningitis vaccine, polio if coming from a country with ongoing poliovirus transmission, and yellow fever if coming from a known yellow fever endemic area, in contrast, influenza vaccine is recommended but not obligatory. \"Seasonal Influenza: \"The Saudi Ministry of Health recommends that international pilgrims be vaccinated against seasonal influenza before arrival into the Kingdom of Saudi Arabia, particularly those at increased risk of severe influenza diseases, including pregnant women, children under 5 years, the elderly, and individuals with underlying health conditions such as HIV/AIDS, asthma, and chronic heart or lung diseases. In Saudi Arabia, seasonal influenza vaccination is recommended for internal pilgrims, particularly those at risk described above, and all health-care workers in the Hajj premises.\" https://www.saudiembassy.net/hajj-and-umrah-health-requirements Given concerns re: possible MERS-CoV transmission to pilgrims visiting Saudi Arabia, many countries have increased surveillance of respiratory illnesses in returning pilgrims (notably post Hajj), and in the 6 years since identification of the MERS-CoV, there have been no cases among returning Hajji\'s and just a handful of cases among individuals returning from having performed the Umrah pilgrimage. Movement and exposures of visiting Hajj pilgrims are controlled - camels are not permitted in the area where Hajjis are congregated, healthcare workers and others identified as contacts of confirmed MERS-CoV cases are not permitted to go to the Hajj area Studies addressing the etiologies of respiratory illnesses in returning Hajji\'s have identified influenza virus, respiratory syncytial virus, parainfluenza virus, adenovirus and rhinovirus (see Respiratory infections - UK: Hajj returnees 20151011.3706464 and Respiratory virus infections - Saudi Arabia: Hajj pilgrims 2012 20130730.1854631 ). Note that the incubation period for influenza ranges from 1-4 days so transmission during travel is a plausible event. The actual number of individual identified as ill enough to require medical treatment at a hospital seems to be between 19 and 27 (taking into account the additional 8 identified and mentioned by the New York City\'s mayor\'s spokesperson in a tweet). Presumably these individuals had a fever above 100 F (37.8 C) and cough. The extension of the count to approaching 100 individuals may include those with a cough, possibly in the early stages of illness (influenza frequently begins with a dry cough), and others possibly coughing in response to hearing others coughing around them (think theater or lectures when coughing begins.) As the rapid respiratory virus screening tests should be available in a reasonable amount of time, we will post information as it becomes available, but should any knowledgeable sources have additional information that can be shared with us, ProMED would be very grateful. The HealthMap/ProMED maps can be found at: New York State, United States: https://promedmail.org/promed-post?place=6009759,234 Middle East: https://promedmail.org/promed-post?place=6009759,12214 . Mod.MPP] See Also MERS-CoV (29): UK (England) ex Saudi Arabia, Risk Assessment ECDC 20180830.5996187 2017 . MERS-CoV (63): Saudi Arabia (QS, TB), WHO : 20171009.5369268 2016 . Health hazards - Saudi Arabia: Hajj, Umrah, vaccination requirements 20160715.4346367 MERS-CoV (71): Saudi Arabia (MK), pilgrimage caution, WHO 20160623.4305152 2015 . MERS-CoV (138): Saudi Arabia, Jordan, post Hajj surveillance, RFI 20151009.3704734 MERS-CoV (136): Kuwait WHO, Saudi Arabia MOH, camel, Hajj 20150924.3666811 MERS-CoV (131): Saudi Arabia, animal reservoir, camels, Hajj, RFI 20150914.3643612 MERS-CoV (130): Saudi Arabia, animal reservoir, camels, Hajj 20150912.3641457 MERS-CoV (114): Saudi Arabia, animal reservoir, camels, Hajj 20150823.3597358 Respiratory infections - UK: Hajj returnees 20151011.3706464 Respiratory infections - Canada: (AB) Hajj returnees 20151020.3729641 Influenza (51): Germany ex Saudi Arabia, Hajj returnee, RFI 20151009.3704297 Influenza (49): Canada ex Saudi Arabia, Hajj returnees, susp., RFI, Alert 20151005.3693052 2014 . Meningitis, meningococcal - Saudi Arabia: prevention, Hajj travel advice 20140815.2692227 2013 . Respiratory virus infections - Saudi Arabia: Hajj pilgrims 2012 20130730.1854631 2012 . Health hazards - Saudi Arabia: updated Hajj advice 20121011.1338172 2009 . Influenza pandemic (H1N1) 2009 (113): Saudi Arabia, Hajj fatalities 20091122.4013 Influenza pandemic (H1N1) 2009 (109): Saudi Arabia, Hajj pilgrims 20091120.3997 2006 . Influenza - Saudi Arabia: Hajj concerns 20061209.3478 .mpp/ao/mpp",
+    #                          "{\"virus\": \"None\", \"country\": \"United Arab Emirates\", \"date\": \"2018-09-05\", \"cases\": \"19\", \"deaths\": \"None\"}"]]
+
+    if InContextExamples:
+        ntotExamplesTokens = 0
+        for row in InContextExamples:
+            for col in row:
+                nt = token_counter(col, model_name)
+                #print("\nNumber of Tokens in the example = " + str(nt))
+                ntotExamplesTokens = ntotExamplesTokens + nt
+        #
+        print("\nNumber of Tokens of the all examples = " + str(ntotExamplesTokens))
+
+    ###
+
+    if service_provider == "openai":
+        if USE_CACHE:
+            lambda_model = partial(call_model_with_caching, prompt=myPromt, model=model_name,
+                                   temperature=temperature_value, delimiter=myDelimiter, InContextExamples=InContextExamples, handler=api_call_openai,
+                                   map_query_input_output=load_map_query_input_output, cache_fp=cache_name, verbose=True)
+        else:
+            lambda_model = partial(call_model, prompt=myPromt, model=model_name,
+                                   temperature=temperature_value, delimiter=myDelimiter, InContextExamples=InContextExamples, handler=api_call_openai,
+                                   verbose=True)
+    elif service_provider == "gptjrc":
+        if USE_CACHE:
+            lambda_model = partial(call_model_with_caching, prompt=myPromt, model=model_name,
+                                   temperature=temperature_value, delimiter=myDelimiter, InContextExamples=InContextExamples, handler=api_call_gptjrc,
+                                   map_query_input_output=load_map_query_input_output, cache_fp=cache_name, verbose=True)
+        else:
+            lambda_model = partial(call_model, prompt=myPromt, model=model_name,
+                                   temperature=temperature_value, delimiter=myDelimiter, InContextExamples=InContextExamples, handler=api_call_gptjrc,
+                                   verbose=True)
+    # elif service_provider == "dglc":
+    #     if USE_CACHE:
+    #         lambda_model = partial(call_model_with_caching, prompt=myPromt, model=model_name, temperature=temperature_value, delimiter=myDelimiter, InContextExamples=InContextExamples,
+    #                                handler=api_call_dglc, map_query_input_output=load_map_query_input_output, cache_fp=cache_name, verbose=True)
+    #     else:
+    #         lambda_model = partial(call_model, prompt=myPromt, model=model_name,
+    #                                temperature=temperature_value, delimiter=myDelimiter, InContextExamples=InContextExamples, handler=api_call_dglc,
+    #                                verbose=True)
+
+    # elif service_provider == "HFonPremises":
+    #     if USE_CACHE:
+    #         lambda_model = partial(call_model_with_caching, prompt=myPromt, model=model_name,
+    #                                temperature=temperature_value, delimiter=myDelimiter, InContextExamples=InContextExamples, handler=api_call_HFonPremises,
+    #                                map_query_input_output=load_map_query_input_output, cache_fp=cache_name, verbose=True)
+    #     else:
+    #         lambda_model = partial(call_model, prompt=myPromt, model=model_name,
+    #                                temperature=temperature_value, delimiter=myDelimiter, InContextExamples=InContextExamples, handler=api_call_HFonPremises,
+    #                                verbose=True)
+
+
+
+    if lambda_model:
+        df = pd.DataFrame([["one, two, three, a step fortward Mary"], ["one, two, three, a step back"]], columns=["text"])
+        df["text_es"] = df["text"].apply(lambda_model)
+
+        print("\n")
+        print(df)
+
+    print("\nEnd Computations")
+
+
+

retrieverRAG_testing.py

@@ -0,0 +1,339 @@
+# https://www.mixedbread.ai/blog/mxbai-embed-large-v1
+# https://huggingface.co/mixedbread-ai/mxbai-embed-large-v1
+
+import os
+import time
+import pandas as pd
+import numpy as np
+from typing import Dict
+
+import torch
+from transformers import AutoModel, AutoTokenizer
+from sentence_transformers.util import cos_sim
+from accelerate import Accelerator  # Import from accelerate
+from scipy.stats import zscore
+
+# Set up environment variables for Hugging Face caching
+os.environ["HF_HUB_CACHE"] = "/eos/jeodpp/home/users/consose/cache/huggingface/hub"
+os.environ["HUGGINGFACE_HUB_CACHE"] = "/eos/jeodpp/home/users/consose/cache/huggingface/hub"
+os.environ["HF_HOME"] = "/eos/jeodpp/home/users/consose/cache/huggingface/hub"
+
+# Initialize the Accelerator
+accelerator = Accelerator()
+
+# Use the device managed by Accelerator
+device = accelerator.device
+print("Using accelerator device =", device)
+
+
+# 1. Load the model and tokenizer
+model_id_Retriever = 'mixedbread-ai/mxbai-embed-large-v1'
+tokenizer_Retriever = AutoTokenizer.from_pretrained(model_id_Retriever)
+modelRetriever = AutoModel.from_pretrained(model_id_Retriever)
+
+# Accelerate prepares the model (e.g., moves to the appropriate device)
+modelRetriever = accelerator.prepare(modelRetriever)
+
+
+
+
+# Define the transform_query function
+def transform_query(queryText: str) -> str:
+    """For retrieval, add the prompt for queryText (not for documents)."""
+    return f'Represent this sentence for searching relevant passages: {queryText}'
+
+# Define the pooling function
+def pooling(outputs: torch.Tensor, inputs: Dict, strategy: str = 'cls') -> np.ndarray:
+    if strategy == 'cls':
+        outputs = outputs[:, 0]
+    elif strategy == 'mean':
+        outputs = torch.sum(
+            outputs * inputs["attention_mask"][:, :, None], dim=1
+        ) / torch.sum(inputs["attention_mask"], dim=1, keepdim=True)
+    else:
+        raise NotImplementedError
+    return outputs.detach().cpu().numpy()
+
+
+def retrievePassageSimilarities(queryText, passages):
+    # Create the docs list by adding the transformed queryText and then the passages
+    docs = [transform_query(queryText)] + passages
+
+    # 2. Encode the inputs
+    inputs = tokenizer_Retriever(docs, padding=True, return_tensors='pt')
+
+    # Move inputs to the right device using accelerator
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    with torch.no_grad():
+        outputs = modelRetriever(**inputs).last_hidden_state
+    embeddings = pooling(outputs, inputs, 'cls')
+
+    similarities = cos_sim(embeddings[0], embeddings[1:])
+
+    #print('similarities:', similarities)
+
+    return similarities
+
+
+
+def RAG_retrieval_Base(queryText,passages, min_threshold=0.0, max_num_passages=None):
+
+    try:
+        similarities=retrievePassageSimilarities(queryText, passages)
+
+        #Create a DataFrame
+        df = pd.DataFrame({
+            'Passage': passages,
+            'Similarity': similarities.flatten()  # Flatten the similarity tensor/array to ensure compatibility
+        })
+
+        # Filter the DataFrame based on the similarity threshold
+        df_filtered = df[df['Similarity'] >= min_threshold]
+
+        # If max_num_passages is specified, limit the number of passages returned
+        if max_num_passages is not None:
+            df_filtered = df_filtered.nlargest(max_num_passages, 'Similarity')
+
+        df_filtered = df_filtered.sort_values(by='Similarity', ascending=False)
+
+        # Return the filtered DataFrame
+        return df_filtered
+
+    except Exception as e:
+        # Log the exception message or handle it as needed
+        print(f"An error occurred: {e}")
+        return pd.DataFrame()  # Return an empty DataFrame in case of error
+
+
+
+def RAG_retrieval_Z_scores(queryText, passages, z_threshold=1.0, max_num_passages=None, min_threshold=0.5):
+    try:
+        # Encoding and similarity computation remains the same
+
+        similarities = retrievePassageSimilarities(queryText, passages)
+
+        # Calculate z-scores for similarities
+        z_scores = zscore(similarities.flatten())
+
+        # Create a DataFrame with passages, similarities, and z-scores
+        df = pd.DataFrame({
+            'Passage': passages,
+            'Similarity': similarities.flatten(),
+            'Z-Score': z_scores
+        })
+
+        # Filter passages based on z-score threshold
+        df_filtered = df[df['Z-Score'] >= z_threshold]
+
+        if min_threshold:
+            # Filter the DataFrame also on min similarity threshold
+            df_filtered = df[df['Similarity'] >= min_threshold]
+
+        # If max_num_passages is specified, limit the number of passages returned
+        if max_num_passages is not None:
+            df_filtered = df_filtered.nlargest(max_num_passages, 'Similarity')
+
+        # Sort by similarity (or z-score if preferred)
+        df_filtered = df_filtered.sort_values(by='Similarity', ascending=False)
+
+        return df_filtered
+
+    except Exception as e:
+        # Log the exception message or handle it as needed
+        print(f"An error occurred: {e}")
+        return pd.DataFrame()  # Return an empty DataFrame in case of error
+
+
+
+
+def RAG_retrieval_Percentile(queryText, passages, percentile=90,max_num_passages=None, min_threshold=0.5):
+    try:
+        # Encoding and similarity computation remains the same
+
+        similarities = retrievePassageSimilarities(queryText, passages)
+
+        # Determine threshold based on percentile
+        threshold = np.percentile(similarities.flatten(), percentile)
+
+        # Create a DataFrame
+        df = pd.DataFrame({
+            'Passage': passages,
+            'Similarity': similarities.flatten()
+        })
+
+        # Filter using percentile threshold
+        df_filtered = df[df['Similarity'] >= threshold]
+
+        if min_threshold:
+            # Filter the DataFrame also on min similarity threshold
+            df_filtered = df[df['Similarity'] >= min_threshold]
+
+        # If max_num_passages is specified, limit the number of passages returned
+        if max_num_passages is not None:
+            df_filtered = df_filtered.nlargest(max_num_passages, 'Similarity')
+
+        # Sort by similarity
+        df_filtered = df_filtered.sort_values(by='Similarity', ascending=False)
+
+        return df_filtered
+
+    except Exception as e:
+        # Log the exception message or handle it as needed
+        print(f"An error occurred: {e}")
+        return pd.DataFrame()  # Return an empty DataFrame in case of error
+
+
+
+def RAG_retrieval_TopK(queryText, passages, top_fraction=0.1, max_num_passages=None, min_threshold=0.5):
+    try:
+        # Encoding and similarity computation (assuming retrievePassageSimilarities is defined elsewhere)
+        similarities = retrievePassageSimilarities(queryText, passages)
+
+        # Calculate the number of passages to select based on top fraction
+        num_passages_TopFraction = max(1, int(top_fraction * len(passages)))
+
+        # Create a DataFrame
+        df = pd.DataFrame({
+            'Passage': passages,
+            'Similarity': similarities.flatten()
+        })
+
+        # Select the top passages dynamically
+        df_filtered = df.nlargest(num_passages_TopFraction, 'Similarity')
+
+        if min_threshold:
+            # Filter the DataFrame also on min similarity threshold
+            df_filtered = df_filtered[df_filtered['Similarity'] >= min_threshold]
+
+        # If max_num_passages is specified, limit the number of passages returned
+        if max_num_passages is not None:
+            df_filtered = df_filtered.nlargest(max_num_passages, 'Similarity')
+
+        # Sort by similarity
+        df_filtered = df_filtered.sort_values(by='Similarity', ascending=False)
+
+        return df_filtered
+
+    except Exception as e:
+        # Log the exception message or handle it as needed
+        print(f"An error occurred: {e}")
+        return pd.DataFrame()  # Return an empty DataFrame in case of error
+
+
+
+if __name__ == '__main__':
+
+    queryText = 'A man is eating a piece of bread'
+
+    # Define the passages list
+    passages = [
+        "A man is eating food.",
+        "A man is eating pasta.",
+        "The girl is carrying a baby.",
+        "A man is riding a horse.",
+    ]
+
+    #df_retrieved = RAG_retrieval_Base(queryText, passages)
+    #df_retrieved = RAG_retrieval_Base(queryText, passages, min_threshold=0.5)
+    #df_retrieved = RAG_retrieval_Base(queryText, passages, max_num_passages=3)
+    df_retrieved = RAG_retrieval_Base(queryText, passages, min_threshold=0.5, max_num_passages=3)
+
+    #df_retrieved = RAG_retrieval_Z_scores(queryText, passages, z_threshold=1.0)
+    #df_retrieved = RAG_retrieval_Z_scores(queryText, passages, z_threshold=1.0,max_num_passages=3)
+
+    #df_retrieved = RAG_retrieval_Percentile(queryText, passages, percentile=80)
+    # df_retrieved = RAG_retrieval_Percentile(queryText, passages, percentile=80, max_num_passages=3)
+
+    ##df_retrieved = RAG_retrieval_TopK(queryText, passages, top_fraction=0.2)
+    #df_retrieved = RAG_retrieval_TopK(queryText, passages, top_fraction=0.2, max_num_passages=3)
+
+
+    print(df_retrieved)
+
+    #labelTriplesLIST_RAGGED = df_retrieved['Passage'].apply(lambda x: (x,)).tolist()
+
+
+    print("end of computations")
+
+# VERSION WITHOUT ACCELERATE
+#
+# #https://www.mixedbread.ai/blog/mxbai-embed-large-v1
+# #https://huggingface.co/mixedbread-ai/mxbai-embed-large-v1
+#
+# import os
+#
+# os.environ["HF_HUB_CACHE"] = "/eos/jeodpp/home/users/consose/cache/huggingface/hub"
+# os.environ["HUGGINGFACE_HUB_CACHE"] = "/eos/jeodpp/home/users/consose/cache/huggingface/hub"
+# os.environ["HF_HOME"] = "/eos/jeodpp/home/users/consose/cache/huggingface/hub"
+#
+# import time
+# import pandas as pd
+# import numpy as np
+#
+#
+#
+# from typing import Dict
+#
+# import torch
+# import numpy as np
+# from transformers import AutoModel, AutoTokenizer
+# from sentence_transformers.util import cos_sim
+#
+# # For retrieval you need to pass this prompt. Please find our more in our blog post.
+# def transform_queryText(queryText: str) -> str:
+#     """ For retrieval, add the prompt for queryText (not for documents).
+#     """
+#     return f'Represent this sentence for searching relevant passages: {queryText}'
+#
+# # The model works really well with cls pooling (default) but also with mean pooling.
+# def pooling(outputs: torch.Tensor, inputs: Dict,  strategy: str = 'cls') -> np.ndarray:
+#     if strategy == 'cls':
+#         outputs = outputs[:, 0]
+#     elif strategy == 'mean':
+#         outputs = torch.sum(
+#             outputs * inputs["attention_mask"][:, :, None], dim=1) / torch.sum(inputs["attention_mask"], dim=1, keepdim=True)
+#     else:
+#         raise NotImplementedError
+#     return outputs.detach().cpu().numpy()
+#
+# # 1. load model
+# model_id = 'mixedbread-ai/mxbai-embed-large-v1'
+# tokenizer = AutoTokenizer.from_pretrained(model_id)
+# model = AutoModel.from_pretrained(model_id).cuda()
+#
+# queryText = 'A man is eating a piece of bread'
+#
+# # Define the passages list
+# passages = [
+#     "A man is eating food.",
+#     "A man is eating pasta.",
+#     "The girl is carrying a baby.",
+#     "A man is riding a horse.",
+# ]
+#
+# # Create the docs list by adding the transformed queryText and then the passages
+# docs = [transform_queryText(queryText)] + passages
+#
+# # 2. encode
+# inputs = tokenizer(docs, padding=True, return_tensors='pt')
+# for k, v in inputs.items():
+#     inputs[k] = v.cuda()
+# outputs = model(**inputs).last_hidden_state
+# embeddings = pooling(outputs, inputs, 'cls')
+#
+# similarities = cos_sim(embeddings[0], embeddings[1:])
+#
+# print('similarities:', similarities)
+#
+#
+# # Create a DataFrame
+# df = pd.DataFrame({
+#     'Passage': passages,
+#     'Similarity': similarities.flatten()  # Flatten the similarity tensor/array to ensure compatibility
+# })
+#
+# # Display the DataFrame
+# print(df)
+#
+#
+# print("end of computations")

virtuosoQueryRest.py

@@ -3,11 +3,14 @@ from requests.auth import HTTPDigestAuth, HTTPBasicAuth
 import ssl
 import json
 
+from joblib import Memory
 
+cachedir = 'cached'
+mem = Memory(cachedir, verbose=False)
 
 
 
-
+@mem.cache
 def execute_query(endpoint, query, auth):
     headers = {
         'Content-Type': 'application/x-www-form-urlencoded',
@@ -144,32 +147,26 @@ if __name__ == '__main__':
 
     #############
 
-    #query = 'SELECT * WHERE { ?s ?p ?o } LIMIT 100'
-
-    # word ="acute sinusitis"
-    # query = f"""
-    #         SELECT ?concept ?label (COUNT(?edge) AS ?score)
-    #         WHERE {{
-    #           ?concept skos:prefLabel|rdfs:label|skos:altLabel|obo:hasRelatedSynonym ?label .
-    #           FILTER (LCASE(STR(?label)) = "{word}")
-    #           ?concept ?edge ?o .
-    #         }}
-    #         GROUP BY ?concept ?label
-    #         ORDER BY DESC(?score)
-    #     """
 
-    choices = ['SNOMED', 'LOINC', 'ICD10', 'MESH', 'NCIT']  # restricts the input to these values only
+    #choices = ['SNOMED', 'LOINC', 'ICD10', 'MESH', 'NCIT']  # restricts the input to these values only
+    choices = ["AI", "AIO", "AEO", "BFO", "BIM", "BCGO", "CL", "CHIRO", "CHEBI", "DCM", "FMA", "GO", "GENO",
+             "GeoSPARQL", "HL7", "DOID", "HP", "HP_O", "IDO", "IAO", "ICD10", "LOINC", "MESH",
+             "MONDO", "NCIT", "NCBITAXON", "NCBITaxon_", "NIFCELL", "NIFSTD", "GML", "OBCS", "OCHV", "OHPI",
+             "OPB", "TRANS", "PLOSTHES", "RADLEX", "RO", "STY", "SO", "SNOMED", "STATO",
+             "SYMP", "FoodOn", "UBERON", "ORDO", "HOOM", "VO", "OGMS", "EuroSciVoc"]
 
     # Construct the FROM clauses
     from_clauses = ' '.join([f"FROM <{choice}>" for choice in choices])
 
-    word = "acute sinusitis"
+    #word = "acute sinusitis"
+    word = "pure mathematics"
     # Construct the full SPARQL query
     query = f"""
+            prefix skosxl: <http://www.w3.org/2008/05/skos-xl#> 
             SELECT ?concept ?label (COUNT(?edge) AS ?score)
             {from_clauses}
             WHERE {{
-              ?concept skos:prefLabel|rdfs:label|skos:altLabel|obo:hasRelatedSynonym ?label .
+              ?concept skos:prefLabel|rdfs:label|skos:altLabel|skosxl:literalForm|obo:hasRelatedSynonym ?label .
               FILTER (LCASE(STR(?label)) = "{word.lower()}")
               ?concept ?edge ?o .
             }}