llm-ie 0.3.0__tar.gz → 0.3.2__tar.gz

{llm_ie-0.3.0 → llm_ie-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: llm-ie
-Version: 0.3.0
+Version: 0.3.2
 Summary: An LLM-powered tool that transforms everyday language into robust information extraction pipelines.
 License: MIT
 Author: Enshuo (David) Hsu
@@ -9,6 +9,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: nltk (>=3.8,<4.0)
 Description-Content-Type: text/markdown
 

{llm_ie-0.3.0 → llm_ie-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "llm-ie"
-version = "0.3.0"
+version = "0.3.2"
 description = "An LLM-powered tool that transforms everyday language into robust information extraction pipelines."
 authors = ["Enshuo (David) Hsu"]
 license = "MIT"
@@ -14,6 +14,7 @@ exclude = [
 [tool.poetry.dependencies]
 python = "^3.11"
 nltk = "^3.8"
+colorama = "^0.4.6"
 
 
 [build-system]

llm_ie-0.3.2/src/llm_ie/asset/default_prompts/ReviewFrameExtractor_addition_review_prompt.txt

@@ -0,0 +1,3 @@
+Review the input text and your output carefully. If anything was missed, add it to your output following the defined output formats. 
+You should ONLY adding new items. Do NOT re-generate the entire answer.
+Your output should strictly adheres to the defined output formats. 

llm_ie-0.3.2/src/llm_ie/asset/default_prompts/ReviewFrameExtractor_revision_review_prompt.txt

@@ -0,0 +1,2 @@
+Review the input text and your output carefully. If you find any omissions or errors, correct them by generating a revised output following the defined output formats.
+Your output should strictly adheres to the defined output formats. 

llm_ie-0.3.2/src/llm_ie/asset/default_prompts/SentenceReviewFrameExtractor_addition_review_prompt.txt

@@ -0,0 +1,4 @@
+Review the input sentence and your output carefully. If anything was missed, add it to your output following the defined output formats. 
+You should ONLY adding new items. Do NOT re-generate the entire answer.
+Your output should be based on the input sentence. 
+Your output should strictly adheres to the defined output formats. 

llm_ie-0.3.2/src/llm_ie/asset/default_prompts/SentenceReviewFrameExtractor_revision_review_prompt.txt

@@ -0,0 +1,3 @@
+Review the input sentence and your output carefully. If you find any omissions or errors, correct them by generating a revised output following the defined output formats.
+Your output should be based on the input sentence. 
+Your output should strictly adheres to the defined output formats. 

llm_ie-0.3.2/src/llm_ie/asset/prompt_guide/SentenceCoTFrameExtractor_prompt_guide.txt

@@ -0,0 +1,217 @@
+Prompt Template Design:
+
+1. Task Description:  
+   Provide a detailed description of the task, including the background and the type of task (e.g., named entity recognition).
+
+2. Schema Definition:  
+   List the key concepts that should be extracted, and provide clear definitions for each one.
+
+3. Thinking process:
+   Provide clear step-by-step instructions for analyzing the input text. Typically, this process should begin with an analysis section and proceed to the output generation. Each section should have a specific purpose:
+
+   Optional: Recall Section (<Recall>... </Recall>):
+    Write a brief recall of the task description and schema definition for better understanding of the task. 
+
+   Analysis Section (<Analysis>... </Analysis>):
+    Break down the input text to identify important medical contents and clarify ambiguous concepts. 
+
+   Output Section (<Outputs>... </Outputs>):
+    Based on the analysis, generate the required output in the defined format. Ensure that the extracted information adheres to the schema and task description.
+
+4. Output Format Definition:  
+   The output should be a JSON list, where each element is a dictionary representing a frame (an entity along with its attributes). Each dictionary must include a key that holds the entity text. This key can be named "entity_text" or anything else depend on the context. The attributes can either be flat (e.g., {"entity_text": "<entity_text>", "attr1": "<attr1>", "attr2": "<attr2>"}) or nested (e.g., {"entity_text": "<entity_text>", "attributes": {"attr1": "<attr1>", "attr2": "<attr2>"}}).
+
+5. Optional: Hints:  
+   Provide itemized hints for the information extractors to guide the extraction process.
+
+6. Optional: Examples:  
+   Include examples in the format:  
+    Input: ...  
+    Output: ...
+
+7. Input Placeholder:  
+   The template must include a placeholder in the format {{<placeholder_name>}} for the input text. The placeholder name can be customized as needed.
+   
+
+Example 1 (single entity type with attributes):
+
+    # Task description
+    The paragraph below is from the Food and Drug Administration (FDA) Clinical Pharmacology Section of Labeling for Human Prescription Drug and Biological Products, Adverse reactions section. Please carefully review it and extract the adverse reactions and percentages. Note that each adverse reaction is nested under a clinical trial and potentially an arm. Your output should take that into consideration.
+
+    # Schema definition
+    Your output should contain: 
+        "ClinicalTrial" which is the name of the trial, 
+        If applicable, "Arm" which is the arm within the clinical trial, 
+        "AdverseReaction" which is the name of the adverse reaction,
+        If applicable, "Percentage" which is the occurance of the adverse reaction within the trial and arm,
+        "Evidence" which is the EXACT sentence in the text where you found the AdverseReaction from
+
+    # Thinking process
+    Approach this task step by step. Start with a recall section (<Recall>... </Recall>) that briefly summarize of the task description and schema definition for better understanding of the task. Then write an analysis section (<Analysis>... </Analysis>) to analyze the input sentence. Identify important pharmacology contents and clarify ambiguous concepts. Finally, the output section (<Outputs>... </Outputs>) that list your final outputs following the defined format. 
+
+    # Output format definition
+    Your output should follow JSON format, for example:
+    [
+        {"ClinicalTrial": "<Clinical trial name or number>", "Arm": "<name of arm>", "AdverseReaction": "<Adverse reaction text>", "Percentage": "<a percent>", "Evidence": "<exact sentence from the text>"},
+        {"ClinicalTrial": "<Clinical trial name or number>", "Arm": "<name of arm>", "AdverseReaction": "<Adverse reaction text>", "Percentage": "<a percent>", "Evidence": "<exact sentence from the text>"} 
+    ]
+
+    # Additional hints
+    Your output should be 100% based on the provided content. DO NOT output fake numbers. 
+    If there is no specific arm, just omit the "Arm" key. If the percentage is not reported, just omit the "Percentage" key. The "Evidence" should always be provided.
+
+    # Input placeholder
+    Below is the Adverse reactions section for your reference. I will feed you with sentences from it one by one. 
+    {{input}}
+
+
+Example 2 (multiple entity types):
+
+    # Task description
+    This is a named entity recognition task. Given a sentence from a medical note, annotate the Drug, Form, Strength, Frequency, Route, Dosage, Reason, ADE, and Duration.
+
+    # Schema definition
+    Your output should contain: 
+        "entity_text": the exact wording as mentioned in the note.
+        "entity_type": type of the entity. It should be one of the "Drug", "Form", "Strength", "Frequency", "Route", "Dosage", "Reason", "ADE", or "Duration".
+
+    # Thinking process
+    Approach this task step by step. Start with an analysis section (<Analysis>... </Analysis>) to analyze the input sentence. Identify important medical contents and clarify ambiguous concepts. Then, the output section (<Outputs>... </Outputs>) that list your final outputs following the defined format. 
+
+    # Output format definition
+    Your output should follow JSON format, 
+    if there are one of the entity mentions: Drug, Form, Strength, Frequency, Route, Dosage, Reason, ADE, or Duration:
+        [{"entity_text": "<Exact entity mentions as in the note>", "entity_type": "<entity type as listed above>"},
+        {"entity_text": "<Exact entity mentions as in the note>", "entity_type": "<entity type as listed above>"}]
+    if there is no entity mentioned in the given note, just output an empty list:
+        []
+
+    # Examples
+    Below are some examples:
+
+    Input: Acetaminophen 650 mg PO BID 5.
+    Output: 
+        <Analysis>
+        The sentence "Acetaminophen 650 mg PO BID 5." contains several potential medical entities.
+
+        "Acetaminophen" is a Drug.
+        "650 mg" represents the Strength.
+        "PO" is the Route (meaning by mouth).
+        "BID" stands for a dosing frequency, which represents Frequency (meaning twice a day).
+        </Analysis>
+    
+        <Outputs>
+        [{"entity_text": "Acetaminophen", "entity_type": "Drug"}, {"entity_text": "650 mg", "entity_type": "Strength"}, {"entity_text": "PO", "entity_type": "Route"}, {"entity_text": "BID", "entity_type": "Frequency"}]
+        </Outputs>
+
+    Input: Mesalamine DR 1200 mg PO BID 2.
+    Output: 
+        <Analysis>
+        The sentence "Mesalamine DR 1200 mg PO BID 2." contains the following medical entities:
+
+        "Mesalamine" is a Drug.
+        "DR" stands for Form (delayed-release).
+        "1200 mg" represents the Strength.
+        "PO" is the Route (by mouth).
+        "BID" is the Frequency (twice a day).
+        </Analysis>
+
+        <Outputs>
+        [{"entity_text": "Mesalamine DR", "entity_type": "Drug"}, {"entity_text": "1200 mg", "entity_type": "Strength"}, {"entity_text": "BID", "entity_type": "Frequency"}, {"entity_text": "PO", "entity_type": "Route"}]
+        </Outputs>
+
+    # Input placeholder
+    Below is the medical note for your reference. I will feed you with sentences from it one by one.
+    "{{input}}"
+
+
+Example 3 (multiple entity types with corresponding attributes):
+
+    # Task description
+    This is a named entity recognition task. Given a sentence from a medical note, annotate the events (EVENT) and time expressions (TIMEX3):
+
+    # Schema definition
+    Your output should contain: 
+        "entity_text": the exact wording as mentioned in the note.
+        "entity_type": type of the entity. It should be one of the "EVENT" or "TIMEX3".
+        if entity_type is "EVENT",
+            "type": the event type as one of the "TEST", "PROBLEM", "TREATMENT", "CLINICAL_DEPT", "EVIDENTIAL", or "OCCURRENCE".
+            "polarity": whether an EVENT is positive ("POS") or negative ("NAG"). For example, in “the patient reports headache, and denies chills”, the EVENT [headache] is positive in its polarity, and the EVENT [chills] is negative in its polarity.
+            "modality": whether an EVENT actually occurred or not. Must be one of the "FACTUAL", "CONDITIONAL", "POSSIBLE", or "PROPOSED".
+
+        if entity_type is "TIMEX3",
+            "type": the type as one of the "DATE", "TIME", "DURATION", or "FREQUENCY".
+            "val": the numeric value 1) DATE: [YYYY]-[MM]-[DD], 2) TIME: [hh]:[mm]:[ss], 3) DURATION: P[n][Y/M/W/D]. So, “for eleven days” will be 
+    represented as “P11D”, meaning a period of 11 days. 4)  R[n][duration], where n denotes the number of repeats. When the n is omitted, the expression denotes an unspecified amount of repeats. For example, “once a day for 3 days” is “R3P1D” (repeat the time interval of 1 day (P1D) for 3 times (R3)), twice every day is “RP12H” (repeat every 12 hours)
+            "mod": additional information regarding the temporal value of a time expression. Must be one of the:
+                “NA”: the default value, no relevant modifier is present;  
+                “MORE”, means “more than”, e.g. over 2 days (val = P2D, mod = MORE);  
+                “LESS”, means “less than”, e.g. almost 2 months (val = P2M, mod=LESS); 
+                “APPROX”, means “approximate”, e.g. nearly a week (val = P1W, mod=APPROX);  
+                “START”, describes the beginning of a period of time, e.g.  Christmas morning, 2005 (val= 2005-12-25, mod= START).  
+                “END”, describes the end of a period of time, e.g. late last year, (val = 2010, mod = END)
+                “MIDDLE”, describes the middle of a period of time, e.g. mid-September 2001 (val = 2001-09, mod = MIDDLE) 
+
+    # Thinking process
+    Approach this task step by step. Start with a recall section (<Recall>... </Recall>) that briefly summarize of the task description and schema definition for better understanding of the task. Followed by an analysis section (<Analysis>... </Analysis>) to analyze the input sentence. Identify important medical contents and clarify ambiguous concepts. Then, the output section (<Outputs>... </Outputs>) that list your final outputs following the defined format. 
+
+    # Output format definition
+    Your output should follow JSON format, 
+    if there are one of the EVENT or TIMEX3 entity mentions:
+        [
+            {"entity_text": "<Exact entity mentions as in the note>", "entity_type": "EVENT", "type": "<event type>", "polarity": "<event polarity>", "modality": "<event modality>"},
+            {"entity_text": "<Exact entity mentions as in the note>", "entity_type": "TIMEX3", "type": "<TIMEX3 type>", "val": "<time value>", "mod": "<additional information>"}
+            ...
+        ]
+    if there is no entity mentioned in the given note, just output an empty list:
+        []
+
+
+    # Examples
+    Below are some examples:
+
+    Input: At 9/7/93 , 1:00 a.m. , intravenous fluids rate was decreased to 50 cc&apos;s per hour , total fluids given during the first 24 hours were 140 to 150 cc&apos;s per kilo per day .
+    Output: 
+        <Recall>
+        This is a named entity recognition task that focuses on extracting medical events (EVENT) and time expressions (TIMEX3). Events are categorized by their type (TEST, PROBLEM, TREATMENT, etc.), polarity (POS or NEG), and modality (FACTUAL, CONDITIONAL, POSSIBLE, or PROPOSED). Time expressions are identified as either DATE, TIME, DURATION, or FREQUENCY and include specific values or modifiers where applicable.
+        </Recall>
+
+        <Analysis>
+        In this sentence:
+
+        "9/7/93" represents a TIMEX3 entity for the date.
+        "1:00 a.m." is a TIMEX3 entity representing the time.
+        "first 24 hours" refers to a TIMEX3 entity of duration.
+        "intravenous fluids rate was decreased" is an EVENT referring to a TREATMENT event with a negative polarity (as it was "decreased") and a FACTUAL modality (it actually happened).
+        "total fluids given during the first 24 hours" is another EVENT representing a TREATMENT that is FACTUAL in its modality.
+        </Analysis>
+    
+        <Outputs>
+        [{"entity_text": "intravenous fluids", "entity_type": "EVENT", "type": "TREATMENT", "polarity": "POS", "modality": "FACTUAL"},
+            {"entity_text": "decreased", "entity_type": "EVENT", "type": "OCCURRENCE", "polarity": "POS", "modality": "FACTUAL"},
+            {"entity_text": "total fluids", "entity_type": "EVENT", "type": "TREATMENT", "polarity": "POS", "modality": "FACTUAL"}, 
+            {"entity_text": "9/7/93 , 1:00 a.m.", "entity_type": "TIMEX3", "type": "TIME", "val": "1993-09-07T01:00", "mod": "NA"},
+            {"entity_text": "24 hours", "entity_type": "TIMEX3", "type": "DURATION", "val": "PT24H", "mod": "NA"}]
+        </Outputs>
+
+    Input: At that time it appeared well adhered to the underlying skin .
+    Output: 
+        <Recall>
+        This is a named entity recognition task focused on extracting medical events (EVENT) and time expressions (TIMEX3). Events are categorized by their type (e.g., TEST, PROBLEM, TREATMENT), polarity (POS or NEG), and modality (FACTUAL, CONDITIONAL, POSSIBLE, or PROPOSED). Time expressions are categorized as DATE, TIME, DURATION, or FREQUENCY, and include values or modifiers where applicable.
+        </Recall>
+
+        <Analysis>
+        In this sentence:
+
+        "At that time" refers to a TIMEX3 entity that is vague, so it can be considered as a TIME with an unspecified value.
+        "appeared well adhered to the underlying skin" describes an EVENT that likely indicates a PROBLEM (the condition of the skin) and has a POS polarity (since it is "well adhered") with a FACTUAL modality (it actually occurred).
+        </Analysis>
+
+        <Outputs>
+        [{"entity_text": "it", "entity_type": "EVENT", "type": "TREATMENT", "polarity": "POS", "modality": "FACTUAL"},
+            {"entity_text": "well adhered", "entity_type": "EVENT", "type": "OCCURRENCE", "polarity": "POS", "modality": "FACTUAL"}]
+        </Outputs>
+
+    # Input placeholder
+    Below is the entire medical note for your reference. I will feed you with sentences from it one by one.
+    "{{input}}"

llm_ie-0.3.2/src/llm_ie/asset/prompt_guide/SentenceReviewFrameExtractor_prompt_guide.txt

@@ -0,0 +1,145 @@
+Prompt Template Design:
+
+1. Task Description:  
+   Provide a detailed description of the task, including the background and the type of task (e.g., named entity recognition).
+
+2. Schema Definition:  
+   List the key concepts that should be extracted, and provide clear definitions for each one.
+
+3. Output Format Definition:  
+   The output should be a JSON list, where each element is a dictionary representing a frame (an entity along with its attributes). Each dictionary must include a key that holds the entity text. This key can be named "entity_text" or anything else depend on the context. The attributes can either be flat (e.g., {"entity_text": "<entity_text>", "attr1": "<attr1>", "attr2": "<attr2>"}) or nested (e.g., {"entity_text": "<entity_text>", "attributes": {"attr1": "<attr1>", "attr2": "<attr2>"}}).
+
+4. Optional: Hints:  
+   Provide itemized hints for the information extractors to guide the extraction process.
+
+5. Optional: Examples:  
+   Include examples in the format:  
+    Input: ...  
+    Output: ...
+
+6. Input Placeholder:  
+   The template must include a placeholder in the format {{<placeholder_name>}} for the input text. The placeholder name can be customized as needed.
+   
+
+Example 1 (single entity type with attributes):
+
+    # Task description
+    The paragraph below is from the Food and Drug Administration (FDA) Clinical Pharmacology Section of Labeling for Human Prescription Drug and Biological Products, Adverse reactions section. Please carefully review it and extract the adverse reactions and percentages. Note that each adverse reaction is nested under a clinical trial and potentially an arm. Your output should take that into consideration.
+
+    # Schema definition
+    Your output should contain: 
+        "ClinicalTrial" which is the name of the trial, 
+        If applicable, "Arm" which is the arm within the clinical trial, 
+        "AdverseReaction" which is the name of the adverse reaction,
+        If applicable, "Percentage" which is the occurance of the adverse reaction within the trial and arm,
+        "Evidence" which is the EXACT sentence in the text where you found the AdverseReaction from
+
+    # Output format definition
+    Your output should follow JSON format, for example:
+    [
+        {"ClinicalTrial": "<Clinical trial name or number>", "Arm": "<name of arm>", "AdverseReaction": "<Adverse reaction text>", "Percentage": "<a percent>", "Evidence": "<exact sentence from the text>"},
+        {"ClinicalTrial": "<Clinical trial name or number>", "Arm": "<name of arm>", "AdverseReaction": "<Adverse reaction text>", "Percentage": "<a percent>", "Evidence": "<exact sentence from the text>"} 
+    ]
+
+    # Additional hints
+    Your output should be 100% based on the provided content. DO NOT output fake numbers. 
+    If there is no specific arm, just omit the "Arm" key. If the percentage is not reported, just omit the "Percentage" key. The "Evidence" should always be provided.
+
+    # Input placeholder
+    Below is the Adverse reactions section for your reference. I will feed you with sentences from it one by one. 
+    {{input}}
+
+
+Example 2 (multiple entity types):
+
+    # Task description
+    This is a named entity recognition task. Given a sentence from a medical note, annotate the Drug, Form, Strength, Frequency, Route, Dosage, Reason, ADE, and Duration.
+
+    # Schema definition
+    Your output should contain: 
+        "entity_text": the exact wording as mentioned in the note.
+        "entity_type": type of the entity. It should be one of the "Drug", "Form", "Strength", "Frequency", "Route", "Dosage", "Reason", "ADE", or "Duration".
+
+    # Output format definition
+    Your output should follow JSON format, 
+    if there are one of the entity mentions: Drug, Form, Strength, Frequency, Route, Dosage, Reason, ADE, or Duration:
+        [{"entity_text": "<Exact entity mentions as in the note>", "entity_type": "<entity type as listed above>"},
+        {"entity_text": "<Exact entity mentions as in the note>", "entity_type": "<entity type as listed above>"}]
+    if there is no entity mentioned in the given note, just output an empty list:
+        []
+
+    I am only interested in the extracted contents in []. Do NOT explain your answer.
+
+    # Examples
+    Below are some examples:
+
+    Input: Acetaminophen 650 mg PO BID 5.
+    Output: [{"entity_text": "Acetaminophen", "entity_type": "Drug"}, {"entity_text": "650 mg", "entity_type": "Strength"}, {"entity_text": "PO", "entity_type": "Route"}, {"entity_text": "BID", "entity_type": "Frequency"}]
+
+    Input: Mesalamine DR 1200 mg PO BID 2.
+    Output: [{"entity_text": "Mesalamine DR", "entity_type": "Drug"}, {"entity_text": "1200 mg", "entity_type": "Strength"}, {"entity_text": "BID", "entity_type": "Frequency"}, {"entity_text": "PO", "entity_type": "Route"}]
+
+
+    # Input placeholder
+    Below is the medical note for your reference. I will feed you with sentences from it one by one.
+    "{{input}}"
+
+
+Example 3 (multiple entity types with corresponding attributes):
+
+    # Task description
+    This is a named entity recognition task. Given a sentence from a medical note, annotate the events (EVENT) and time expressions (TIMEX3):
+
+    # Schema definition
+    Your output should contain: 
+        "entity_text": the exact wording as mentioned in the note.
+        "entity_type": type of the entity. It should be one of the "EVENT" or "TIMEX3".
+        if entity_type is "EVENT",
+            "type": the event type as one of the "TEST", "PROBLEM", "TREATMENT", "CLINICAL_DEPT", "EVIDENTIAL", or "OCCURRENCE".
+            "polarity": whether an EVENT is positive ("POS") or negative ("NAG"). For example, in “the patient reports headache, and denies chills”, the EVENT [headache] is positive in its polarity, and the EVENT [chills] is negative in its polarity.
+            "modality": whether an EVENT actually occurred or not. Must be one of the "FACTUAL", "CONDITIONAL", "POSSIBLE", or "PROPOSED".
+
+        if entity_type is "TIMEX3",
+            "type": the type as one of the "DATE", "TIME", "DURATION", or "FREQUENCY".
+            "val": the numeric value 1) DATE: [YYYY]-[MM]-[DD], 2) TIME: [hh]:[mm]:[ss], 3) DURATION: P[n][Y/M/W/D]. So, “for eleven days” will be 
+    represented as “P11D”, meaning a period of 11 days. 4)  R[n][duration], where n denotes the number of repeats. When the n is omitted, the expression denotes an unspecified amount of repeats. For example, “once a day for 3 days” is “R3P1D” (repeat the time interval of 1 day (P1D) for 3 times (R3)), twice every day is “RP12H” (repeat every 12 hours)
+            "mod": additional information regarding the temporal value of a time expression. Must be one of the:
+                “NA”: the default value, no relevant modifier is present;  
+                “MORE”, means “more than”, e.g. over 2 days (val = P2D, mod = MORE);  
+                “LESS”, means “less than”, e.g. almost 2 months (val = P2M, mod=LESS); 
+                “APPROX”, means “approximate”, e.g. nearly a week (val = P1W, mod=APPROX);  
+                “START”, describes the beginning of a period of time, e.g.  Christmas morning, 2005 (val= 2005-12-25, mod= START).  
+                “END”, describes the end of a period of time, e.g. late last year, (val = 2010, mod = END)
+                “MIDDLE”, describes the middle of a period of time, e.g. mid-September 2001 (val = 2001-09, mod = MIDDLE) 
+
+    # Output format definition
+    Your output should follow JSON format, 
+    if there are one of the EVENT or TIMEX3 entity mentions:
+        [
+            {"entity_text": "<Exact entity mentions as in the note>", "entity_type": "EVENT", "type": "<event type>", "polarity": "<event polarity>", "modality": "<event modality>"},
+            {"entity_text": "<Exact entity mentions as in the note>", "entity_type": "TIMEX3", "type": "<TIMEX3 type>", "val": "<time value>", "mod": "<additional information>"}
+            ...
+        ]
+    if there is no entity mentioned in the given note, just output an empty list:
+        []
+
+    I am only interested in the extracted contents in []. Do NOT explain your answer.
+
+    # Examples
+    Below are some examples:
+
+    Input: At 9/7/93 , 1:00 a.m. , intravenous fluids rate was decreased to 50 cc&apos;s per hour , total fluids given during the first 24 hours were 140 to 150 cc&apos;s per kilo per day .
+    Output: [{"entity_text": "intravenous fluids", "entity_type": "EVENT", "type": "TREATMENT", "polarity": "POS", "modality": "FACTUAL"},
+            {"entity_text": "decreased", "entity_type": "EVENT", "type": "OCCURRENCE", "polarity": "POS", "modality": "FACTUAL"},
+            {"entity_text": "total fluids", "entity_type": "EVENT", "type": "TREATMENT", "polarity": "POS", "modality": "FACTUAL"}, 
+            {"entity_text": "9/7/93 , 1:00 a.m.", "entity_type": "TIMEX3", "type": "TIME", "val": "1993-09-07T01:00", "mod": "NA"},
+            {"entity_text": "24 hours", "entity_type": "TIMEX3", "type": "DURATION", "val": "PT24H", "mod": "NA"}]
+
+    Input: At that time it appeared well adhered to the underlying skin .
+    Output: [{"entity_text": "it", "entity_type": "EVENT", "type": "TREATMENT", "polarity": "POS", "modality": "FACTUAL"},
+            {"entity_text": "well adhered", "entity_type": "EVENT", "type": "OCCURRENCE", "polarity": "POS", "modality": "FACTUAL"}]
+
+
+    # Input placeholder
+    Below is the entire medical note for your reference. I will feed you with sentences from it one by one.
+    "{{input}}"

{llm_ie-0.3.0 → llm_ie-0.3.2}/src/llm_ie/extractors.py

@@ -5,9 +5,11 @@ import inspect
 import importlib.resources
 import warnings
 import itertools
-from typing import List, Dict, Tuple, Union, Callable
+from typing import Set, List, Dict, Tuple, Union, Callable
 from llm_ie.data_types import LLMInformationExtractionFrame, LLMInformationExtractionDocument
 from llm_ie.engines import InferenceEngine
+from colorama import Fore, Style
+from nltk.tokenize import RegexpTokenizer
 
 
 class Extractor:
@@ -36,7 +38,7 @@ class Extractor:
         This method returns the pre-defined prompt guideline for the extractor from the package asset.
         """
         file_path = importlib.resources.files('llm_ie.asset.prompt_guide').joinpath(f"{cls.__name__}_prompt_guide.txt")
-        with open(file_path, 'r') as f:
+        with open(file_path, 'r', encoding="utf-8") as f:
             return f.read()
 
 
@@ -115,7 +117,7 @@ class Extractor:
                 dict_obj = json.loads(dict_str)
                 out.append(dict_obj)
             except json.JSONDecodeError:
-                print(f'Post-processing failed at:\n{dict_str}')
+                warnings.warn(f'Post-processing failed:\n{dict_str}', RuntimeWarning)
         return out
     
 
@@ -138,9 +140,68 @@ class FrameExtractor(Extractor):
                          prompt_template=prompt_template,
                          system_prompt=system_prompt,
                          **kwrs)
-    
+        self.tokenizer = RegexpTokenizer(r'\w+|[^\w\s]')
+
+
+    def _jaccard_score(self, s1:set, s2:set) -> float:
+        """
+        This method calculates the Jaccard score between two sets of word tokens.
+        """
+        return len(s1.intersection(s2)) / len(s1.union(s2))
+
+
+    def _get_word_tokens(self, text) -> Tuple[List[str], List[Tuple[int]]]:
+        """
+        This method tokenizes the input text into a list of word tokens and their spans.
+        """
+        tokens = []
+        spans = []
+        for span in self.tokenizer.span_tokenize(text):
+            spans.append(span)
+            start, end = span
+            tokens.append(text[start:end])
+        return tokens, spans
+
+
+    def _get_closest_substring(self, text:str, pattern:str, buffer_size:float=0.2) -> Tuple[Tuple[int, int], float]:
+        """
+        This method finds the closest (highest Jaccard score) substring in text that matches the pattern.
+
+        Parameters
+        ----------
+        text : str
+            the input text.
+        pattern : str
+            the pattern to match.
+        buffer_size : float, Optional
+            the buffer size for the matching window. Default is 20% of pattern length.
+
+        Returns : Tuple[Tuple[int, int], float]
+            a tuple of 2-tuple span and Jaccard score.
+        """
+        text_tokens, text_spans = self._get_word_tokens(text)
+        pattern_tokens, _ = self._get_word_tokens(pattern)
+        pattern_tokens = set(pattern_tokens)
+        window_size = len(pattern_tokens)
+        window_size_min = int(window_size * (1 - buffer_size))
+        window_size_max = int(window_size * (1 + buffer_size))
+        closest_substring_spans = None
+        best_score = 0
+        
+        for i in range(len(text_tokens) - window_size_max):
+            for w in range(window_size_min, window_size_max): 
+                sub_str_tokens = set(text_tokens[i:i + w])
+                score = self._jaccard_score(sub_str_tokens, pattern_tokens)
+                if score > best_score:
+                    best_score = score
+                    sub_string_word_spans = text_spans[i:i + w]
+                    closest_substring_spans = (sub_string_word_spans[0][0], sub_string_word_spans[-1][-1])
+
+        return closest_substring_spans, best_score
 
-    def _find_entity_spans(self, text: str, entities: List[str], case_sensitive:bool=False) -> List[Tuple[int]]:
+
+    def _find_entity_spans(self, text: str, entities: List[str], case_sensitive:bool=False, 
+                           fuzzy_match:bool=True, fuzzy_buffer_size:float=0.2, fuzzy_score_cutoff:float=0.8) -> List[Tuple[int]]:
         """
         This function inputs a text and a list of entity text, 
         outputs a list of spans (2-tuple) for each entity.
@@ -150,19 +211,46 @@ class FrameExtractor(Extractor):
         ----------
         text : str
             text that contains entities
+        entities : List[str]
+            a list of entity text to find in the text
+        case_sensitive : bool, Optional
+            if True, entity text matching will be case-sensitive.
+        fuzzy_match : bool, Optional
+            if True, fuzzy matching will be applied to find entity text.
+        fuzzy_buffer_size : float, Optional
+            the buffer size for fuzzy matching. Default is 20% of entity text length.
+        fuzzy_score_cutoff : float, Optional
+            the Jaccard score cutoff for fuzzy matching. 
+            Matched entity text must have a score higher than this value or a None will be returned.
         """
+        # Handle case sensitivity
+        if not case_sensitive:
+            text = text.lower()
+
+        # Match entities
         entity_spans = []
-        for entity in entities:            
-            if case_sensitive:
-                match = re.search(re.escape(entity), text)
-            else: 
-                match = re.search(re.escape(entity), text, re.IGNORECASE)
-                
+        for entity in entities:          
+            if not case_sensitive:
+                entity = entity.lower()
+
+            # Exact match  
+            match = re.search(re.escape(entity), text)
             if match:
                 start, end = match.span()
                 entity_spans.append((start, end))
                 # Replace the found entity with spaces to avoid finding the same instance again
                 text = text[:start] + ' ' * (end - start) + text[end:]
+            # Fuzzy match
+            elif fuzzy_match:
+                closest_substring_span, best_score = self._get_closest_substring(text, entity, buffer_size=fuzzy_buffer_size)
+                if best_score >= fuzzy_score_cutoff:
+                    entity_spans.append(closest_substring_span)
+                    # Replace the found entity with spaces to avoid finding the same instance again
+                    text = text[:closest_substring_span[0]] + ' ' * (closest_substring_span[1] - closest_substring_span[0]) + text[closest_substring_span[1]:]
+                else:
+                    entity_spans.append(None)
+
+            # No match
             else:
                 entity_spans.append(None)
 
@@ -275,7 +363,9 @@ class BasicFrameExtractor(FrameExtractor):
     
 
     def extract_frames(self, text_content:Union[str, Dict[str,str]], entity_key:str, max_new_tokens:int=2048, 
-                       temperature:float=0.0, document_key:str=None, **kwrs) -> List[LLMInformationExtractionFrame]:
+                       temperature:float=0.0, document_key:str=None, stream:bool=False,
+                       case_sensitive:bool=False, fuzzy_match:bool=True, fuzzy_buffer_size:float=0.2, 
+                       fuzzy_score_cutoff:float=0.8, **kwrs) -> List[LLMInformationExtractionFrame]:
         """
         This method inputs a text and outputs a list of LLMInformationExtractionFrame
         It use the extract() method and post-process outputs into frames.
@@ -295,14 +385,35 @@ class BasicFrameExtractor(FrameExtractor):
         document_key : str, Optional
             specify the key in text_content where document text is. 
             If text_content is str, this parameter will be ignored.
+        stream : bool, Optional
+            if True, LLM generated text will be printed in terminal in real-time.
+        case_sensitive : bool, Optional
+            if True, entity text matching will be case-sensitive.
+        fuzzy_match : bool, Optional
+            if True, fuzzy matching will be applied to find entity text.
+        fuzzy_buffer_size : float, Optional
+            the buffer size for fuzzy matching. Default is 20% of entity text length.
+        fuzzy_score_cutoff : float, Optional
+            the Jaccard score cutoff for fuzzy matching. 
+            Matched entity text must have a score higher than this value or a None will be returned.
 
         Return : str
             a list of frames.
         """
         frame_list = []
         gen_text = self.extract(text_content=text_content, 
-                                max_new_tokens=max_new_tokens, temperature=temperature, **kwrs)
-        entity_json = self._extract_json(gen_text=gen_text)
+                                max_new_tokens=max_new_tokens, 
+                                temperature=temperature, 
+                                stream=stream,
+                                **kwrs)
+
+        entity_json = []
+        for entity in self._extract_json(gen_text=gen_text):
+            if entity_key in entity:
+                entity_json.append(entity)
+            else:
+                warnings.warn(f'Extractor output "{entity}" does not have entity_key ("{entity_key}"). This frame will be dropped.', RuntimeWarning)
+                
         if isinstance(text_content, str):
             text = text_content
         elif isinstance(text_content, dict):
@@ -310,7 +421,10 @@ class BasicFrameExtractor(FrameExtractor):
 
         spans = self._find_entity_spans(text=text, 
                                         entities=[e[entity_key] for e in entity_json], 
-                                        case_sensitive=False)
+                                        case_sensitive=case_sensitive,
+                                        fuzzy_match=fuzzy_match,
+                                        fuzzy_buffer_size=fuzzy_buffer_size,
+                                        fuzzy_score_cutoff=fuzzy_score_cutoff)
         
         for i, (ent, span) in enumerate(zip(entity_json, spans)):
             if span is not None:
@@ -325,8 +439,8 @@ class BasicFrameExtractor(FrameExtractor):
         
 
 class ReviewFrameExtractor(BasicFrameExtractor):
-    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, review_prompt:str, 
-                 review_mode:str, system_prompt:str=None, **kwrs):
+    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, 
+                 review_mode:str, review_prompt:str=None,system_prompt:str=None, **kwrs):
         """
         This class add a review step after the BasicFrameExtractor.
         The Review process asks LLM to review its output and:
@@ -340,8 +454,9 @@ class ReviewFrameExtractor(BasicFrameExtractor):
             the LLM inferencing engine object. Must implements the chat() method.
         prompt_template : str
             prompt template with "{{<placeholder name>}}" placeholder.
-        review_prompt : str
-            the prompt text that ask LLM to review. Specify addition or revision in the instruction. 
+        review_prompt : str: Optional
+            the prompt text that ask LLM to review. Specify addition or revision in the instruction.
+            if not provided, a default review prompt will be used. 
         review_mode : str
             review mode. Must be one of {"addition", "revision"}
             addition mode only ask LLM to add new frames, while revision mode ask LLM to regenerate.
@@ -350,11 +465,20 @@ class ReviewFrameExtractor(BasicFrameExtractor):
         """
         super().__init__(inference_engine=inference_engine, prompt_template=prompt_template, 
                          system_prompt=system_prompt, **kwrs)
-        self.review_prompt = review_prompt
         if review_mode not in {"addition", "revision"}: 
             raise ValueError('review_mode must be one of {"addition", "revision"}.')
         self.review_mode = review_mode
 
+        if review_prompt:
+            self.review_prompt = review_prompt
+        else:
+            file_path = importlib.resources.files('llm_ie.asset.default_prompts').\
+                joinpath(f"{self.__class__.__name__}_{self.review_mode}_review_prompt.txt")
+            with open(file_path, 'r', encoding="utf-8") as f:
+                self.review_prompt = f.read()
+
+            warnings.warn(f'Custom review prompt not provided. The default review prompt is used:\n"{self.review_prompt}"', UserWarning)
+
 
     def extract(self, text_content:Union[str, Dict[str,str]], 
                 max_new_tokens:int=4096, temperature:float=0.0, stream:bool=False, **kwrs) -> str:
@@ -377,12 +501,15 @@ class ReviewFrameExtractor(BasicFrameExtractor):
         Return : str
             the output from LLM. Need post-processing.
         """
-        # Pormpt extraction
         messages = []
         if self.system_prompt:
             messages.append({'role': 'system', 'content': self.system_prompt})
 
         messages.append({'role': 'user', 'content': self._get_user_prompt(text_content)})
+        # Initial output
+        if stream:
+            print(f"{Fore.BLUE}Initial Output:{Style.RESET_ALL}")
+
         initial = self.inference_engine.chat(
                         messages=messages,
                         max_new_tokens=max_new_tokens, 
@@ -395,6 +522,8 @@ class ReviewFrameExtractor(BasicFrameExtractor):
         messages.append({'role': 'assistant', 'content': initial})
         messages.append({'role': 'user', 'content': self.review_prompt})
 
+        if stream:
+            print(f"\n{Fore.YELLOW}Review:{Style.RESET_ALL}")
         review = self.inference_engine.chat(
                         messages=messages, 
                         max_new_tokens=max_new_tokens, 
@@ -459,7 +588,7 @@ class SentenceFrameExtractor(FrameExtractor):
     
     
     def extract(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=512, 
-                document_key:str=None, multi_turn:bool=True, temperature:float=0.0, stream:bool=False, **kwrs) -> List[Dict[str,str]]:
+                document_key:str=None, multi_turn:bool=False, temperature:float=0.0, stream:bool=False, **kwrs) -> List[Dict[str,str]]:
         """
         This method inputs a text and outputs a list of outputs per sentence. 
 
@@ -507,8 +636,8 @@ class SentenceFrameExtractor(FrameExtractor):
         for sent in sentences:
             messages.append({'role': 'user', 'content': sent['sentence_text']})
             if stream:
-                print(f"\n\nSentence: \n{sent['sentence_text']}\n")
-                print("Extraction:")
+                print(f"\n\n{Fore.GREEN}Sentence: {Style.RESET_ALL}\n{sent['sentence_text']}\n")
+                print(f"{Fore.BLUE}Extraction:{Style.RESET_ALL}")
 
             gen_text = self.inference_engine.chat(
                             messages=messages, 
@@ -534,7 +663,9 @@ class SentenceFrameExtractor(FrameExtractor):
     
 
     def extract_frames(self, text_content:Union[str, Dict[str,str]], entity_key:str, max_new_tokens:int=512, 
-                       document_key:str=None, multi_turn:bool=True, temperature:float=0.0, stream:bool=False, **kwrs) -> List[LLMInformationExtractionFrame]:
+                       document_key:str=None, multi_turn:bool=False, temperature:float=0.0, stream:bool=False,
+                       case_sensitive:bool=False, fuzzy_match:bool=True, fuzzy_buffer_size:float=0.2, fuzzy_score_cutoff:float=0.8,
+                        **kwrs) -> List[LLMInformationExtractionFrame]:
         """
         This method inputs a text and outputs a list of LLMInformationExtractionFrame
         It use the extract() method and post-process outputs into frames.
@@ -562,6 +693,15 @@ class SentenceFrameExtractor(FrameExtractor):
             the temperature for token sampling.
         stream : bool, Optional
             if True, LLM generated text will be printed in terminal in real-time. 
+        case_sensitive : bool, Optional
+            if True, entity text matching will be case-sensitive.
+        fuzzy_match : bool, Optional
+            if True, fuzzy matching will be applied to find entity text.
+        fuzzy_buffer_size : float, Optional
+            the buffer size for fuzzy matching. Default is 20% of entity text length.
+        fuzzy_score_cutoff : float, Optional
+            the Jaccard score cutoff for fuzzy matching. 
+            Matched entity text must have a score higher than this value or a None will be returned.
 
         Return : str
             a list of frames.
@@ -575,9 +715,19 @@ class SentenceFrameExtractor(FrameExtractor):
                                            **kwrs)
         frame_list = []
         for sent in llm_output_sentence:
-            entity_json = self._extract_json(gen_text=sent['gen_text'])
+            entity_json = []
+            for entity in self._extract_json(gen_text=sent['gen_text']):
+                if entity_key in entity:
+                    entity_json.append(entity)
+                else:
+                    warnings.warn(f'Extractor output "{entity}" does not have entity_key ("{entity_key}"). This frame will be dropped.', RuntimeWarning)
+
             spans = self._find_entity_spans(text=sent['sentence_text'], 
-                                                entities=[e[entity_key] for e in entity_json], case_sensitive=False)
+                                            entities=[e[entity_key] for e in entity_json], 
+                                            case_sensitive=case_sensitive,
+                                            fuzzy_match=fuzzy_match,
+                                            fuzzy_buffer_size=fuzzy_buffer_size,
+                                            fuzzy_score_cutoff=fuzzy_score_cutoff)
             for ent, span in zip(entity_json, spans):
                 if span is not None:
                     start, end = span
@@ -592,6 +742,248 @@ class SentenceFrameExtractor(FrameExtractor):
         return frame_list
 
 
+class SentenceReviewFrameExtractor(SentenceFrameExtractor):
+    def __init__(self, inference_engine:InferenceEngine, prompt_template:str,  
+                 review_mode:str, review_prompt:str=None, system_prompt:str=None, **kwrs):
+        """
+        This class adds a review step after the SentenceFrameExtractor.
+        For each sentence, the review process asks LLM to review its output and:
+            1. add more frames while keeping current. This is efficient for boosting recall. 
+            2. or, regenerate frames (add new and delete existing). 
+        Use the review_mode parameter to specify. Note that the review_prompt should instruct LLM accordingly.
+
+        Parameters:
+        ----------
+        inference_engine : InferenceEngine
+            the LLM inferencing engine object. Must implements the chat() method.
+        prompt_template : str
+            prompt template with "{{<placeholder name>}}" placeholder.
+        review_prompt : str: Optional
+            the prompt text that ask LLM to review. Specify addition or revision in the instruction.
+            if not provided, a default review prompt will be used. 
+        review_mode : str
+            review mode. Must be one of {"addition", "revision"}
+            addition mode only ask LLM to add new frames, while revision mode ask LLM to regenerate.
+        system_prompt : str, Optional
+            system prompt.
+        """
+        super().__init__(inference_engine=inference_engine, prompt_template=prompt_template, 
+                         system_prompt=system_prompt, **kwrs)
+
+        if review_mode not in {"addition", "revision"}: 
+            raise ValueError('review_mode must be one of {"addition", "revision"}.')
+        self.review_mode = review_mode
+
+        if review_prompt:
+            self.review_prompt = review_prompt
+        else:
+            file_path = importlib.resources.files('llm_ie.asset.default_prompts').\
+                joinpath(f"{self.__class__.__name__}_{self.review_mode}_review_prompt.txt")
+            with open(file_path, 'r', encoding="utf-8") as f:
+                self.review_prompt = f.read()
+
+            warnings.warn(f'Custom review prompt not provided. The default review prompt is used:\n"{self.review_prompt}"', UserWarning)
+
+
+    def extract(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=512, 
+                document_key:str=None, multi_turn:bool=False, temperature:float=0.0, stream:bool=False, **kwrs) -> List[Dict[str,str]]:
+        """
+        This method inputs a text and outputs a list of outputs per sentence. 
+
+        Parameters:
+        ----------
+        text_content : Union[str, Dict[str,str]]
+            the input text content to put in prompt template. 
+            If str, the prompt template must has only 1 placeholder {{<placeholder name>}}, regardless of placeholder name.
+            If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
+        max_new_tokens : str, Optional
+            the max number of new tokens LLM should generate. 
+        document_key : str, Optional
+            specify the key in text_content where document text is. 
+            If text_content is str, this parameter will be ignored.
+        multi_turn : bool, Optional
+            multi-turn conversation prompting. 
+            If True, sentences and LLM outputs will be appended to the input message and carry-over. 
+            If False, only the current sentence is prompted. 
+            For LLM inference engines that supports prompt cache (e.g., Llama.Cpp, Ollama), use multi-turn conversation prompting
+            can better utilize the KV caching. 
+        temperature : float, Optional
+            the temperature for token sampling.
+        stream : bool, Optional
+            if True, LLM generated text will be printed in terminal in real-time. 
+
+        Return : str
+            the output from LLM. Need post-processing.
+        """
+        # define output
+        output = []
+        # sentence tokenization
+        if isinstance(text_content, str):
+            sentences = self._get_sentences(text_content)
+        elif isinstance(text_content, dict):
+            sentences = self._get_sentences(text_content[document_key])
+        # construct chat messages
+        messages = []
+        if self.system_prompt:
+            messages.append({'role': 'system', 'content': self.system_prompt})
+
+        messages.append({'role': 'user', 'content': self._get_user_prompt(text_content)})
+        messages.append({'role': 'assistant', 'content': 'Sure, please start with the first sentence.'})
+
+        # generate sentence by sentence
+        for sent in sentences:
+            messages.append({'role': 'user', 'content': sent['sentence_text']})
+            if stream:
+                print(f"\n\n{Fore.GREEN}Sentence: {Style.RESET_ALL}\n{sent['sentence_text']}\n")
+                print(f"{Fore.BLUE}Initial Output:{Style.RESET_ALL}")
+
+            initial = self.inference_engine.chat(
+                            messages=messages, 
+                            max_new_tokens=max_new_tokens, 
+                            temperature=temperature,
+                            stream=stream,
+                            **kwrs
+                        )
+            
+            # Review
+            if stream:
+                print(f"\n{Fore.YELLOW}Review:{Style.RESET_ALL}")
+            messages.append({'role': 'assistant', 'content': initial})
+            messages.append({'role': 'user', 'content': self.review_prompt})
+
+            review = self.inference_engine.chat(
+                            messages=messages, 
+                            max_new_tokens=max_new_tokens, 
+                            temperature=temperature,
+                            stream=stream,
+                            **kwrs
+                        )
+            
+            # Output
+            if self.review_mode == "revision":
+                gen_text = review
+            elif self.review_mode == "addition":
+                gen_text = initial + '\n' + review
+            
+            if multi_turn:
+                # update chat messages with LLM outputs
+                messages.append({'role': 'assistant', 'content': review})
+            else:
+                # delete sentence and review so that message is reset
+                del messages[-3:]
+
+            # add to output
+            output.append({'sentence_start': sent['start'],
+                            'sentence_end': sent['end'],
+                            'sentence_text': sent['sentence_text'],
+                            'gen_text': gen_text})
+        return output
+        
+
+class SentenceCoTFrameExtractor(SentenceFrameExtractor):
+    from nltk.tokenize.punkt import PunktSentenceTokenizer
+    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None, **kwrs):
+        """
+        This class performs sentence-based Chain-of-thoughts (CoT) information extraction.
+        A simulated chat follows this process:
+            1. system prompt (optional)
+            2. user instructions (schema, background, full text, few-shot example...)
+            3. user input first sentence
+            4. assistant analyze the sentence
+            5. assistant extract outputs
+            6. repeat #3, #4, #5
+
+        Input system prompt (optional), prompt template (with user instructions), 
+        and specify a LLM.
+
+        Parameters
+        ----------
+        inference_engine : InferenceEngine
+            the LLM inferencing engine object. Must implements the chat() method.
+        prompt_template : str
+            prompt template with "{{<placeholder name>}}" placeholder.
+        system_prompt : str, Optional
+            system prompt.
+        """
+        super().__init__(inference_engine=inference_engine, prompt_template=prompt_template, 
+                         system_prompt=system_prompt, **kwrs)
+        
+
+    def extract(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=512, 
+                document_key:str=None, multi_turn:bool=False, temperature:float=0.0, stream:bool=False, **kwrs) -> List[Dict[str,str]]:
+        """
+        This method inputs a text and outputs a list of outputs per sentence. 
+
+        Parameters:
+        ----------
+        text_content : Union[str, Dict[str,str]]
+            the input text content to put in prompt template. 
+            If str, the prompt template must has only 1 placeholder {{<placeholder name>}}, regardless of placeholder name.
+            If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
+        max_new_tokens : str, Optional
+            the max number of new tokens LLM should generate. 
+        document_key : str, Optional
+            specify the key in text_content where document text is. 
+            If text_content is str, this parameter will be ignored.
+        multi_turn : bool, Optional
+            multi-turn conversation prompting. 
+            If True, sentences and LLM outputs will be appended to the input message and carry-over. 
+            If False, only the current sentence is prompted. 
+            For LLM inference engines that supports prompt cache (e.g., Llama.Cpp, Ollama), use multi-turn conversation prompting
+            can better utilize the KV caching. 
+        temperature : float, Optional
+            the temperature for token sampling.
+        stream : bool, Optional
+            if True, LLM generated text will be printed in terminal in real-time. 
+
+        Return : str
+            the output from LLM. Need post-processing.
+        """
+        # define output
+        output = []
+        # sentence tokenization
+        if isinstance(text_content, str):
+            sentences = self._get_sentences(text_content)
+        elif isinstance(text_content, dict):
+            sentences = self._get_sentences(text_content[document_key])
+        # construct chat messages
+        messages = []
+        if self.system_prompt:
+            messages.append({'role': 'system', 'content': self.system_prompt})
+
+        messages.append({'role': 'user', 'content': self._get_user_prompt(text_content)})
+        messages.append({'role': 'assistant', 'content': 'Sure, please start with the first sentence.'})
+
+        # generate sentence by sentence
+        for sent in sentences:
+            messages.append({'role': 'user', 'content': sent['sentence_text']})
+            if stream:
+                print(f"\n\n{Fore.GREEN}Sentence: {Style.RESET_ALL}\n{sent['sentence_text']}\n")
+                print(f"{Fore.BLUE}CoT:{Style.RESET_ALL}")
+
+            gen_text = self.inference_engine.chat(
+                            messages=messages, 
+                            max_new_tokens=max_new_tokens, 
+                            temperature=temperature,
+                            stream=stream,
+                            **kwrs
+                        )
+            
+            if multi_turn:
+                # update chat messages with LLM outputs
+                messages.append({'role': 'assistant', 'content': gen_text})
+            else:
+                # delete sentence so that message is reset
+                del messages[-1]
+
+            # add to output
+            output.append({'sentence_start': sent['start'],
+                            'sentence_end': sent['end'],
+                            'sentence_text': sent['sentence_text'],
+                            'gen_text': gen_text})
+        return output
+    
+
 class RelationExtractor(Extractor):
     def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None, **kwrs):
         """
@@ -752,8 +1144,8 @@ class BinaryRelationExtractor(RelationExtractor):
         """
         roi_text = self._get_ROI(frame_1, frame_2, text, buffer_size=buffer_size)
         if stream:
-            print(f"\n\nROI text: \n{roi_text}\n")
-            print("Extraction:")
+            print(f"\n\n{Fore.GREEN}ROI text:{Style.RESET_ALL} \n{roi_text}\n")
+            print(f"{Fore.BLUE}Extraction:{Style.RESET_ALL}")
 
         messages = []
         if self.system_prompt:
@@ -904,8 +1296,8 @@ class MultiClassRelationExtractor(RelationExtractor):
         """
         roi_text = self._get_ROI(frame_1, frame_2, text, buffer_size=buffer_size)
         if stream:
-            print(f"\n\nROI text: \n{roi_text}\n")
-            print("Extraction:")
+            print(f"\n\n{Fore.GREEN}ROI text:{Style.RESET_ALL} \n{roi_text}\n")
+            print(f"{Fore.BLUE}Extraction:{Style.RESET_ALL}")
 
         messages = []
         if self.system_prompt:

{llm_ie-0.3.0 → llm_ie-0.3.2}/src/llm_ie/prompt_editor.py

@@ -1,13 +1,10 @@
 import sys
-from typing import Dict, Union
+from typing import Dict
 import importlib.resources
 from llm_ie.engines import InferenceEngine
 from llm_ie.extractors import FrameExtractor
 import re
-import colorama
 from colorama import Fore, Style
-import ipywidgets as widgets
-from IPython.display import display, HTML
 
     
 class PromptEditor:
@@ -90,7 +87,6 @@ class PromptEditor:
         """
         This method runs an interactive chat session in the terminal to help users write prompt templates.
         """
-        colorama.init(autoreset=True)
         file_path = importlib.resources.files('llm_ie.asset.PromptEditor_prompts').joinpath('chat.txt')
         with open(file_path, 'r') as f:
             chat_prompt_template = f.read()
@@ -123,6 +119,16 @@ class PromptEditor:
         """
         This method runs an interactive chat session in Jupyter/IPython using ipywidgets to help users write prompt templates.
         """
+        # Check if ipywidgets is installed
+        if importlib.util.find_spec("ipywidgets") is None:
+            raise ImportError("ipywidgets not found. Please install ipywidgets (```pip install ipywidgets```).")
+        import ipywidgets as widgets
+
+        # Check if IPython is installed
+        if importlib.util.find_spec("IPython") is None:
+            raise ImportError("IPython not found. Please install IPython (```pip install ipython```).")
+        from IPython.display import display, HTML
+
         # Load the chat prompt template from the resources
         file_path = importlib.resources.files('llm_ie.asset.PromptEditor_prompts').joinpath('chat.txt')
         with open(file_path, 'r') as f: