langroid 0.52.7__tar.gz → 0.52.9__tar.gz

{langroid-0.52.7 → langroid-0.52.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.52.7
+Version: 0.52.9
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT

{langroid-0.52.7 → langroid-0.52.9}/langroid/language_models/base.py

@@ -99,9 +99,8 @@ class LLMConfig(BaseSettings):
 
     @property
     def model_max_output_tokens(self) -> int:
-        return min(
-            self.max_output_tokens or get_model_info(self.chat_model).max_output_tokens,
-            get_model_info(self.chat_model).max_output_tokens,
+        return (
+            self.max_output_tokens or get_model_info(self.chat_model).max_output_tokens
         )
 
 

{langroid-0.52.7 → langroid-0.52.9}/langroid/language_models/openai_gpt.py

@@ -336,15 +336,16 @@ class OpenAIGPTConfig(LLMConfig):
         # (e.g. anthropic doesn't like first msg to be system msg)
         litellm.modify_params = True
         self.seed = None  # some local mdls don't support seed
-        keys_dict = litellm.utils.validate_environment(self.chat_model)
-        missing_keys = keys_dict.get("missing_keys", [])
-        if len(missing_keys) > 0:
-            raise ValueError(
-                f"""
-                Missing environment variables for litellm-proxied model:
-                {missing_keys}
-                """
-            )
+        if self.api_key == DUMMY_API_KEY:
+            keys_dict = litellm.utils.validate_environment(self.chat_model)
+            missing_keys = keys_dict.get("missing_keys", [])
+            if len(missing_keys) > 0:
+                raise ValueError(
+                    f"""
+                    Missing environment variables for litellm-proxied model:
+                    {missing_keys}
+                    """
+                )
 
     @classmethod
     def create(cls, prefix: str) -> Type["OpenAIGPTConfig"]:
@@ -1504,6 +1505,9 @@ class OpenAIGPT(LanguageModel):
                     from litellm import completion as litellm_completion
 
                     completion_call = litellm_completion
+
+                    if self.api_key != DUMMY_API_KEY:
+                        kwargs["api_key"] = self.api_key
                 else:
                     if self.client is None:
                         raise ValueError(
@@ -1587,6 +1591,10 @@ class OpenAIGPT(LanguageModel):
             else:
                 if self.config.litellm:
                     from litellm import acompletion as litellm_acompletion
+
+                    if self.api_key != DUMMY_API_KEY:
+                        kwargs["api_key"] = self.api_key
+
                 # TODO this may not work: text_completion is not async,
                 # and we didn't find an async version in litellm
                 assert isinstance(self.async_client, AsyncOpenAI)
@@ -1734,6 +1742,9 @@ class OpenAIGPT(LanguageModel):
                 from litellm import completion as litellm_completion
 
                 completion_call = litellm_completion
+
+                if self.api_key != DUMMY_API_KEY:
+                    kwargs["api_key"] = self.api_key
             else:
                 if self.client is None:
                     raise ValueError("OpenAI/equivalent chat-completion client not set")
@@ -1792,6 +1803,9 @@ class OpenAIGPT(LanguageModel):
                 from litellm import acompletion as litellm_acompletion
 
                 acompletion_call = litellm_acompletion
+
+                if self.api_key != DUMMY_API_KEY:
+                    kwargs["api_key"] = self.api_key
             else:
                 if self.async_client is None:
                     raise ValueError(

langroid-0.52.9/langroid/parsing/pdf_utils.py

@@ -0,0 +1,89 @@
+import tempfile
+from io import BytesIO
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import TYPE_CHECKING, Any, BinaryIO, List, Optional, Tuple, Union
+
+try:
+    import fitz
+except ImportError:
+    if not TYPE_CHECKING:
+        fitz = None
+
+from langroid.exceptions import LangroidImportError
+
+if fitz is None:
+    raise LangroidImportError("fitz", ["pymupdf", "all", "pdf-parsers", "doc-chat"])
+
+
+def pdf_split_pages(
+    input_pdf: Union[BytesIO, BinaryIO, str],
+    splits: Optional[List[int]] = None,
+) -> Tuple[List[Path], TemporaryDirectory[Any]]:
+    """Splits a PDF into individual pages or chunks in a temporary directory.
+
+    Args:
+        input_pdf: Input PDF file in bytes, binary mode, or a file path
+        splits: Optional list of page numbers to split at.
+                If provided, pages will be grouped into chunks ending at
+                these page numbers.
+                For example, if splits = [4, 9], the result will have pages 1-4, 5-9,
+                and 10-end.
+                If not provided, default to splitting into individual pages.
+        max_workers: Maximum number of concurrent workers for parallel processing
+
+    Returns:
+        Tuple containing:
+            - List of paths to individual PDF pages or chunks
+            - Temporary directory object (caller must call cleanup())
+
+    Example:
+        paths, tmp_dir = split_pdf_temp("input.pdf")
+        # Use paths...
+        tmp_dir.cleanup()  # Clean up temp files when done
+    """
+    tmp_dir = tempfile.TemporaryDirectory()
+    if isinstance(input_pdf, str):
+        doc = fitz.open(input_pdf)
+    else:
+        doc = fitz.open(stream=input_pdf, filetype="pdf")
+    paths = []
+
+    total_pages = len(doc)
+
+    if splits is None:
+        # Split into individual pages (original behavior)
+        for page_num in range(total_pages):
+            new_doc = fitz.open()
+            new_doc.insert_pdf(doc, from_page=page_num, to_page=page_num)
+            output = Path(tmp_dir.name) / f"page_{page_num + 1}.pdf"
+            new_doc.save(str(output))
+            new_doc.close()
+            paths.append(output)
+    else:
+        # Split according to specified page ranges
+        # Make sure the splits list is sorted and includes all valid splits
+        splits = sorted([s for s in splits if 1 <= s <= total_pages])
+
+        # Create the ranges to process
+        ranges = []
+        start_page = 0
+        for end_page in splits:
+            ranges.append((start_page, end_page - 1))
+            start_page = end_page
+
+        # Add the final range if there are pages after the last split
+        if start_page < total_pages:
+            ranges.append((start_page, total_pages - 1))
+
+        # Process each range
+        for i, (from_page, to_page) in enumerate(ranges):
+            new_doc = fitz.open()
+            new_doc.insert_pdf(doc, from_page=from_page, to_page=to_page)
+            output = Path(tmp_dir.name) / f"pages_{from_page + 1}_to_{to_page + 1}.pdf"
+            new_doc.save(str(output))
+            new_doc.close()
+            paths.append(output)
+
+    doc.close()
+    return paths, tmp_dir

{langroid-0.52.7 → langroid-0.52.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langroid"
-version = "0.52.7"
+version = "0.52.9"
 authors = [
     {name = "Prasad Chalasani", email = "pchalasani@gmail.com"},
 ]

langroid-0.52.7/langroid/parsing/pdf_utils.py

@@ -1,54 +0,0 @@
-import tempfile
-from io import BytesIO
-from pathlib import Path
-from tempfile import TemporaryDirectory
-from typing import TYPE_CHECKING, Any, BinaryIO, List, Tuple, Union
-
-try:
-    import fitz
-except ImportError:
-    if not TYPE_CHECKING:
-        fitz = None
-
-from langroid.exceptions import LangroidImportError
-
-if fitz is None:
-    raise LangroidImportError("fitz", ["pymupdf", "all", "pdf-parsers", "doc-chat"])
-
-
-def pdf_split_pages(
-    input_pdf: Union[BytesIO, BinaryIO, str],
-) -> Tuple[List[Path], TemporaryDirectory[Any]]:
-    """Splits a PDF into individual pages in a temporary directory.
-
-    Args:
-        input_pdf: Input PDF file in bytes, binary mode, or a file path
-        max_workers: Maximum number of concurrent workers for parallel processing
-
-    Returns:
-        Tuple containing:
-            - List of paths to individual PDF pages
-            - Temporary directory object (caller must call cleanup())
-
-    Example:
-        paths, tmp_dir = split_pdf_temp("input.pdf")
-        # Use paths...
-        tmp_dir.cleanup()  # Clean up temp files when done
-    """
-    tmp_dir = tempfile.TemporaryDirectory()
-    if isinstance(input_pdf, str):
-        doc = fitz.open(input_pdf)
-    else:
-        doc = fitz.open(stream=input_pdf, filetype="pdf")
-    paths = []
-
-    for page_num in range(len(doc)):
-        new_doc = fitz.open()
-        new_doc.insert_pdf(doc, from_page=page_num, to_page=page_num)
-        output = Path(tmp_dir.name) / f"page_{page_num + 1}.pdf"
-        new_doc.save(str(output))
-        new_doc.close()
-        paths.append(output)
-
-    doc.close()
-    return paths, tmp_dir