1.1.1.1 updated ui and corresponding features for the devices arrangement ui.

app.py

@@ -1,5 +1,3 @@
-# search_logic = gr.Interface(text_analysis,input="text",outputs="highlight",title="High light")
-
 # first layer extraction(text)
 # second layer extraction(first layer output)
 # third layer extraction(first layer outputs aggregated, second layer outputs aggregated)
@@ -10,6 +8,7 @@ import gradio as gr
 from cloud_db import *
 from supplier import *
 from utility import *
+from features import init_app_data
 
 from ui_device import *
 from ui_equivalent import *
@@ -21,11 +20,11 @@ examples = []
 demo = gr.TabbedInterface(
     [device_page,equivalent_page], 
     ["Device","Equivalent Comparators"],
-    [device_page,equivalent_page],
-    ["Clinical Study","Studies"],
     theme = gr.themes.Soft(primary_hue="sky",secondary_hue="orange"),
+    title="AMRA AI Medi Reader",
     css = "footer {visibility: hidden}",
-    title="AMRA AI Medi Reader")
+    )
+# )
 
 def refresh_data():
     return

application.py

@@ -79,6 +79,18 @@ data_structure = {
             "article",
             "outcomes"
         ]
+    },
+    "devices":{
+        "key":[
+            "device_name"
+        ],
+        "fields":[
+            "device_name",
+            "device_type",
+            "intended_use",
+            "indications",
+            "contraindications"
+        ]
     }
 }
 
@@ -86,9 +98,6 @@ data_structure = {
 application default data
 '''
 app_data = {
-    "current_article":{},
-    "articles":[],
-    "terms":[],
-    "prompts":[],
-    "outputs":[]
+    "current_device":{},
+    "devices":[],
 }

cloud_db.py

@@ -14,13 +14,31 @@ db_client = boto3.client(
 dynamodb data operations
 '''
 
-# get the list of articles from articles table in dynamodb
+# get the list of items from a table in dynamodb
 def get_table(table_name:str):
+    '''
+    get the list of items from table in dynamodb
+    
+    Args:
+        table_name (str): the name of the table in dynamodb
+        
+    Returns:
+        list: a list of items in the table
+    '''
     result = db_client.scan(TableName = table_name,AttributesToGet = data_structure[table_name]["fields"])
     return [db_map_to_py_dict(r) for r in result["Items"]]
 
-# add a new article to table articles in dynamodb, return error if failed
+# add a new item to a table in dynamodb, return error if failed
 def post_item(table_name:str,item:dict):
+    '''
+    add a new item to table in dynamodb, return error if failed
+    
+    Args:
+        table_name (str): the name of the table in dynamodb
+        item (dict): the item to be added to the table
+        
+    Returns:
+        dict: the result of the operation'''
     try:
         res = db_client.put_item(
             TableName = table_name,
@@ -30,8 +48,18 @@ def post_item(table_name:str,item:dict):
         return {"Error":e}
     return res
 
-# update an article in table articles in dynamodb, return error if failed
+# update an item in a table in dynamodb, return error if failed
 def put_item(table_name:str,item:dict):
+    '''
+    update an item in table in dynamodb, return error if failed
+    
+    Args:
+        table_name (str): the name of the table in dynamodb
+        item (dict): the item to be updated to the table
+        
+    Returns:
+        dict: the result of the operation
+    '''
     try:
         res = db_client.put_item(
             TableName = table_name,
@@ -41,8 +69,18 @@ def put_item(table_name:str,item:dict):
         return {"Error":e}
     return res
 
-# delete an article in table articles in dynamodb, return error if not found.
+# delete an item in a table in dynamodb, return error if not found.
 def delete_item(table_name:str,key:dict):
+    '''
+    delete an item in table in dynamodb, return error if not found.
+
+    Args:
+        table_name (str): the name of the table in dynamodb
+        key (dict): the key of the item to be deleted
+
+    Returns:
+        dict: the result of the operation
+    '''
     try:
         res = db_client.delete_item(
             TableName = table_name,
@@ -52,10 +90,17 @@ def delete_item(table_name:str,key:dict):
         return {"Error":e}
     return res
 
-
-'''
-'''
 def get_item(table_name:str,key:dict):
+    '''
+    get an item in table in dynamodb, return error if not found.
+    
+    Args:
+        table_name (str): the name of the table in dynamodb
+        key (dict): the key of the item to be deleted
+        
+    Returns:
+        dict: the result of the operation
+    '''
     try:
         res = db_client.get_item(
             TableName = table_name,
@@ -69,5 +114,14 @@ def get_item(table_name:str,key:dict):
 dynamodb structure management
 '''
 def get_structure(table_name:str):
+    '''
+    get the structure of a table in dynamodb
+
+    Args:
+        table_name (str): the name of the table in dynamodb
+
+    Returns:
+        dict: the structure of the table
+    '''
     result = db_client.describe_table(TableName = table_name)
     return result["Table"]["AttributeDefinitions"]

features.py

@@ -1,417 +1,122 @@
 # language default packages
-from datetime import datetime
-from collections import defaultdict
+from application import *
 
 # external packages
 import gradio as gr
-import tiktoken
 
 # internal packages
 from cloud_db import *
 from cloud_storage import *
 from supplier import *
 
-encoding = tiktoken.get_encoding("cl100k_base")
-
 # get prompts, terms, outputs from the cloud
 def init_app_data():
     '''
     a function to initialize the application data from the cloud backend
     '''
-    app_data["prompts"] = get_table("prompts")
-    app_data["terms"] = get_table("terms")
-    app_data["outputs"] = get_table("outputs")
-    app_data["articles"] = get_table("articles")
-
-def process_study(
-        study_file_obj,
-        study_content,
-        device=default_device
-        ):
-    
-    if study_file_obj:    
-        article = add_article(device,study_file_obj)
-    elif study_content:
-        article = add_article(device,study_content,file_object=False)
-    else:
-        return "No file or content provided","No file or content provided","No file or content provided"
-
-    app_data["current_article"] = article
-    selected_prompts = select_prompts(article["content"],terms=app_data["terms"],prompts=app_data["prompts"])
-    
-    res = process_prompts(article["content"],selected_prompts)
-    output = {
-        "domain":article["domain"],
-        "article":article["name"],
-        "outcomes":res
-    }
-    
-    add_output(output)
-    views = create_views(res)
-
-    return views
-    # return ""
-
-def refresh():
-    '''
-    this function refresh the application data from the cloud backend
-    '''
-    init_app_data()
+    app_data["devices"] = get_table("devices")
 
-    article = app_data["current_article"]
-    if not article:
-        return "No file or content provided"
-    selected_prompts = select_prompts(article["content"],terms=app_data["terms"],prompts=app_data["prompts"])    
-
-    res = process_prompts(article["content"],selected_prompts)
-
-    output = {
-        "domain":article["domain"],
-        "article":article["name"],
-        "outcomes":res
-    }
-    views = create_views(res)
-    add_output(output)
-
-    return views
-
-def create_views(output):
+def create_view(device):
     md_text = ""
     
-    overview = [v for _,v in output.items() if v["assessment"] == "overview"][0]
-    safety = [v for _,v in output.items() if v["assessment"] == "safety"][0]
     # add overview
-    md_text += f"<details><summary><b>Overivew</b></summary>\n\n"
-    md_text += overview["content"] + "\n</details>\n\n"
-    
-    # add performance
-    md_text += f"<details><summary><b>Performance</b></summary>\n\n"
-    for title,content in output.items():
-        if content["assessment"] not in  ["overview","safety"]:
-            md_text += f"#### {content['assessment']} - {title}\n\n"
-            md_text += content["content"] + "\n\n"
-    md_text += "</details>\n\n"
-
-    # add safety
-    md_text += f"<details><summary><b>Safety</b></summary>\n\n"
-    md_text += safety["content"] + "\n\n" + "</details>\n\n"
-
-    return gr.update(value=md_text)
+    md_text += f"<details><summary><b>Intended Use</b></summary>\n\n"
+    md_text += device["intended_use"] + "\n</details>\n\n"
 
-def extract_key_content(text,start,end,before = None,case_sensitive=False):
-    '''
-    this function extract the content between start and end
-    and return the content in between. The function will find
-    all the start and keep the last one showing up in the text,
-    and find all the end and keep the last one showing up in the
-    text. If no start or end is found, the function will return
-    the no text.
+    md_text += f"<details><summary><b>Indications</b></summary>\n\n"
+    md_text += device["indications"] + "\n</details>\n\n"
 
-    Parameters
-    ----------
-    text : str
-        text of the article
-    start : list
-        list of start substrings
-    end : list
-        list of end substrings
+    md_text += f"<details><summary><b>Contraindications</b></summary>\n\n"
+    md_text += device["contraindications"] + "\n</details>\n\n"
 
-    Returns
-    -------
-    str
-        content between start and end
-    '''
-    origin = text
-    if not case_sensitive:
-        text = text.lower()
-        start = [s.lower() for s in start]
-        end = [e.lower() for e in end]
-    
-    start_index = 0
-    for s in start:
-        start_index = max(start_index,text.find(s))
-        
-    if start_index ==-1: start_index = 0
+    return gr.update(value=md_text)
 
-    end_index = 0
-    for e in end:
-        end_index = max(end_index,text[start_index:].find(e))
-    
-    if before:
-        for b in before:
-            before_index = text[start_index:start_index+end_index].find(b)
-            end_index = min(end_index,before_index) if before_index != -1 and before_index >=800 else end_index # 800 is a magic number for the length of the abstract
+def add_device(
+        device_name,
+        device_type,
+        upload_instruction,
+        intended_use,
+        indications,
+        contraindications
+        ):
     
-    content = origin[start_index:start_index+end_index]
-    return content, start_index, start_index+end_index
-
-def get_articles(update_local=True):
-    '''
-    this function return the list of articles
-
-    Parameters
-    ----------
-    update_local : bool, optional
-        update the local memory, by default True
-
-    Returns
-    -------
-    list
-        list of articles
-    '''
-    articles = get_table("articles")
-    if update_local:
-        app_data["articles"] = articles
-
-    return articles
-
-def get_article(domain,name):
-    '''
-    this function return the article object
-
-    Parameters
-    ----------
-    domain : str
-        subject domain of the article
-    name : str
-        name of the article
-
-    Returns
-    -------
-    dict
-        article object
-    '''
-    article = get_item("articles",{"domain":domain,"name":name})
-
-    return article
-
-def add_article(domain,file,add_to_s3=True, add_to_local=True, file_object=True):
-    '''
-    this function receive the domain name and file obj
-    and add the article to the cloud, s3 and local memory
+    if device_name in [d["device_name"] for d in app_data["devices"]]:
+        return gr.update(value="Device already exists!")
 
-    Parameters
-    ----------
-    domain : str
-        subject domain of the article
-    file_obj : file object
-        file object of the article
-    add_to_s3 : bool, optional
-        add article to s3 bucket, by default True
-    add_to_local : bool, optional
-        add article to local memory, by default True
-
-    Returns
-    -------
-    dict
-        article object
-    '''
-    if file_object:
-        content, _ = read_pdf(file)
-        filename = file.name.split("\\")[-1]
-        # name = filename.split(".")[0]
-    else:
-        content = file
-        # filename = file.name
-        filename = f"temp_{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
-
-    article ={
-        "domain":domain,
-        "name":filename,
-        "content":content,
-        "upload_time":datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+    device = {
+        "device_name":device_name,
+        "device_type":device_type,
     }
     
-    if add_to_s3 and file_object:
-        upload_fileobj(file,domain,filename)
-
-    if add_to_local:
-        app_data["articles"].append(article)
-
-    res = post_item("articles",article)
-    if "Error" in res:
-        print(res["Error"])
-        return res
-    
-    return article
-    
-def remove_article(domain,name,remove_from_s3=True, remove_from_local=True):
-    '''
-    this function remove the article from the cloud, s3 and local memory
-
-    Parameters
-    ----------
-    domain : str
-        subject domain of the article
-    name : str
-        name of the article
-    remove_from_s3 : bool, optional
-        remove article from s3 bucket, by default True
-    remove_from_local : bool, optional
-        remove article from local memory, by default True
-
-    Returns
-    -------
-    dict
-        article object
-    '''
-    delete_item("articles",{"domain":domain,"name":name})
-    if remove_from_s3:
-        delete_file(domain,name)
-    if remove_from_local:
-        # app_data["articles"].remove(article)
-        pass
-    delete_item("articles",{"domain":domain,"name":name})
-
-    return True
+    if upload_instruction:
+        content, _ = read_pdf(upload_instruction)
 
-def update_article(article,file_obj=None,update_local=True):
-    '''
-    this function receive the article object and update the article
-    to the cloud, s3 and local memory
-    
-    Parameters
-    ----------
-    article : dict
-        article object
-    file_obj : file object, optional
-        file object of the article, by default None
-    update_local : bool, optional
-        update article to local memory, by default True
+        device["intended_use"] = get_intended_use(content)
+        device["indications"] = get_indications(content)
+        device["contraindications"] = get_contraindications(content)
         
-    Returns
-    -------
-    dict
-        article object
-        '''
-    if file_obj:
-        upload_fileobj(file_obj,article["domain"],article["name"])
-
-    if update_local:
-        app_data["articles"].append(article)
+        filename = upload_instruction.name.split("/")[-1] if "/" in upload_instruction.name else upload_instruction.name.split("\\")[-1]
 
-    post_item("articles",article)
-    
-    return article
-
-def add_output(output):
-    '''
-    this function add the output to the cloud
-    
-    Parameters
-    ----------
-    output : dict
-        output object
-        
-    Returns
-    -------
-    bool
-        True if success
-    '''
-    res = post_item("outputs",output)
-
-    if "Error" in res:
-        print(res)
-        return False
-    return res
-
-def get_output(domain,name):
-    res = output = get_item("outputs",{"domain":domain,"name":name})
-    if "Error" in res:
-        print(res)
-        return False
-    return output
+        upload_fileobj(upload_instruction,"instructions",filename)
+    else:
+        device["intended_use"] = intended_use
+        device["indications"] = indications
+        device["contraindications"] = contraindications
 
-def remove_output(domain,name):
-    res = delete_item("outputs",{"domain":domain,"name":name})
-    if "Error" in res:
-        print(res)
-        return False
-    return True
+    res = post_item("devices",device)
+    app_data["current_device"] = device
 
-def update_output(output):
-    res = put_item("outputs",output)
-    if "Error" in res:
-        print(res)
-        return False
-    return True
+    init_app_data()
 
-def add_device(*args):
-    pass
+    return create_view(device)
 
-def get_device():
-    pass
+def get_device(
+        device_name
+):
+    item = get_item("devices",{"device_name":device_name})["Item"]
+    device = db_map_to_py_dict(item)
+    return device["device_name"], device["device_type"], device["intended_use"], device["indications"], device["contraindications"], create_view(device)
 
-def remove_device():
-    pass
+def remove_device(
+        device_name
+):
+    res = delete_item("devices",{"device_name":device_name})
+    return res
 
-def update_device():
-    pass
+def update_device(
+        device_name,
+        device_type,
+        intended_use,
+        indications,
+        contraindications
+    ):
+    device = {
+        "device_name":device_name,
+        "device_type":device_type,
+        "intended_use":intended_use,
+        "indications":indications,
+        "contraindications":contraindications
+    }
+    res = put_item("devices",device)
+    return res
 
-# identify article state
-def identify_logic(text):
-    article_logic = [
-        "groups",
-        "levels",
-        "preoperatives"
+def get_intended_use(content):
+    instructions = [
+        "what is the intended use of this device?"
     ]
+    result = send_inst(create_inst(content,instructions))
+    return result
 
-    return {l:l in text.lower() for l in article_logic}
-
-def select_prompts(text,terms,prompts):
-    selected_templates = set()
-    for t in terms:
-        if all([term in text for term in t["terms"]]):
-            selected_templates.update(t["template_name"])
-
-    logic = identify_logic(text)
-
-    selected_prompts = [p for p in prompts if p["template_name"] in selected_templates]
-    overview_prompts = [p for p in prompts if p["assessment_step"] == "overview"]
-    for p in overview_prompts:
-        if all([p[l]==v for l,v in logic.items() if v]):
-            selected_prompts.append(p)
-
-    return selected_prompts
-
-def keyword_search(keywords,full_text):
-    keywords_result = {}
-    for k in keywords:
-        if type(k) is tuple:
-            keywords_result[k]=list_or([keyword_search(kw,full_text) for kw in k])
-        else:
-            keywords_result[k]=keyword_search(k,full_text)
-    return keywords_result
-
-def process_prompts(text,prompts):
-    '''
-    process_prompts function receive the text and prompts and return the instruction stream
-
-    Parameters
-    ----------
-    text : str
-        text of the article
-    prompts : list
-        list of prompts
-
-    Returns
-    -------
-    dict
-        processed extraction results from openai api
-    '''
-    res = {}
-    for p in prompts:
-        inst = [
-            p["prompt"]+", ".join(p["fields"]),
-            p["reformat_inst"]
-        ]
-        inst_stream = create_inst(text,inst)
-        extraction = send_inst(inst_stream)
-
-        res[p["template_name"]] = {
-            "template_name":p["template_name"],
-            "assessment":p["assessment_step"],
-            "content":extraction
-        }
+def get_indications(content):
+    instructions = [
+        "what are the indications for use outllined for this device?"
+    ]
+    result = send_inst(create_inst(content,instructions))
+    return result
 
-    return res
+def get_contraindications(content):
+    instructions = [
+        "what are the contraindications for use outllined for this device?"
+    ]
+    result = send_inst(create_inst(content,instructions))
+    return result

test_cloud.py

@@ -1,29 +0,0 @@
-from cloud_db import *
-from cloud_storage import *
-from utility import default_domain
-
-import unittest
-
-tables = ["articles","prompts","terms","outputs"]
-samples_dir = "../.samples/input/"
-
-files = []
-for file in os.listdir(samples_dir):
-    if file.endswith(".pdf"):
-        files.append(os.path.join(samples_dir, file))
-
-class TestCloud(unittest.TestCase):
-    # a function to test the cloud db get article function
-    def test_cloud_db(self):
-        pass
-        
-    # a function to test the cloud storage upload file function
-    def test_cloud_storage(self):
-        # upload a file to the cloud storage
-        for f in files:
-            # filename = os.path.basename(f)
-            assert upload_file(f,default_domain) == True
-            # assert res == True
-
-if __name__ == '__main__':
-    unittest.main()

ui_device.py

@@ -2,14 +2,7 @@ import gradio as gr
 
 from utility import *
 from application import *
-from features import init_app_data, add_device
-# from ui_list import render_list
-
-def refresh_ui_device():
-    # init_app_data()
-    # render_list()
-
-    return ()
+from features import init_app_data, add_device, remove_device, get_device
 
 def reset():
     return (
@@ -18,59 +11,113 @@ def reset():
         gr.File.update(value=None),
         gr.TextArea.update(value=""),
         gr.TextArea.update(value=""),
-        gr.TextArea.update(value="")
+        gr.TextArea.update(value=""),
+        gr.Markdown.update(value="")
     )
 
+def refresh():
+    init_app_data()
+    '''
+    refresh the literature report.
+    '''
+    print([d["device_name"] for d in app_data["devices"]])
+    return create_md_tables(app_data["devices"]), gr.Dropdown.update(choices=[d["device_name"] for d in app_data["devices"]])
+
 with gr.Blocks() as device_page:
-    
-    with gr.Column():
-        gr.Markdown("## Devices")
-        gr.HTML("<hr>")
-        device_name = gr.Textbox(lines=1, label="Subject Device Name")
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("## Devices")
+            gr.HTML("<hr>")
+            select_device = gr.Dropdown(
+                choices=[d["device_name"] for d in app_data["devices"]],
+                # choices=["chiken","duck","goose"],
+                value=None,
+                label="Select Device",
+                interactive=True
+            )
+            gr.HTML("<hr>")
+            device_name = gr.Textbox(lines=1, label="Subject Device Name")
+            device_type = gr.Textbox(lines=1, label="Subject Device Type")
 
-        upload_instruction = gr.File(label="Upload IFU(Instruction For Use)")
+            upload_instruction = gr.File(label="Upload IFU(Instruction For Use)")
 
-        intented_use = gr.TextArea(lines=5, label="Intended Use")
-        indications = gr.TextArea(lines=5, label="Indication")
-        contraindications = gr.TextArea(lines=5, label="Contraindication")
+            intended_use = gr.TextArea(lines=5, label="Intended Use")
+            indications = gr.TextArea(lines=5, label="Indication")
+            contraindications = gr.TextArea(lines=5, label="Contraindication")
 
-        with gr.Row():
-            btn_reset = gr.Button("Reset",variant="stop")
-            btn_add = gr.Button("Add",variant="primary")
+            with gr.Row():
+                btn_get = gr.Button("Get",variant="primary")
+                btn_add = gr.Button("Add",variant="primary")
+                btn_reset = gr.Button("Reset",variant="stop")
 
-    btn_reset.click(
-        fn=reset,
-        outputs=[
-            device_name,
-            upload_instruction,
-            intented_use,
-            indications,
-            contraindications
-        ])
+            gr.Markdown("## Device Details")
+            details = gr.Markdown("")
 
-    btn_add.click(
-        fn=add_device,
-        inputs=[
-            device_name,
-            upload_instruction,
-            intented_use,
-            indications,
-            contraindications
-        ])
+        btn_reset.click(
+            fn=reset,
+            outputs=[
+                device_name,
+                device_type,
+                upload_instruction,
+                intended_use,
+                indications,
+                contraindications,
+                details
+            ])
 
+        btn_add.click(
+            fn=add_device,
+            inputs=[
+                device_name,
+                device_type,
+                upload_instruction,
+                intended_use,
+                indications,
+                contraindications
+            ],
+            outputs=[
+                details
+            ]
+            )
 
-    # show the list of devices in the database
-    with gr.Column() as device_list:
-        gr.HTML("<hr>")
-        gr.Markdown("## Device List")
-        gr.HTML("<hr>")
-        # gr.Label("Select a device to view the details")
-        # devices_list = render_list(app_data["devices"],title="Device List")
+        btn_get.click(
+            fn=get_device,
+            inputs=[select_device],
+            outputs=[
+                device_name,
+                device_type,
+                intended_use,
+                indications, 
+                contraindications,
+                details
+                ]
+        )
 
-        btn_refresh = gr.Button("Refresh")
+        # select_device.change(
+        #     fn=get_device,
+        #     inputs=[select_device],
+        #     outputs=[
+        #         device_name,
+        #         device_type,
+        #         intended_use,
+        #         indications, 
+        #         contraindications,
+        #         details
+        #         ]
+        # )
 
-    btn_refresh.click(
-        fn=refresh_ui_device        
-        )
+        # show the list of devices in the database
+        with gr.Column(scale=2):
+            gr.Markdown("## Devices List")
+            btn_refresh = gr.Button(value="Refresh",variant="primary")
+            gr.HTML("<hr>")
         
-
+            device_list = gr.Markdown("")
+        
+        btn_refresh.click(
+            fn=refresh,
+            outputs=[
+                device_list,
+                select_device
+                ]
+        )

ui_studies.py

@@ -1,38 +0,0 @@
-import gradio as gr
-
-from application import *
-from features import init_app_data
-
-def refresh():
-    init_app_data()
-    '''
-    refresh the literature report.
-    '''
-    return create_md_tables(app_data["articles"])
-
-
-def create_md_tables(articles):
-    '''
-    create markdown tables for the articles.
-    '''
-    md_text = ""
-    md_text += "| Domain | File Name | Upload Time | Device |\n| --- | --- | --- | --- |\n"
-
-    for article in articles:
-        md_table = f"| {article['domain']} | {article['name']} | {article['upload_time']} | {default_device} |\n"
-        md_text += md_table
-
-    return md_text
-
-with gr.Blocks() as studies_page:
-    with gr.Row():
-        gr.Markdown("## Article Lists")
-        btn_refresh = gr.Button(value="Refresh",variant="primary")
-    gr.HTML("<hr>")
-    
-    article_list = gr.Markdown("")
-    
-    btn_refresh.click(
-        fn=refresh,
-        outputs=[article_list]
-    )

ui_study.py

@@ -1,62 +0,0 @@
-import gradio as gr
-
-from utility import *
-from application import *
-from features import *
-
-def reset():
-    '''
-    reset gradio input and output features in this page.
-    '''
-    return (
-        gr.Files.update(value=None),
-        gr.TextArea.update(value=""),
-        gr.Markdown.update(value="")
-    )
-
-with gr.Blocks() as study_page:
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("## Studies")
-            gr.HTML("<hr>")
-
-            upload_study = gr.File(label="Upload a clinical study report",type="file")
-            
-            input_study = gr.TextArea(label="Or paste a clinical study report content",placeholder="Paste content here...",lines=5)
-
-            with gr.Row():
-                btn_reset = gr.Button(value="Reset",variant="stop")
-                btn_add_study = gr.Button(value="Add",variant="primary")
-
-        with gr.Column():
-            with gr.Row():
-                gr.Markdown("## Literature Report")
-                btn_refresh = gr.Button(value="Refresh",variant="primary")
-            views = gr.Markdown("")
-            
-    btn_reset.click(
-        reset,
-        outputs=[
-            upload_study,
-            input_study,
-            views,
-        ]
-    )
-
-    btn_add_study.click(
-        process_study,
-        inputs=[
-            upload_study,
-            input_study,
-        ],
-        outputs=[
-            views,
-        ],
-    )
-
-    btn_refresh.click(
-        refresh,
-        outputs=[
-            views,
-        ],
-    )

utility.py

@@ -1,10 +1,30 @@
 import json
 
 from application import *
+
+import tiktoken
 from pdfminer.high_level import extract_text
 from pdfminer.pdfparser import PDFParser
 from pdfminer.pdfdocument import PDFDocument
 
+token_encoder = tiktoken.get_encoding("cl100k_base")
+
+def count_tokens(text):
+    '''
+    this function count the number of tokens in the text
+    
+    Parameters
+    ----------
+    text: str
+        text to be counted
+    
+    Returns
+    -------
+    n_tokens: int
+        number of tokens in the text
+    '''
+    
+    return len(token_encoder.encode(text))
 
 '''
 following functions are for file manipulation
@@ -191,6 +211,27 @@ following functions are used for business logic. (to be moved to business logic
 '''
 
 # function to calculate the estimated cost of the translation
-def est_cost(n_tokens,rate):
+def est_cost(n_tokens,rate:float=0.004):
     return round(rate*n_tokens/1000,4)
 
+def create_md_tables(devices):
+    '''
+    create markdown tables for the articles.
+
+    Parameters
+    ----------
+    devices: list
+        list of devices
+
+    Returns
+    -------
+        md_text: str
+    '''
+    md_text = ""
+    md_text += "| Device name | Device Type | Intended Use | \n| --- | --- | --- | \n"
+
+    for device in devices:
+        md_table = f"| {device['device_name']} | {device['device_type']} | {device['intended_use']} | \n"
+        md_text += md_table
+
+    return md_text