langroid 0.1.85__py3-none-any.whl → 0.1.219__py3-none-any.whl

langroid/language_models/prompt_formatter/__init__.py

@@ -0,0 +1,15 @@
+from .base import PromptFormatter
+from .llama2_formatter import Llama2Formatter
+from ..config import PromptFormatterConfig, Llama2FormatterConfig
+
+from . import base
+from . import llama2_formatter
+
+__all__ = [
+    "PromptFormatter",
+    "Llama2Formatter",
+    "PromptFormatterConfig",
+    "Llama2FormatterConfig",
+    "base",
+    "llama2_formatter",
+]

langroid/language_models/prompt_formatter/base.py

@@ -17,13 +17,11 @@ class PromptFormatter(ABC):
         self.config = config
 
     @staticmethod
-    def create(config: PromptFormatterConfig) -> "PromptFormatter":
-        from langroid.language_models.prompt_formatter.llama2_formatter import (
-            Llama2Formatter,
-        )
+    def create(formatter: str) -> "PromptFormatter":
+        from langroid.language_models.config import HFPromptFormatterConfig
+        from langroid.language_models.prompt_formatter.hf_formatter import HFFormatter
 
-        formatter_class = dict(llama2=Llama2Formatter).get(config.type, Llama2Formatter)
-        return formatter_class(config)
+        return HFFormatter(HFPromptFormatterConfig(model_name=formatter))
 
     @abstractmethod
     def format(self, messages: List[LLMMessage]) -> str:

langroid/language_models/prompt_formatter/hf_formatter.py

@@ -0,0 +1,135 @@
+"""
+Prompt formatter based on HuggingFace `AutoTokenizer.apply_chat_template` method
+from their Transformers library. It searches the hub for a model matching the
+specified name, and uses the first one it finds. We assume that all matching
+models will have the same tokenizer, so we just use the first one.
+"""
+
+import logging
+import re
+from typing import Any, List, Set, Tuple, Type
+
+from jinja2.exceptions import TemplateError
+
+from langroid.language_models.base import LanguageModel, LLMMessage, Role
+from langroid.language_models.config import HFPromptFormatterConfig
+from langroid.language_models.prompt_formatter.base import PromptFormatter
+
+logger = logging.getLogger(__name__)
+
+
+def try_import_hf_modules() -> Tuple[Type[Any], Type[Any], Type[Any]]:
+    """
+    Attempts to import the AutoTokenizer class from the transformers package.
+    Returns:
+        The AutoTokenizer class if successful.
+    Raises:
+        ImportError: If the transformers package is not installed.
+    """
+    try:
+        from huggingface_hub import HfApi, ModelFilter
+        from transformers import AutoTokenizer
+
+        return AutoTokenizer, HfApi, ModelFilter
+    except ImportError:
+        raise ImportError(
+            """
+            You are trying to use some/all of:
+            HuggingFace transformers.AutoTokenizer,
+            huggingface_hub.HfApi, 
+            huggingface_hub.ModelFilter,
+            but these are not not installed 
+            by default with Langroid. Please install langroid using the 
+            `transformers` extra, like so:
+            pip install "langroid[transformers]"
+            or equivalent.
+            """
+        )
+
+
+def find_hf_formatter(model_name: str) -> str:
+    AutoTokenizer, HfApi, ModelFilter = try_import_hf_modules()
+    hf_api = HfApi()
+    # try to find a matching model, with progressivly shorter prefixes of model_name
+    model_name = model_name.lower().split("/")[-1]
+    parts = re.split("[:\\-_]", model_name)
+    parts = [p.lower() for p in parts if p != ""]
+    for i in range(len(parts), 0, -1):
+        prefix = "-".join(parts[:i])
+        models = hf_api.list_models(
+            filter=ModelFilter(
+                task="text-generation",
+                model_name=prefix,
+            )
+        )
+        try:
+            mdl = next(models)
+        except StopIteration:
+            continue
+
+        tokenizer = AutoTokenizer.from_pretrained(mdl.id)
+        if tokenizer.chat_template is not None:
+            return str(mdl.id)
+    return ""
+
+
+class HFFormatter(PromptFormatter):
+    models: Set[str] = set()  # which models have been used for formatting
+
+    def __init__(self, config: HFPromptFormatterConfig):
+        super().__init__(config)
+        AutoTokenizer, HfApi, ModelFilter = try_import_hf_modules()
+        self.config: HFPromptFormatterConfig = config
+        hf_api = HfApi()
+        models = hf_api.list_models(
+            filter=ModelFilter(
+                task="text-generation",
+                model_name=config.model_name,
+            )
+        )
+        try:
+            mdl = next(models)
+        except StopIteration:
+            raise ValueError(f"Model {config.model_name} not found on HuggingFace Hub")
+
+        self.tokenizer = AutoTokenizer.from_pretrained(mdl.id)
+        if self.tokenizer.chat_template is None:
+            raise ValueError(
+                f"Model {config.model_name} does not support chat template"
+            )
+        elif mdl.id not in HFFormatter.models:
+            # only warn if this is the first time we've used this mdl.id
+            logger.warning(
+                f"""
+            Using HuggingFace {mdl.id} for prompt formatting: 
+            This is the CHAT TEMPLATE. If this is not what you intended,
+            consider specifying a more complete model name for the formatter.
+             
+            {self.tokenizer.chat_template}
+            """
+            )
+        HFFormatter.models.add(mdl.id)
+
+    def format(self, messages: List[LLMMessage]) -> str:
+        sys_msg, chat_msgs, user_msg = LanguageModel.get_chat_history_components(
+            messages
+        )
+        # build msg dicts expected by AutoTokenizer.apply_chat_template
+        sys_msg_dict = dict(role=Role.SYSTEM.value, content=sys_msg)
+        chat_dicts = []
+        for user, assistant in chat_msgs:
+            chat_dicts.append(dict(role=Role.USER.value, content=user))
+            chat_dicts.append(dict(role=Role.ASSISTANT.value, content=assistant))
+        chat_dicts.append(dict(role=Role.USER.value, content=user_msg))
+        all_dicts = [sys_msg_dict] + chat_dicts
+        try:
+            # apply chat template
+            result = self.tokenizer.apply_chat_template(all_dicts, tokenize=False)
+        except TemplateError:
+            # this likely means the model doesn't support a system msg,
+            # so combine it with the first user msg
+            first_user_msg = chat_msgs[0][0] if len(chat_msgs) > 0 else user_msg
+            first_user_msg = sys_msg + "\n\n" + first_user_msg
+            chat_dicts[0] = dict(role=Role.USER.value, content=first_user_msg)
+            result = self.tokenizer.apply_chat_template(chat_dicts, tokenize=False)
+        return str(result)

langroid/language_models/utils.py

@@ -23,11 +23,10 @@ def retry_with_exponential_backoff(
     max_retries: int = 10,
     errors: tuple = (  # type: ignore
         requests.exceptions.RequestException,
-        openai.error.Timeout,
-        openai.error.RateLimitError,
-        openai.error.APIError,
-        openai.error.ServiceUnavailableError,
-        openai.error.TryAgain,
+        openai.APITimeoutError,
+        openai.RateLimitError,
+        openai.AuthenticationError,
+        openai.APIError,
         aiohttp.ServerTimeoutError,
         asyncio.TimeoutError,
     ),
@@ -44,11 +43,15 @@ def retry_with_exponential_backoff(
             try:
                 return func(*args, **kwargs)
 
-            except openai.error.InvalidRequestError as e:
+            except openai.BadRequestError as e:
                 # do not retry when the request itself is invalid,
                 # e.g. when context is too long
                 logger.error(f"OpenAI API request failed with error: {e}.")
                 raise e
+            except openai.AuthenticationError as e:
+                # do not retry when there's an auth error
+                logger.error(f"OpenAI API request failed with error: {e}.")
+                raise e
 
             # Retry on specified errors
             except errors as e:
@@ -85,11 +88,10 @@ def async_retry_with_exponential_backoff(
     jitter: bool = True,
     max_retries: int = 10,
     errors: tuple = (  # type: ignore
-        openai.error.Timeout,
-        openai.error.RateLimitError,
-        openai.error.APIError,
-        openai.error.ServiceUnavailableError,
-        openai.error.TryAgain,
+        openai.APITimeoutError,
+        openai.RateLimitError,
+        openai.AuthenticationError,
+        openai.APIError,
         aiohttp.ServerTimeoutError,
         asyncio.TimeoutError,
     ),
@@ -107,12 +109,15 @@ def async_retry_with_exponential_backoff(
                 result = await func(*args, **kwargs)
                 return result
 
-            except openai.error.InvalidRequestError as e:
+            except openai.BadRequestError as e:
                 # do not retry when the request itself is invalid,
                 # e.g. when context is too long
                 logger.error(f"OpenAI API request failed with error: {e}.")
                 raise e
-
+            except openai.AuthenticationError as e:
+                # do not retry when there's an auth error
+                logger.error(f"OpenAI API request failed with error: {e}.")
+                raise e
             # Retry on specified errors
             except errors as e:
                 # Increment retries
@@ -138,11 +143,3 @@ def async_retry_with_exponential_backoff(
                 raise e
 
     return wrapper
-
-
-# @retry_with_exponential_backoff
-# def completions_with_backoff(**kwargs):
-#     return openai.Completion.create(**kwargs)
-
-
-# completions_with_backoff(model="text-davinci-002", prompt="Once upon a time,")

langroid/mytypes.py

@@ -1,13 +1,15 @@
 import hashlib
 import uuid
 from enum import Enum
-from typing import Any, Dict, List, Union
+from textwrap import dedent
+from typing import Any, Callable, Dict, List, Union
 
 from pydantic import BaseModel, Extra
 
 Number = Union[int, float]
 Embedding = List[Number]
 Embeddings = List[Embedding]
+EmbeddingFunction = Callable[[List[str]], Embeddings]
 
 
 class Entity(str, Enum):
@@ -26,10 +28,12 @@ class DocMetaData(BaseModel):
 
     source: str = "context"
     is_chunk: bool = False  # if it is a chunk, don't split
+    id: str = ""  # unique id for the document
+    window_ids: List[str] = []  # for RAG: ids of chunks around this one
 
-    def dict(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+    def dict_bool_int(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
         """
-        Override dict method to convert bool fields to int, to appease some
+        Special dict method to convert bool fields to int, to appease some
         downstream libraries,  e.g. Chroma which complains about bool fields in
         metadata.
         """
@@ -51,9 +55,10 @@ class Document(BaseModel):
     content: str
     metadata: DocMetaData
 
-    def _unique_hash_id(self) -> str:
+    @staticmethod
+    def hash_id(doc: str) -> str:
         # Encode the document as UTF-8
-        doc_utf8 = str(self).encode("utf-8")
+        doc_utf8 = str(doc).encode("utf-8")
 
         # Create a SHA256 hash object
         sha256_hash = hashlib.sha256()
@@ -69,8 +74,15 @@ class Document(BaseModel):
 
         return str(hash_uuid)
 
-    def id(self) -> Any:
-        if hasattr(self.metadata, "id"):
+    def _unique_hash_id(self) -> str:
+        return self.hash_id(str(self))
+
+    def id(self) -> str:
+        if (
+            hasattr(self.metadata, "id")
+            and self.metadata.id is not None
+            and self.metadata.id != ""
+        ):
             return self.metadata.id
         else:
             return self._unique_hash_id()
@@ -78,4 +90,9 @@ class Document(BaseModel):
     def __str__(self) -> str:
         # TODO: make metadata a pydantic model to enforce "source"
         self.metadata.json()
-        return f"{self.content} {self.metadata.json()}"
+        return dedent(
+            f"""
+        CONTENT: {self.content}         
+        SOURCE:{self.metadata.source}
+        """
+        )

langroid/parsing/__init__.py

@@ -0,0 +1,46 @@
+from . import parser
+from . import agent_chats
+from . import code_parser
+from . import document_parser
+from . import parse_json
+from . import para_sentence_split
+from . import repo_loader
+from . import url_loader
+from . import table_loader
+from . import urls
+from . import utils
+from . import search
+from . import web_search
+from . import spider
+
+from .parser import (
+    Splitter,
+    PdfParsingConfig,
+    DocxParsingConfig,
+    DocParsingConfig,
+    ParsingConfig,
+    Parser,
+)
+
+__all__ = [
+    "parser",
+    "agent_chats",
+    "code_parser",
+    "document_parser",
+    "parse_json",
+    "para_sentence_split",
+    "repo_loader",
+    "url_loader",
+    "table_loader",
+    "urls",
+    "utils",
+    "search",
+    "web_search",
+    "spider",
+    "Splitter",
+    "PdfParsingConfig",
+    "DocxParsingConfig",
+    "DocParsingConfig",
+    "ParsingConfig",
+    "Parser",
+]