ai-microcore 4.0.0.dev4__tar.gz → 4.0.0.dev5__tar.gz

{ai_microcore-4.0.0.dev4 → ai_microcore-4.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-microcore
-Version: 4.0.0.dev4
+Version: 4.0.0.dev5
 Summary: # Minimalistic Foundation for AI Applications
 Keywords: llm,large language models,ai,similarity search,ai search,gpt,openai
 Author-email: Vitalii Stepanenko <mail@vitalii.in>

{ai_microcore-4.0.0.dev4 → ai_microcore-4.0.0.dev5}/microcore/__init__.py

@@ -161,4 +161,4 @@ __all__ = [
     # "wrappers",
 ]
 
-__version__ = "4.0.0-dev4"
+__version__ = "4.0.0-dev5"

{ai_microcore-4.0.0.dev4 → ai_microcore-4.0.0.dev5}/microcore/_env.py

@@ -14,6 +14,7 @@ from .llm.local_llm import make_llm_functions as make_local_llm_functions
 
 if TYPE_CHECKING:
     from .wrappers.llm_response_wrapper import LLMResponse  # noqa: F401
+    from transformers import PreTrainedModel, PreTrainedTokenizer  # noqa: F401
 
 
 @dataclass
@@ -26,10 +27,10 @@ class Env:
     llm_before_handlers: list[callable] = field(default_factory=list)
     llm_after_handlers: list[callable] = field(default_factory=list)
     texts: AbstractEmbeddingDB = None
-    model: "transformers.PreTrainedModel" = field(
+    model: "PreTrainedModel" = field(
         default=None, init=False, repr=False
     )  # noqa
-    tokenizer: "transformers.PreTrainedTokenizer" = field(  # noqa
+    tokenizer: "PreTrainedTokenizer" = field(  # noqa
         default=None, init=False, repr=False
     )
 

{ai_microcore-4.0.0.dev4 → ai_microcore-4.0.0.dev5}/microcore/_llm_functions.py

@@ -1,17 +1,27 @@
+import logging
 from datetime import datetime
 
 from .utils import run_parallel
-from .wrappers.llm_response_wrapper import LLMResponse
+from .wrappers.llm_response_wrapper import LLMResponse, DictFromLLMResponse
 from .types import TPrompt
 from ._env import env
 
 
-def llm(prompt: TPrompt, **kwargs) -> str | LLMResponse:
+def llm(
+    prompt: TPrompt,
+    retries: int = 0,
+    parse_json: bool | dict = False,
+    **kwargs
+) -> str | LLMResponse:
     """
     Request Large Language Model synchronously
 
     Args:
         prompt (str | Msg | dict | list[str | Msg | dict]): Text to send to LLM
+        retries (int): Number of retries in case of error
+        parse_json (bool|dict):
+            If True, parses response as JSON,
+            alternatively non-empty dict can be used as parse_json arguments
         **kwargs (dict): Parameters supported by the LLM API
 
             See parameters supported by the OpenAI:
@@ -40,7 +50,18 @@ def llm(prompt: TPrompt, **kwargs) -> str | LLMResponse:
     """
     [h(prompt, **kwargs) for h in env().llm_before_handlers]
     start = datetime.now()
-    response = env().llm_function(prompt, **kwargs)
+    tries = retries + 1
+    while tries > 0:
+        try:
+            tries -= 1
+            response = env().llm_function(prompt, **kwargs)
+            break
+        except Exception as e:
+            if tries == 0:
+                raise e
+            logging.error(f"LLM error: {e}")
+            logging.info(f"Retrying... {tries} retries left")
+            continue
     try:
         response.gen_duration = (datetime.now() - start).total_seconds()
         if not env().config.SAVE_MEMORY:
@@ -48,15 +69,35 @@ def llm(prompt: TPrompt, **kwargs) -> str | LLMResponse:
     except AttributeError:
         ...
     [h(response) for h in env().llm_after_handlers]
+    if tries > 0:
+        retry_params = dict(**kwargs)
+        retry_params["retries"] = tries - 1
+        setattr(
+            response,
+            "_retry_callback",
+            lambda: llm(prompt, **retry_params)
+        )
+    if parse_json:
+        parsing_params = parse_json if isinstance(parse_json, dict) else {}
+        return response.parse_json(**parsing_params)
     return response
 
 
-async def allm(prompt: TPrompt, **kwargs) -> str | LLMResponse:
+async def allm(
+    prompt: TPrompt,
+    retries: int = 0,
+    parse_json: bool | dict = False,
+    **kwargs
+) -> str | LLMResponse | DictFromLLMResponse:
     """
     Request Large Language Model asynchronously
 
     Args:
         prompt (str | Msg | dict | list[str | Msg | dict]): Text to send to LLM
+        retries (int): Number of retries in case of error
+        parse_json (bool|dict):
+            If True, parses response as JSON,
+            alternatively non-empty dict can be used as parse_json arguments
         **kwargs (dict): Parameters supported by the LLM API
 
             See parameters supported by the OpenAI:
@@ -87,7 +128,18 @@ async def allm(prompt: TPrompt, **kwargs) -> str | LLMResponse:
     """
     [h(prompt, **kwargs) for h in env().llm_before_handlers]
     start = datetime.now()
-    response = await env().llm_async_function(prompt, **kwargs)
+    tries = retries + 1
+    while tries > 0:
+        try:
+            tries -= 1
+            response = await env().llm_async_function(prompt, **kwargs)
+            break
+        except Exception as e:
+            if tries == 0:
+                raise e
+            logging.error(f"LLM error: {e}")
+            logging.info(f"Retrying... {tries} retries left")
+            continue
     try:
         response.gen_duration = (datetime.now() - start).total_seconds()
         if not env().config.SAVE_MEMORY:
@@ -95,6 +147,15 @@ async def allm(prompt: TPrompt, **kwargs) -> str | LLMResponse:
     except AttributeError:
         ...
     [h(response) for h in env().llm_after_handlers]
+    if parse_json:
+        try:
+            parsing_params = parse_json if isinstance(parse_json, dict) else {}
+            return response.parse_json(**parsing_params)
+        except Exception as e:
+            if tries > 0:
+                logging.error(f"LLM error: {e}")
+                logging.info(f"Retrying... {tries} retries left")
+                return await allm(prompt, retries=tries - 1, parse_json=parse_json, **kwargs)
     return response
 
 

{ai_microcore-4.0.0.dev4 → ai_microcore-4.0.0.dev5}/microcore/text2speech/elevenlabs.py

@@ -1,9 +1,28 @@
 import os
+from dataclasses import dataclass, asdict
 from datetime import datetime
 import aiohttp
 from .._env import env
 
 
+@dataclass
+class TTSArgs:
+    text: str
+    out_file: str = None
+    voice: str = "D38z5RcWu1voky8WS1ja"
+    stability: float = 0.29
+    similarity_boost: float = 0.5
+    style: float = 0.0
+    chunk_size: int = 1024
+    speed: float = 1.0
+    use_speaker_boost: bool = False
+    previous_text: str = None
+    next_text: str = None
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
 async def text_to_speech(
     text: str,
     out_file: str = None,
@@ -12,6 +31,10 @@ async def text_to_speech(
     similarity_boost=0.5,
     style=0.0,
     chunk_size=1024,
+    speed=1.0,
+    use_speaker_boost: bool = False,
+    previous_text: str = None,
+    next_text: str = None,
 ) -> str:
     url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice}"
     if not out_file:
@@ -25,8 +48,15 @@ async def text_to_speech(
             "stability": stability,
             "similarity_boost": similarity_boost,
             "style": style,
+            "speed": speed,
         },
     }
+    if use_speaker_boost:
+        data["voice_settings"]["use_speaker_boost"] = use_speaker_boost
+    if previous_text:
+        data["previous_text"] = previous_text
+    if next_text:
+        data["next_text"] = next_text
     headers = {
         "Accept": "audio/mpeg",
         "Content-Type": "application/json",

{ai_microcore-4.0.0.dev4 → ai_microcore-4.0.0.dev5}/microcore/types.py

@@ -5,6 +5,7 @@ from .message_types import Msg
 
 if TYPE_CHECKING:
     from .wrappers.prompt_wrapper import PromptWrapper  # noqa: F401
+    from .wrappers.llm_response_wrapper import LLMResponse  # noqa: F401
 
 TPrompt = Union[
     dict, Msg, str, "PromptWrapper", List[Union[dict, Msg, str, "PromptWrapper"]]
@@ -12,9 +13,9 @@ TPrompt = Union[
 """Type for prompt argument in LLM requests"""
 TplFunctionType = Callable[[Union[PathLike[str], str], Any], str]
 """Function type for rendering prompt templates"""
-LLMFunctionType = Callable[[TPrompt, Any], str]
+LLMFunctionType = Callable[[TPrompt, Any], "LLMResponse"]
 """Function type for requesting LLM synchronously"""
-LLMAsyncFunctionType = Callable[[TPrompt, Any], Awaitable[str]]
+LLMAsyncFunctionType = Callable[[TPrompt, Any], Awaitable["LLMResponse"]]
 """Function type for requesting LLM asynchronously"""
 
 

{ai_microcore-4.0.0.dev4 → ai_microcore-4.0.0.dev5}/microcore/wrappers/llm_response_wrapper.py

@@ -46,9 +46,27 @@ class LLMResponse(ExtendedString, ConvertableToMessage):
         return obj
 
     def parse_json(
-        self, raise_errors: bool = True, required_fields: list[str] = None
+        self,
+        raise_errors: bool = True,
+        required_fields: list[str] = None,
+        validator: callable = None,
     ) -> list | dict | float | int | str | DictFromLLMResponse:
-        res = parse_json(self.content, raise_errors, required_fields)
+        try:
+            res = parse_json(self.content, True, required_fields)
+            if validator:
+                try:
+                    validator(res)
+                except Exception as e:
+                    raise BadAIAnswer(f"Language model response validation failed: {e}") from None
+        except Exception as e:
+            if hasattr(self, "_retry_callback"):
+                res = self._retry_callback()
+                if isinstance(res, DictFromLLMResponse):
+                    return res
+                return res.parse_json(raise_errors, required_fields, validator)
+            if raise_errors:
+                raise e
+            res = False
         if isinstance(res, dict):
             res = DictFromLLMResponse(res)
             res.llm_response = self