agno 1.7.7__py3-none-any.whl → 1.7.9__py3-none-any.whl

agno/document/reader/pdf_reader.py

@@ -1,6 +1,7 @@
 import asyncio
+import re
 from pathlib import Path
-from typing import IO, Any, List, Optional, Union
+from typing import IO, Any, List, Optional, Tuple, Union
 from uuid import uuid4
 
 from agno.document.base import Document
@@ -15,7 +16,13 @@ except ImportError:
     raise ImportError("`pypdf` not installed. Please install it via `pip install pypdf`.")
 
 
-def process_image_page(doc_name: str, page_number: int, page: Any) -> Document:
+PAGE_START_NUMBERING_FORMAT_DEFAULT = "<start page {page_nr}>"
+PAGE_END_NUMBERING_FORMAT_DEFAULT = "<end page {page_nr}>"
+PAGE_NUMBERING_CORRECTNESS_RATIO_FOR_REMOVAL = 0.4
+
+
+def _ocr_reader(page: Any) -> str:
+    """A single PDF page object."""
     try:
         import rapidocr_onnxruntime as rapidocr
     except ImportError:
@@ -23,7 +30,6 @@ def process_image_page(doc_name: str, page_number: int, page: Any) -> Document:
             "`rapidocr_onnxruntime` not installed. Please install it via `pip install rapidocr_onnxruntime`."
         )
     ocr = rapidocr.RapidOCR()
-    page_text = page.extract_text() or ""
     images_text_list = []
 
     # Extract and process images
@@ -34,22 +40,13 @@ def process_image_page(doc_name: str, page_number: int, page: Any) -> Document:
         ocr_result, elapse = ocr(image_data)
 
         # Extract text from OCR result
-        if ocr_result:
-            images_text_list += [item[1] for item in ocr_result]
+        images_text_list += [item[1] for item in ocr_result] if ocr_result else []
 
-    images_text = "\n".join(images_text_list)
-    content = page_text + "\n" + images_text
-
-    # Append the document
-    return Document(
-        name=doc_name,
-        id=str(uuid4()),
-        meta_data={"page": page_number},
-        content=content,
-    )
+    return "\n".join(images_text_list)
 
 
-async def async_process_image_page(doc_name: str, page_number: int, page: Any) -> Document:
+async def _async_ocr_reader(page: Any) -> str:
+    """page: A single PDF page object."""
     try:
         import rapidocr_onnxruntime as rapidocr
     except ImportError:
@@ -58,9 +55,6 @@ async def async_process_image_page(doc_name: str, page_number: int, page: Any) -
         )
     ocr = rapidocr.RapidOCR()
 
-    page_text = page.extract_text() or ""
-    images_text_list: List = []
-
     # Process images in parallel
     async def process_image(image_data: bytes) -> List[str]:
         ocr_result, _ = ocr(image_data)
@@ -69,27 +63,221 @@ async def async_process_image_page(doc_name: str, page_number: int, page: Any) -
     image_tasks = [process_image(image.data) for image in page.images]
     images_results = await asyncio.gather(*image_tasks)
 
+    images_text_list: List = []
     for result in images_results:
         images_text_list.extend(result)
 
     images_text = "\n".join(images_text_list)
-    content = page_text + "\n" + images_text
-
-    return Document(
-        name=doc_name,
-        id=str(uuid4()),
-        meta_data={"page": page_number},
-        content=content,
+    return images_text
+
+
+def _clean_page_numbers(
+    page_content_list: List[str],
+    extra_content: List[str] = [],
+    page_start_numbering_format: str = PAGE_START_NUMBERING_FORMAT_DEFAULT,
+    page_end_numbering_format: str = PAGE_END_NUMBERING_FORMAT_DEFAULT,
+) -> Tuple[List[str], Optional[int]]:
+    f"""
+    Identifies and removes or reformats page numbers from a list of PDF page contents, based on the most consistent sequential numbering.
+
+    Args:
+        page_content_list (List[str]): A list of strings where each string represents the content of a PDF page.
+        extra_content (List[str]): A list of strings where each string will be appended after the main content. Can be used for appending image information.
+        page_start_numbering_format (str): A format string to prepend to the page content, with `{{page_nr}}` as a placeholder for the page number.
+            Defaults to {PAGE_START_NUMBERING_FORMAT_DEFAULT}. Make it an empty string to remove the page number.
+        page_end_numbering_format (str): A format string to append to the page content, with `{{page_nr}}` as a placeholder for the page number.
+            Defaults to {PAGE_END_NUMBERING_FORMAT_DEFAULT}. Make it an empty string to remove the page number.
+
+    Returns:
+        List[str]: The list of page contents with page numbers removed or reformatted based on the detected sequence.
+        Optional[Int]: The shift for the page numbering. Can be (-2, -1, 0, 1, 2).
+
+    Notes:
+        - The function scans for page numbers using a regular expression that matches digits at the start or end of a string.
+        - It evaluates several potential starting points for numbering (-2, -1, 0, 1, 2 shifts) to determine the most consistent sequence.
+        - If at least a specified ratio of pages (defined by `PAGE_NUMBERING_CORRECTNESS_RATIO_FOR_REMOVAL`) has correct sequential numbering, 
+          the page numbers are processed.
+        - If page numbers are found, the function will add formatted page numbers to each page's content if `page_start_numbering_format` or 
+          `page_end_numbering_format` is provided.
+    """
+    assert len(extra_content) == 0 or len(extra_content) == len(page_content_list), (
+        "Please provide an equally sized list of extra content if provided."
     )
 
+    # Regex to match potential page numbers at the start or end of a string
+    page_number_regex = re.compile(r"^\s*(\d+)\s*|\s*(\d+)\s*$")
+
+    def find_page_number(content):
+        match = page_number_regex.search(content)
+        if match:
+            return int(match.group(1) or match.group(2))
+        return None
+
+    page_numbers = [find_page_number(content) for content in page_content_list]
+    if all(x is None or x > 5 for x in page_numbers):
+        # This approach won't work reliably for higher page numbers.
+        return page_content_list, None
+
+    # Possible range shifts to detect page numbering
+    range_shifts = [-2, -1, 0, 1, 2]
+    best_match, best_correct_count, best_shift = _identify_best_page_sequence(page_numbers, range_shifts)
+
+    # Check if at least ..% of the pages have correct sequential numbering
+    if best_match and best_correct_count / len(page_numbers) >= PAGE_NUMBERING_CORRECTNESS_RATIO_FOR_REMOVAL:
+        # Remove the page numbers from the content
+        for i, expected_number in enumerate(best_match):
+            page_content_list[i] = re.sub(
+                rf"^\s*{expected_number}\s*|\s*{expected_number}\s*$", "", page_content_list[i]
+            )
+
+            page_start = (
+                page_start_numbering_format.format(page_nr=expected_number) + "\n"
+                if page_start_numbering_format
+                else ""
+            )
+            page_end = (
+                "\n" + page_end_numbering_format.format(page_nr=expected_number) if page_end_numbering_format else ""
+            )
+            extra_info = "\n" + extra_content[i] if extra_content else ""
+
+            # Add formatted page numbering if configured.
+            page_content_list[i] = page_start + page_content_list[i] + extra_info + page_end
+    else:
+        best_shift = None
+
+    return page_content_list, best_shift
+
+
+def _identify_best_page_sequence(page_numbers, range_shifts):
+    best_match = None
+    best_shift: Optional[int] = None
+    best_correct_count = 0
+
+    for shift in range_shifts:
+        expected_numbers = [i + shift for i in range(len(page_numbers))]
+        # Check if expected number occurs (or that the expected "2" occurs in an incorrectly merged number like 25,
+        # where 2 is the page number and 5 is part of the PDF content).
+        correct_count = sum(
+            1
+            for actual, expected in zip(page_numbers, expected_numbers)
+            if actual == expected or str(actual).startswith(str(expected)) or str(actual).endswith(str(expected))
+        )
+
+        if correct_count > best_correct_count:
+            best_correct_count = correct_count
+            best_match = expected_numbers
+            best_shift = shift
+
+    return best_match, best_correct_count, best_shift
+
 
 class BasePDFReader(Reader):
+    def __init__(
+        self,
+        split_on_pages: bool = True,
+        page_start_numbering_format: Optional[str] = None,
+        page_end_numbering_format: Optional[str] = None,
+        **kwargs,
+    ):
+        if page_start_numbering_format is None:
+            page_start_numbering_format = PAGE_START_NUMBERING_FORMAT_DEFAULT
+        if page_end_numbering_format is None:
+            page_end_numbering_format = PAGE_END_NUMBERING_FORMAT_DEFAULT
+
+        self.split_on_pages = split_on_pages
+        self.page_start_numbering_format = page_start_numbering_format
+        self.page_end_numbering_format = page_end_numbering_format
+
+        super().__init__(**kwargs)
+
     def _build_chunked_documents(self, documents: List[Document]) -> List[Document]:
         chunked_documents: List[Document] = []
         for document in documents:
             chunked_documents.extend(self.chunk_document(document))
         return chunked_documents
 
+    def _create_documents(self, pdf_content: List[str], doc_name: str, use_uuid_for_id: bool, page_number_shift):
+        if self.split_on_pages:
+            shift = page_number_shift if page_number_shift is not None else 1
+            documents: List[Document] = []
+            for page_number, page_content in enumerate(pdf_content, start=shift):
+                documents.append(
+                    Document(
+                        name=doc_name,
+                        id=(str(uuid4()) if use_uuid_for_id else f"{doc_name}_{page_number}"),
+                        meta_data={"page": page_number},
+                        content=page_content,
+                    )
+                )
+        else:
+            pdf_content_str = "\n".join(pdf_content)
+            document = Document(
+                name=doc_name,
+                id=str(uuid4()) if use_uuid_for_id else doc_name,
+                meta_data={},
+                content=pdf_content_str,
+            )
+            documents = [document]
+
+        if self.chunk:
+            return self._build_chunked_documents(documents)
+
+        return documents
+
+    def _pdf_reader_to_documents(
+        self,
+        doc_reader: DocumentReader,
+        doc_name,
+        read_images=False,
+        use_uuid_for_id=False,
+    ):
+        pdf_content = []
+        pdf_images_text = []
+        for page in doc_reader.pages:
+            pdf_content.append(page.extract_text())
+            if read_images:
+                pdf_images_text.append(_ocr_reader(page))
+
+        pdf_content, shift = _clean_page_numbers(
+            page_content_list=pdf_content,
+            extra_content=pdf_images_text,
+            page_start_numbering_format=self.page_start_numbering_format,
+            page_end_numbering_format=self.page_end_numbering_format,
+        )
+        return self._create_documents(pdf_content, doc_name, use_uuid_for_id, shift)
+
+    async def _async_pdf_reader_to_documents(
+        self,
+        doc_reader: DocumentReader,
+        doc_name: str,
+        read_images=False,
+        use_uuid_for_id=False,
+    ):
+        async def _read_pdf_page(page, read_images) -> Tuple[str, str]:
+            # We tried "asyncio.to_thread(page.extract_text)", but it maintains state internally, which leads to issues.
+            page_text = page.extract_text()
+
+            if read_images:
+                pdf_images_text = await _async_ocr_reader(page)
+            else:
+                pdf_images_text = ""
+
+            return page_text, pdf_images_text
+
+        # Process pages in parallel using asyncio.gather
+        pdf_content: List[Tuple[str, str]] = await asyncio.gather(
+            *[_read_pdf_page(page, read_images) for page in doc_reader.pages]
+        )
+
+        pdf_content_clean, shift = _clean_page_numbers(
+            page_content_list=[x[0] for x in pdf_content],
+            extra_content=[x[1] for x in pdf_content],
+            page_start_numbering_format=self.page_start_numbering_format,
+            page_end_numbering_format=self.page_end_numbering_format,
+        )
+
+        return self._create_documents(pdf_content_clean, doc_name, use_uuid_for_id, shift)
+
 
 class PDFReader(BasePDFReader):
     """Reader for PDF files"""
@@ -106,24 +294,13 @@ class PDFReader(BasePDFReader):
         log_info(f"Reading: {doc_name}")
 
         try:
-            doc_reader = DocumentReader(pdf)
+            pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
             logger.error(f"Error reading PDF: {e}")
             return []
 
-        documents = []
-        for page_number, page in enumerate(doc_reader.pages, start=1):
-            documents.append(
-                Document(
-                    name=doc_name,
-                    id=str(uuid4()),
-                    meta_data={"page": page_number},
-                    content=page.extract_text(),
-                )
-            )
-        if self.chunk:
-            return self._build_chunked_documents(documents)
-        return documents
+        # Read and chunk.
+        return self._pdf_reader_to_documents(pdf_reader, doc_name, use_uuid_for_id=True)
 
     async def async_read(self, pdf: Union[str, Path, IO[Any]]) -> List[Document]:
         try:
@@ -137,30 +314,13 @@ class PDFReader(BasePDFReader):
         log_info(f"Reading: {doc_name}")
 
         try:
-            doc_reader = DocumentReader(pdf)
+            pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
             logger.error(f"Error reading PDF: {e}")
             return []
 
-        async def _process_document(doc_name: str, page_number: int, page: Any) -> Document:
-            return Document(
-                name=doc_name,
-                id=str(uuid4()),
-                meta_data={"page": page_number},
-                content=page.extract_text(),
-            )
-
-        # Process pages in parallel using asyncio.gather
-        documents = await asyncio.gather(
-            *[
-                _process_document(doc_name, page_number, page)
-                for page_number, page in enumerate(doc_reader.pages, start=1)
-            ]
-        )
-
-        if self.chunk:
-            return self._build_chunked_documents(documents)
-        return documents
+        # Read and chunk.
+        return await self._async_pdf_reader_to_documents(pdf_reader, doc_name, use_uuid_for_id=True)
 
 
 class PDFUrlReader(BasePDFReader):
@@ -182,21 +342,10 @@ class PDFUrlReader(BasePDFReader):
         response = fetch_with_retry(url, proxy=self.proxy)
 
         doc_name = url.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
-        doc_reader = DocumentReader(BytesIO(response.content))
-
-        documents = []
-        for page_number, page in enumerate(doc_reader.pages, start=1):
-            documents.append(
-                Document(
-                    name=doc_name,
-                    id=f"{doc_name}_{page_number}",
-                    meta_data={"page": page_number},
-                    content=page.extract_text(),
-                )
-            )
-        if self.chunk:
-            return self._build_chunked_documents(documents)
-        return documents
+        pdf_reader = DocumentReader(BytesIO(response.content))
+
+        # Read and chunk.
+        return self._pdf_reader_to_documents(pdf_reader, doc_name, use_uuid_for_id=False)
 
     async def async_read(self, url: str) -> List[Document]:
         if not url:
@@ -213,27 +362,10 @@ class PDFUrlReader(BasePDFReader):
             response = await async_fetch_with_retry(url, client=client)
 
         doc_name = url.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
-        doc_reader = DocumentReader(BytesIO(response.content))
-
-        async def _process_document(doc_name: str, page_number: int, page: Any) -> Document:
-            return Document(
-                name=doc_name,
-                id=f"{doc_name}_{page_number}",
-                meta_data={"page": page_number},
-                content=page.extract_text(),
-            )
-
-        # Process pages in parallel using asyncio.gather
-        documents = await asyncio.gather(
-            *[
-                _process_document(doc_name, page_number, page)
-                for page_number, page in enumerate(doc_reader.pages, start=1)
-            ]
-        )
+        pdf_reader = DocumentReader(BytesIO(response.content))
 
-        if self.chunk:
-            return self._build_chunked_documents(documents)
-        return documents
+        # Read and chunk.
+        return await self._async_pdf_reader_to_documents(pdf_reader, doc_name, use_uuid_for_id=False)
 
 
 class PDFImageReader(BasePDFReader):
@@ -252,16 +384,10 @@ class PDFImageReader(BasePDFReader):
             doc_name = "pdf"
 
         log_info(f"Reading: {doc_name}")
-        doc_reader = DocumentReader(pdf)
-
-        documents = []
-        for page_number, page in enumerate(doc_reader.pages, start=1):
-            documents.append(process_image_page(doc_name, page_number, page))
-
-        if self.chunk:
-            return self._build_chunked_documents(documents)
+        pdf_reader = DocumentReader(pdf)
 
-        return documents
+        # Read and chunk.
+        return self._pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=False)
 
     async def async_read(self, pdf: Union[str, Path, IO[Any]]) -> List[Document]:
         if not pdf:
@@ -276,18 +402,10 @@ class PDFImageReader(BasePDFReader):
             doc_name = "pdf"
 
         log_info(f"Reading: {doc_name}")
-        doc_reader = DocumentReader(pdf)
+        pdf_reader = DocumentReader(pdf)
 
-        documents = await asyncio.gather(
-            *[
-                async_process_image_page(doc_name, page_number, page)
-                for page_number, page in enumerate(doc_reader.pages, start=1)
-            ]
-        )
-
-        if self.chunk:
-            return self._build_chunked_documents(documents)
-        return documents
+        # Read and chunk.
+        return await self._async_pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=False)
 
 
 class PDFUrlImageReader(BasePDFReader):
@@ -310,17 +428,10 @@ class PDFUrlImageReader(BasePDFReader):
         response = httpx.get(url, proxy=self.proxy) if self.proxy else httpx.get(url)
 
         doc_name = url.split("/")[-1].split(".")[0].replace(" ", "_")
-        doc_reader = DocumentReader(BytesIO(response.content))
-
-        documents = []
-        for page_number, page in enumerate(doc_reader.pages, start=1):
-            documents.append(process_image_page(doc_name, page_number, page))
-
-        # Optionally chunk documents
-        if self.chunk:
-            return self._build_chunked_documents(documents)
+        pdf_reader = DocumentReader(BytesIO(response.content))
 
-        return documents
+        # Read and chunk.
+        return self._pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=False)
 
     async def async_read(self, url: str) -> List[Document]:
         if not url:
@@ -338,15 +449,7 @@ class PDFUrlImageReader(BasePDFReader):
             response.raise_for_status()
 
         doc_name = url.split("/")[-1].split(".")[0].replace(" ", "_")
-        doc_reader = DocumentReader(BytesIO(response.content))
+        pdf_reader = DocumentReader(BytesIO(response.content))
 
-        documents = await asyncio.gather(
-            *[
-                async_process_image_page(doc_name, page_number, page)
-                for page_number, page in enumerate(doc_reader.pages, start=1)
-            ]
-        )
-
-        if self.chunk:
-            return self._build_chunked_documents(documents)
-        return documents
+        # Read and chunk.
+        return await self._async_pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=False)

agno/document/reader/youtube_reader.py

@@ -3,7 +3,7 @@ from typing import List
 
 from agno.document.base import Document
 from agno.document.reader.base import Reader
-from agno.utils.log import log_info, logger
+from agno.utils.log import log_debug, log_info, logger
 
 try:
     from youtube_transcript_api import YouTubeTranscriptApi
@@ -23,12 +23,16 @@ class YouTubeReader(Reader):
             log_info(f"Reading transcript for video: {video_id}")
 
             # Get transcript
-            transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+            log_debug(f"Fetching transcript for video: {video_id}")
+            # Create an instance of YouTubeTranscriptApi
+            ytt_api = YouTubeTranscriptApi()
+            transcript_data = ytt_api.fetch(video_id)
 
             # Combine transcript segments into full text
             transcript_text = ""
-            for segment in transcript_list:
-                transcript_text += f"{segment['text']} "
+
+            for segment in transcript_data:
+                transcript_text += f"{segment.text} "
 
             documents = [
                 Document(

agno/models/anthropic/claude.py

@@ -449,7 +449,7 @@ class Claude(Model):
 
     def get_system_message_for_model(self, tools: Optional[List[Any]] = None) -> Optional[str]:
         if tools is not None and len(tools) > 0:
-            tool_call_prompt = "Do not reflect on the quality of the returned search results in your response"
+            tool_call_prompt = "Do not reflect on the quality of the returned search results in your response\n\n"
             return tool_call_prompt
         return None
 

agno/models/base.py

@@ -1025,6 +1025,10 @@ class Model(ABC):
             stream_data.response_thinking += model_response_delta.thinking
             should_yield = True
 
+        if model_response_delta.reasoning_content is not None:
+            stream_data.response_thinking += model_response_delta.reasoning_content
+            should_yield = True
+
         if model_response_delta.redacted_thinking is not None:
             stream_data.response_redacted_thinking += model_response_delta.redacted_thinking
             should_yield = True

agno/models/message.py

@@ -338,8 +338,12 @@ class Message(BaseModel):
                             if isinstance(tool_call_arguments, dict)
                             else json.loads(tool_call_arguments)
                         )
-                        arguments = ", ".join(f"{k}: {v}" for k, v in tool_call_args.items())
-                        tool_calls_list.append(f"    Arguments: '{arguments}'")
+                        # Ensure tool_call_args is a dictionary before calling .items()
+                        if isinstance(tool_call_args, dict):
+                            arguments = ", ".join(f"{k}: {v}" for k, v in tool_call_args.items())
+                            tool_calls_list.append(f"    Arguments: '{arguments}'")
+                        else:
+                            tool_calls_list.append(f"    Arguments: '{tool_call_args}'")
                     except json.JSONDecodeError:
                         tool_calls_list.append("    Arguments: 'Invalid JSON format'")
             tool_calls_str = "\n".join(tool_calls_list)

agno/models/openai/chat.py

@@ -62,6 +62,7 @@ class OpenAIChat(Model):
     temperature: Optional[float] = None
     user: Optional[str] = None
     top_p: Optional[float] = None
+    service_tier: Optional[str] = None  # "auto" | "default" | "flex" | "priority", defaults to "auto" when not set
     extra_headers: Optional[Any] = None
     extra_query: Optional[Any] = None
     request_params: Optional[Dict[str, Any]] = None
@@ -175,6 +176,7 @@ class OpenAIChat(Model):
             "extra_headers": self.extra_headers,
             "extra_query": self.extra_query,
             "metadata": self.metadata,
+            "service_tier": self.service_tier,
         }
 
         # Handle response format - always use JSON schema approach
@@ -241,6 +243,7 @@ class OpenAIChat(Model):
                 "user": self.user,
                 "extra_headers": self.extra_headers,
                 "extra_query": self.extra_query,
+                "service_tier": self.service_tier,
             }
         )
         cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}

agno/models/openai/responses.py

@@ -47,7 +47,7 @@ class OpenAIResponses(Model):
     top_p: Optional[float] = None
     truncation: Optional[Literal["auto", "disabled"]] = None
     user: Optional[str] = None
-
+    service_tier: Optional[Literal["auto", "default", "flex", "priority"]] = None
     request_params: Optional[Dict[str, Any]] = None
 
     # Client parameters
@@ -178,6 +178,7 @@ class OpenAIResponses(Model):
             "top_p": self.top_p,
             "truncation": self.truncation,
             "user": self.user,
+            "service_tier": self.service_tier,
         }
         # Set the response format
         if response_format is not None:
@@ -310,11 +311,11 @@ class OpenAIResponses(Model):
         formatted_tools = []
         if tools:
             for _tool in tools:
-                if _tool["type"] == "function":
-                    _tool_dict = _tool["function"]
+                if _tool.get("type") == "function":
+                    _tool_dict = _tool.get("function", {})
                     _tool_dict["type"] = "function"
-                    for prop in _tool_dict["parameters"]["properties"].values():
-                        if isinstance(prop["type"], list):
+                    for prop in _tool_dict.get("parameters", {}).get("properties", {}).values():
+                        if isinstance(prop.get("type", ""), list):
                             prop["type"] = prop["type"][0]
 
                     formatted_tools.append(_tool_dict)