ai-parrot 0.3.6__tar.gz → 0.3.9__tar.gz

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/Makefile

@@ -5,14 +5,15 @@ venv:
 install:
 	# Install Parrot
 	pip install --upgrade python-datamodel
-	pip install --upgrade asyncdb[all]
+	pip install --upgrade asyncdb[default,bigquery]
 	pip install --upgrade navconfig[default]
-	pip install --upgrade navigator-api[locale]
+	pip install --upgrade navigator-api[uvloop,locale]
 	# Nav requirements:
 	pip install --upgrade navigator-session
 	pip install --upgrade navigator-auth
 	# QS requirements
-	pip install --upgrade querysource[analytics]
+	# pip install --upgrade querysource[analytics]
+	pip install --upgrade querysource
 	# and Parrot:
 	# pip install -e .[google,milvus,groq,analytics]
 

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ai-parrot
-Version: 0.3.6
+Version: 0.3.9
 Summary: Live Chatbots based on Langchain chatbots and Agents     Integrated into Navigator Framework or used into aiohttp applications.
 Home-page: https://github.com/phenobarbital/ai-parrot
 Author: Jesus Lara
@@ -108,6 +108,7 @@ Requires-Dist: ftfy==6.2.3; extra == "loaders"
 Requires-Dist: librosa==0.10.1; extra == "loaders"
 Requires-Dist: XlsxWriter==3.2.0; extra == "loaders"
 Requires-Dist: timm==1.0.9; extra == "loaders"
+Requires-Dist: easyocr==1.7.1; extra == "loaders"
 Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic==0.1.11; extra == "anthropic"
 Requires-Dist: anthropic==0.25.2; extra == "anthropic"

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/ai_parrot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ai-parrot
-Version: 0.3.6
+Version: 0.3.9
 Summary: Live Chatbots based on Langchain chatbots and Agents     Integrated into Navigator Framework or used into aiohttp applications.
 Home-page: https://github.com/phenobarbital/ai-parrot
 Author: Jesus Lara
@@ -108,6 +108,7 @@ Requires-Dist: ftfy==6.2.3; extra == "loaders"
 Requires-Dist: librosa==0.10.1; extra == "loaders"
 Requires-Dist: XlsxWriter==3.2.0; extra == "loaders"
 Requires-Dist: timm==1.0.9; extra == "loaders"
+Requires-Dist: easyocr==1.7.1; extra == "loaders"
 Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic==0.1.11; extra == "anthropic"
 Requires-Dist: anthropic==0.25.2; extra == "anthropic"

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/ai_parrot.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ examples/extract_frames.py
 examples/load_pdf.py
 examples/test_bot.py
 examples/test_question.py
+examples/askbuddy/create_bot.py
 parrot/__init__.py
 parrot/conf.py
 parrot/exceptions.c

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/ai_parrot.egg-info/requires.txt

@@ -107,6 +107,7 @@ ftfy==6.2.3
 librosa==0.10.1
 XlsxWriter==3.2.0
 timm==1.0.9
+easyocr==1.7.1
 
 [milvus]
 langchain-milvus>=0.1.4

ai_parrot-0.3.9/examples/askbuddy/create_bot.py

@@ -0,0 +1,32 @@
+import asyncio
+from parrot.chatbots.basic import Chatbot
+from parrot.llms.vertex import VertexLLM
+
+
+async def get_agent():
+    """Return the New Agent.
+    """
+    llm = VertexLLM(
+        model='gemini-1.5-pro',
+        temperature=0.1,
+        top_k=30,
+        Top_p=0.6,
+    )
+    agent = Chatbot(
+        name='AskBuddy',
+        llm=llm
+    )
+    await agent.configure()
+    # Create the Collection
+    if agent.store.collection_exists('employee_information'):
+        await agent.store.delete_collection('employee_information')
+    await agent.store.create_collection(  # pylint: disable=E1120
+        collection_name='employee_information',
+        dimension=768,
+        index_type="IVF_SQ8",
+        metric_type='L2'
+    )
+
+
+if __name__ == "__main__":
+    agent = asyncio.run(get_agent())

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/parrot/loaders/pdf.py

@@ -6,6 +6,7 @@ import re
 import ftfy
 import fitz
 import pytesseract
+from pytesseract import Output
 from paddleocr import PaddleOCR
 import torch
 import cv2
@@ -15,16 +16,38 @@ from transformers import (
     # VisionEncoderDecoderConfig,
     # ViTImageProcessor,
     # AutoTokenizer,
+    LayoutLMv3FeatureExtractor,
+    LayoutLMv3TokenizerFast,
     LayoutLMv3ForTokenClassification,
     LayoutLMv3Processor
 )
 from pdf4llm import to_markdown
 from PIL import Image
 from langchain.docstore.document import Document
-from navconfig import config
+from navconfig.logging import logging
 from .basepdf import BasePDF
 
 
+logging.getLogger(name='ppocr').setLevel(logging.INFO)
+
+# Function to rescale bounding boxes
+def rescale_bounding_boxes(bboxes, image_width, image_height, target_size=1000):
+    """Rescale bounding boxes to fit within the target size for LayoutLMv3."""
+    rescaled_bboxes = []
+    for bbox in bboxes:
+        x1, y1 = bbox[0]
+        x2, y2 = bbox[2]
+        # Rescale based on the image dimensions
+        rescaled_bbox = [
+            int(x1 / image_width * target_size),
+            int(y1 / image_height * target_size),
+            int(x2 / image_width * target_size),
+            int(y2 / image_height * target_size)
+        ]
+        rescaled_bboxes.append(rescaled_bbox)
+    return rescaled_bboxes
+
+
 class PDFLoader(BasePDF):
     """
     Loader for PDF files.
@@ -50,13 +73,22 @@ class PDFLoader(BasePDF):
         self.page_as_images = kwargs.get('page_as_images', False)
         if self.page_as_images is True:
             # Load the processor and model from Hugging Face
+            # self.feature_extractor = LayoutLMv3FeatureExtractor(apply_ocr=False)
+            # self.image_tokenizer = LayoutLMv3TokenizerFast.from_pretrained(
+            #     "microsoft/layoutlmv3-base"
+            # )
+            # self.image_processor = LayoutLMv3Processor(
+            #     self.feature_extractor,
+            #     self.image_tokenizer
+            # )
             self.image_processor = LayoutLMv3Processor.from_pretrained(
                 "microsoft/layoutlmv3-base",
-                apply_ocr=True
+                apply_ocr=False
             )
+            # LayoutLMv3ForSequenceClassification.from_pretrained
             self.image_model = LayoutLMv3ForTokenClassification.from_pretrained(
-                # "microsoft/layoutlmv3-base-finetuned-funsd"
-                "HYPJUDY/layoutlmv3-base-finetuned-funsd"
+                "microsoft/layoutlmv3-base"
+                # "HYPJUDY/layoutlmv3-base-finetuned-funsd"
             )
             # Set device to GPU if available
             self.image_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
@@ -73,63 +105,63 @@ class PDFLoader(BasePDF):
         if table_settings:
             self.table_settings.update(table_settings)
 
-    def explain_image(self, image_path):
-        """Function to explain the image."""
-        # with open(image_path, "rb") as image_file:
-        #     image_content = image_file.read()
-
-        # Open the image
-        image = cv2.imread(image_path)
-        task_prompt = "<s_docvqa><s_question>{user_input}</s_question><s_answer>"
-        question = "Extract Questions about Happily Greet"
-        prompt = task_prompt.replace("{user_input}", question)
-
-        decoder_input_ids = self.image_processor.tokenizer(
-            prompt,
-            add_special_tokens=False,
-            return_tensors="pt",
-        ).input_ids
-
-        pixel_values = self.image_processor(
-            image,
-            return_tensors="pt"
-        ).pixel_values
-
-        # Send inputs to the appropriate device
-        pixel_values = pixel_values.to(self.image_device)
-        decoder_input_ids = decoder_input_ids.to(self.image_device)
-
-        outputs = self.image_model.generate(
-            pixel_values,
-            decoder_input_ids=decoder_input_ids,
-            max_length=self.image_model.decoder.config.max_position_embeddings,
-            pad_token_id=self.image_processor.tokenizer.pad_token_id,
-            eos_token_id=self.image_processor.tokenizer.eos_token_id,
-            bad_words_ids=[[self.image_processor.tokenizer.unk_token_id]],
-            # use_cache=True
-            return_dict_in_generate=True,
-        )
-
-        sequence = self.image_processor.batch_decode(outputs.sequences)[0]
-
-
-        sequence = sequence.replace(
-            self.image_processor.tokenizer.eos_token, ""
-        ).replace(
-            self.image_processor.tokenizer.pad_token, ""
-        )
-        # remove first task start token
-        sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()
-        # Print the extracted sequence
-        print("Extracted Text:", sequence)
-
-        print(self.image_processor.token2json(sequence))
-
-        # Format the output as Markdown (optional step)
-        markdown_text = self.format_as_markdown(sequence)
-        print("Markdown Format:\n", markdown_text)
-
-        return None
+    # def explain_image(self, image_path):
+    #     """Function to explain the image."""
+    #     # with open(image_path, "rb") as image_file:
+    #     #     image_content = image_file.read()
+
+    #     # Open the image
+    #     image = cv2.imread(image_path)
+    #     task_prompt = "<s_docvqa><s_question>{user_input}</s_question><s_answer>"
+    #     question = "Extract Questions about Happily Greet"
+    #     prompt = task_prompt.replace("{user_input}", question)
+
+    #     decoder_input_ids = self.image_processor.tokenizer(
+    #         prompt,
+    #         add_special_tokens=False,
+    #         return_tensors="pt",
+    #     ).input_ids
+
+    #     pixel_values = self.image_processor(
+    #         image,
+    #         return_tensors="pt"
+    #     ).pixel_values
+
+    #     # Send inputs to the appropriate device
+    #     pixel_values = pixel_values.to(self.image_device)
+    #     decoder_input_ids = decoder_input_ids.to(self.image_device)
+
+    #     outputs = self.image_model.generate(
+    #         pixel_values,
+    #         decoder_input_ids=decoder_input_ids,
+    #         max_length=self.image_model.decoder.config.max_position_embeddings,
+    #         pad_token_id=self.image_processor.tokenizer.pad_token_id,
+    #         eos_token_id=self.image_processor.tokenizer.eos_token_id,
+    #         bad_words_ids=[[self.image_processor.tokenizer.unk_token_id]],
+    #         # use_cache=True
+    #         return_dict_in_generate=True,
+    #     )
+
+    #     sequence = self.image_processor.batch_decode(outputs.sequences)[0]
+
+
+    #     sequence = sequence.replace(
+    #         self.image_processor.tokenizer.eos_token, ""
+    #     ).replace(
+    #         self.image_processor.tokenizer.pad_token, ""
+    #     )
+    #     # remove first task start token
+    #     sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()
+    #     # Print the extracted sequence
+    #     print("Extracted Text:", sequence)
+
+    #     print(self.image_processor.token2json(sequence))
+
+    #     # Format the output as Markdown (optional step)
+    #     markdown_text = self.format_as_markdown(sequence)
+    #     print("Markdown Format:\n", markdown_text)
+
+    #     return None
 
     def convert_to_markdown(self, text):
         """
@@ -141,7 +173,7 @@ class PDFLoader(BasePDF):
         # Detect headings and bold them
         markdown_text = re.sub(r"(^.*Scorecard.*$)", r"## \1", markdown_text)
         # Convert lines with ":" to a list item (rough approach)
-        markdown_text = re.sub(r"(\w+):", r"- **\1**:", markdown_text)
+        # markdown_text = re.sub(r"(\w+):", r"- **\1**:", markdown_text)
         # Return the markdown formatted text
         return markdown_text
 
@@ -164,40 +196,77 @@ class PDFLoader(BasePDF):
 
         return cleaned_text.strip()
 
-    def extract_page_text(self, image_path) -> str:
-        # Open the image
-        image = Image.open(image_path).convert("RGB")
-
-        # Processor handles the OCR internally, no need for words or boxes
-        encoding = self.image_processor(image, return_tensors="pt", truncation=True)
-        encoding = {k: v.to(self.image_device) for k, v in encoding.items()}
+    def create_bounding_box(self, bbox_data):
+        xs = []
+        ys = []
+        for x, y in bbox_data:
+            xs.append(x)
+            ys.append(y)
 
-        # Forward pass
-        outputs = self.image_model(**encoding)
-        logits = outputs.logits
+        left = int(min(xs))
+        top = int(min(ys))
+        right = int(max(xs))
+        bottom = int(max(ys))
 
-        # Get predictions
-        predictions = logits.argmax(-1).squeeze().tolist()
-        labels = [self.image_model.config.id2label[pred] for pred in predictions]
+        return [left, top, right, bottom]
 
-        # Get the words and boxes from the processor's OCR step
-        words = self.image_processor.tokenizer.convert_ids_to_tokens(
-            encoding['input_ids'].squeeze().tolist()
-        )
-        boxes = encoding['bbox'].squeeze().tolist()
-
-        # Combine words and labels, preserving line breaks based on vertical box position
-        extracted_text = ""
-        last_box = None
-        for word, label, box in zip(words, labels, boxes):
-            if label != 'O':
-                # Check if the current word is on a new line based on the vertical position of the box
-                if last_box and abs(box[1] - last_box[1]) > 10:  # A threshold for line breaks
-                    extracted_text += "\n"  # Add a line break
-
-                extracted_text += f"{word} "
-                last_box = box
-        cleaned_text = self.clean_tokenized_text(extracted_text)
+    def extract_page_text(self, image_path) -> str:
+        # Open the image
+        image = Image.open(image_path).convert("RGB")
+        image_width, image_height = image.size
+
+        # Initialize PaddleOCR with English language
+        ocr = PaddleOCR(use_angle_cls=True, lang='en')
+        ocr_result = ocr.ocr(str(image_path), cls=True)
+
+        # Collect the text and bounding boxes
+        text_with_boxes = []
+        for line in ocr_result[0]:
+            text = line[1][0]  # Extract the text
+            bbox = line[0]     # Extract the bounding box
+            text_with_boxes.append((text, bbox))
+
+        # Step 2: Sort text based on y-coordinate (top-down order)
+        def average_y(bbox):
+            return sum([point[1] for point in bbox]) / len(bbox)
+
+        text_with_boxes.sort(key=lambda x: average_y(x[1]))
+
+        # Insert line breaks based on y-coordinate differences
+        words_with_newlines = []
+        last_y = None
+        threshold = 20  # You can adjust this value based on the document's layout
+
+        for _, (word, bbox) in enumerate(text_with_boxes):
+            current_y = average_y(bbox)
+            if last_y is not None and current_y - last_y > threshold:
+                words_with_newlines.append("\n")  # Insert a line break
+            words_with_newlines.append(word)
+            last_y = current_y
+
+        # # Step 3: Extract words and bounding boxes after sorting
+        # words = [item[0] for item in text_with_boxes]
+        # bounding_boxes = [item[1] for item in text_with_boxes]
+
+        # # Step 4: Rescale bounding boxes to the 0-1000 range for LayoutLMv3
+        # boxes = rescale_bounding_boxes(
+        #     bounding_boxes,
+        #     image_width,
+        #     image_height
+        # )
+
+        # # Print extracted text and bounding boxes
+        # # for word, bbox in zip(words, boxes):
+        # #    print(f"Word: {word}, Bounding Box: {bbox}")
+
+        # # Processor handles the OCR internally, no need for words or boxes
+        # encoded_inputs = self.image_processor(image, words, boxes=boxes, return_tensors="pt")
+        # outputs = self.image_model(**encoded_inputs)
+
+        # Step 7: Join the sorted words into a paragraph
+        paragraph = " ".join(words_with_newlines)
+
+        cleaned_text = self.clean_tokenized_text(paragraph)
         markdown_text = self.convert_to_markdown(cleaned_text)
         return markdown_text
 
@@ -217,6 +286,10 @@ class PDFLoader(BasePDF):
             docs = []
             try:
                 md_text = to_markdown(pdf) # get markdown for all pages
+                try:
+                    summary_document = self.get_summary_from_text(md_text)
+                except Exception:
+                    summary_document = ''
                 _meta = {
                     "url": f'{path}',
                     "source": f"{path.name}",
@@ -228,9 +301,9 @@ class PDFLoader(BasePDF):
                     "data": {},
                     "summary": '',
                     "document_meta": {
-                        "title": pdf.metadata.get("title", ""),
-                        "creationDate": pdf.metadata.get("creationDate", ""),
-                        "author": pdf.metadata.get("author", ""),
+                        "title": pdf.metadata.get("title", ""),  # pylint: disable=E1101
+                        "creationDate": pdf.metadata.get("creationDate", ""),  # pylint: disable=E1101
+                        "author": pdf.metadata.get("author", ""),  # pylint: disable=E1101
                     }
                 }
                 docs.append(
@@ -239,6 +312,14 @@ class PDFLoader(BasePDF):
                         metadata=_meta
                     )
                 )
+                if summary_document:
+                    summary_document = f"**Summary**\n{path.name}\n" + summary_document
+                    docs.append(
+                        Document(
+                            page_content=summary_document,
+                            metadata=_meta
+                        )
+                    )
             except Exception:
                 pass
             for page_number in range(pdf.page_count):
@@ -261,11 +342,10 @@ class PDFLoader(BasePDF):
                         "answer": '',
                         "source_type": self._source_type,
                         "data": {},
-                        "summary": summary,
+                        "summary": '',
                         "document_meta": {
-                            "title": pdf.metadata.get("title", ""),
-                            "creationDate": pdf.metadata.get("creationDate", ""),
-                            "author": pdf.metadata.get("author", ""),
+                            "title": pdf.metadata.get("title", ""),  # pylint: disable=E1101
+                            "author": pdf.metadata.get("author", ""),  # pylint: disable=E1101
                         }
                     }
                     docs.append(
@@ -274,6 +354,15 @@ class PDFLoader(BasePDF):
                             metadata=metadata
                         )
                     )
+                    # And Summary Document:
+                    if summary:
+                        sm = f"**Summary**\n{path.name} Page.#{page_num}\n" + summary
+                        docs.append(
+                            Document(
+                                page_content=sm,
+                                metadata=metadata
+                            )
+                        )
                 # Extract images and use OCR to get text from each image
                 # second: images
                 file_name = path.stem.replace(' ', '_').replace('.', '').lower()
@@ -366,9 +455,10 @@ class PDFLoader(BasePDF):
                 if self.page_as_images is True:
                     # Convert the page to a Pixmap (which is an image)
                     mat = fitz.Matrix(2, 2)
-                    pix = page.get_pixmap(dpi=300, matrix=mat) # Increase DPI for better resolution
+                    pix = page.get_pixmap(dpi=600, matrix=mat) # Increase DPI for better resolution
                     img_name = f'{file_name}_page_{page_num}.png'
                     img_path = self._imgdir.joinpath(img_name)
+                    print('IMAGE > ', img_path)
                     if img_path.exists():
                         img_path.unlink(missing_ok=True)
                     self.logger.notice(
@@ -380,7 +470,7 @@ class PDFLoader(BasePDF):
                     # TODO passing the image to a AI visual to get explanation
                     # Get the extracted text from the image
                     text = self.extract_page_text(img_path)
-                    print('TEXT EXTRACTED >> ', text)
+                    # print('TEXT EXTRACTED >> ', text)
                     url = f'/static/images/{img_name}'
                     image_meta = {
                         "url": url,
@@ -406,25 +496,16 @@ class PDFLoader(BasePDF):
         else:
             return []
 
-    def get_ocr(self, img_path) -> list:
-        # Initialize PaddleOCR with table recognition
-        self.ocr_model = PaddleOCR(
+    def get_paddleocr(self, img_path) -> list:
+        # Initialize PaddleOCR
+        ocr_model = PaddleOCR(
             lang='en',
             det_model_dir=None,
             rec_model_dir=None,
             rec_char_dict_path=None,
-            table=True,
-            # use_angle_cls=True,
+            # table=True,
+            use_angle_cls=True,
             # use_gpu=True
         )
-        result = self.ocr_model.ocr(img_path, cls=True)
-
-        # extract tables:
-        # The result contains the table structure and content
-        tables = []
-        for line in result:
-            if 'html' in line[1]:
-                html_table = line[1]['html']
-                tables.append(html_table)
-
-        print('TABLES > ', tables)
+        result = ocr_model.ocr(img_path, cls=True)
+        return result

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/parrot/loaders/videolocal.py

@@ -84,11 +84,13 @@ class VideoLocalLoader(BaseVideoLoader):
         if transcript_whisper:
             # VTT version:
             transcript = self.transcript_to_vtt(transcript_whisper, transcript_path)
-            doc = Document(
-                page_content=transcript,
-                metadata=metadata
-            )
-            documents.append(doc)
+            transcript_chunks = split_text(transcript, 65535)
+            for chunk in transcript_chunks:
+                doc = Document(
+                    page_content=chunk,
+                    metadata=metadata
+                )
+                documents.append(doc)
             # Saving every dialog chunk as a separate document
             dialogs = self.transcript_to_blocks(transcript_whisper)
             docs = []

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/parrot/stores/milvus.py

@@ -1,12 +1,12 @@
 from typing import Optional, Union, Any
 import asyncio
-import uuid
-import torch
+# import uuid
+# import torch
 from pymilvus import (
     MilvusClient,
-    Collection,
-    FieldSchema,
-    CollectionSchema,
+    # Collection,
+    # FieldSchema,
+    # CollectionSchema,
     DataType,
     connections,
     db
@@ -148,10 +148,10 @@ class MilvusStore(AbstractStore):
             )
 
     async def __aenter__(self):
-        try:
-            self.tensor = torch.randn(1000, 1000).cuda()
-        except RuntimeError:
-            self.tensor = None
+        # try:
+        #     self.tensor = torch.randn(1000, 1000).cuda()
+        # except RuntimeError:
+        #     self.tensor = None
         if self._embed_ is None:
             self._embed_ = self.create_embedding(
                 model_name=self.embedding_name
@@ -161,10 +161,10 @@ class MilvusStore(AbstractStore):
     async def __aexit__(self, exc_type, exc_value, traceback):
         # closing Embedding
         self._embed_ = None
-        del self.tensor
+        # del self.tensor
         try:
             self.close(alias=self._client_id)
-            torch.cuda.empty_cache()
+            # torch.cuda.empty_cache()
         except RuntimeError:
             pass
 
@@ -199,7 +199,10 @@ class MilvusStore(AbstractStore):
         connections.disconnect(alias=alias)
         try:
             self._client.close()
+        except AttributeError:
+            pass
         finally:
+            self._client = None
             self._connected = False
 
     def create_db(self, db_name: str, alias: str = 'default', **kwargs) -> bool:
@@ -269,8 +272,9 @@ class MilvusStore(AbstractStore):
         return self.get_vector()
 
     def collection_exists(self, collection_name: str) -> bool:
-        if collection_name in self._client.list_collections():
-            return True
+        with self.connection():
+            if collection_name in self._client.list_collections():
+                return True
         return False
 
     def check_state(self, collection_name: str) -> dict:
@@ -478,10 +482,10 @@ class MilvusStore(AbstractStore):
     ):
         if not collection:
             collection = self.collection
-        try:
-            tensor = torch.randn(1000, 1000).cuda()
-        except Exception:
-            tensor = None
+        # try:
+        #     tensor = torch.randn(1000, 1000).cuda()
+        # except Exception:
+        #     tensor = None
         if upsert is True:
             # get first document
             doc = documents[0]
@@ -510,7 +514,7 @@ class MilvusStore(AbstractStore):
             vector_field='vector',
             **kwargs
         )
-        del tensor
+        # del tensor
         return docstore
 
     def upsert(self, payload: dict, collection: str = None) -> None:

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/parrot/version.py

@@ -3,7 +3,7 @@
 __title__ = "ai-parrot"
 __description__ = "Live Chatbots based on Langchain chatbots and Agents \
     Integrated into Navigator Framework or used into aiohttp applications."
-__version__ = "0.3.6"
+__version__ = "0.3.9"
 __author__ = "Jesus Lara"
 __author_email__ = "jesuslarag@gmail.com"
 __license__ = "MIT"

{ai_parrot-0.3.6 → ai_parrot-0.3.9}/setup.py

@@ -224,6 +224,7 @@ setup(
             "XlsxWriter==3.2.0",
             # "xformers==0.0.27.post2",
             "timm==1.0.9",
+            "easyocr==1.7.1"
         ],
         "anthropic": [
             "langchain-anthropic==0.1.11",