ws-bom-robot-app 0.0.44__py3-none-any.whl → 0.0.46__py3-none-any.whl

ws_bom_robot_app/llm/tools/tool_manager.py

@@ -1,133 +1,133 @@
-from asyncio import Queue
-from typing import  Optional, Type, Callable
-from ws_bom_robot_app.llm.models.api import LlmAppTool
-from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
-from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager
-from ws_bom_robot_app.llm.tools.utils import getRandomWaitingMessage, translate_text
-from ws_bom_robot_app.llm.tools.models.main import NoopInput,DocumentRetrieverInput,ImageGeneratorInput
-from pydantic import BaseModel, ConfigDict
-
-class ToolConfig(BaseModel):
-    function: Callable
-    model: Optional[Type[BaseModel]] = NoopInput
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True
-    )
-
-class ToolManager:
-    """
-    ToolManager is responsible for managing various tools used in the application.
-
-    Attributes:
-        app_tool (LlmAppTool): The application tool configuration.
-        api_key (str): The API key for accessing external services.
-        callbacks (list): A list of callback functions to be executed.
-
-    Methods:
-        document_retriever(query: str): Asynchronously retrieves documents based on the query.
-        image_generator(query: str, language: str = "it"): Asynchronously generates an image based on the query.
-        get_coroutine(): Retrieves the coroutine function based on the tool configuration.
-    """
-
-    def __init__(
-        self,
-        llm: LlmInterface,
-        app_tool: LlmAppTool,
-        callbacks: list,
-        queue: Optional[Queue] = None
-    ):
-        self.llm = llm
-        self.app_tool = app_tool
-        self.callbacks = callbacks
-        self.queue = queue
-
-
-    #region functions
-    async def document_retriever(self, query: str) -> list:
-        """
-        Asynchronously retrieves documents based on the provided query using the specified search settings.
-
-        Args:
-          query (str): The search query string.
-
-        Returns:
-          list: A list of retrieved documents based on the search criteria.
-
-        Raises:
-          ValueError: If the configuration for the tool is invalid or the vector database is not found.
-
-        Notes:
-          - The function supports different search types such as "similarity", "similarity_score_threshold", "mmr", and "mixed".
-          - The search settings can be customized through the `app_tool.search_settings` attribute.
-          - If a queue is provided, a waiting message is put into the queue before invoking the search.
-        """
-        if (
-            self.app_tool.type == "function" and self.app_tool.vector_db
-            #and self.settings.get("dataSource") == "knowledgebase"
-        ):
-            search_type = "similarity"
-            search_kwargs = {"k": 4}
-            if self.app_tool.search_settings:
-                search_settings = self.app_tool.search_settings # type: ignore
-                if search_settings.search_type == "similarityScoreThreshold":
-                    search_type = "similarity_score_threshold"
-                    search_kwargs = {
-                        "score_threshold": search_settings.score_threshold_id if search_settings.score_threshold_id else  0.5,
-                        "k": search_settings.search_k if search_settings.search_k else 100
-                    }
-                elif search_settings.search_type == "mmr":
-                    search_type = "mmr"
-                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
-                elif search_settings.search_type == "default":
-                    search_type = "similarity"
-                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
-                else:
-                    search_type = "mixed"
-                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
-            if self.queue:
-              await self.queue.put(getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False))
-
-            return await VectorDbManager.get_strategy(self.app_tool.vector_type).invoke(
-                self.llm.get_embeddings(),
-                self.app_tool.vector_db,
-                query,
-                search_type,
-                search_kwargs,
-                app_tool=self.app_tool,
-                llm=self.llm.get_llm()
-                )
-        return []
-        #raise ValueError(f"Invalid configuration for {self.settings.name} tool of type {self.settings.type}. Must be a function or vector db not found.")
-
-    async def image_generator(self, query: str, language: str = "it"):
-        """
-        Asynchronously generates an image based on the query.
-        set OPENAI_API_KEY in your environment variables
-        """
-        from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
-        model = self.app_tool.model or "dall-e-3"
-        random_waiting_message = getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False)
-        if not language:
-            language = "it"
-        await translate_text(
-            self.llm, language, random_waiting_message, self.callbacks
-        )
-        try:
-            #set os.environ.get("OPENAI_API_KEY")!
-            image_url = DallEAPIWrapper(model=model).run(query)  # type: ignore
-            return image_url
-        except Exception as e:
-            return f"Error: {str(e)}"
-
-    #endregion
-
-    #class variables (static)
-    _list: dict[str,ToolConfig] = {
-        "document_retriever": ToolConfig(function=document_retriever, model=DocumentRetrieverInput),
-        "image_generator": ToolConfig(function=image_generator, model=ImageGeneratorInput),
-    }
-
-    #instance methods
-    def get_coroutine(self):
-        tool_cfg = self._list.get(self.app_tool.function_name)
-        return getattr(self, tool_cfg.function.__name__)  # type: ignore
+from asyncio import Queue
+from typing import  Optional, Type, Callable
+from ws_bom_robot_app.llm.models.api import LlmAppTool
+from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
+from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager
+from ws_bom_robot_app.llm.tools.utils import getRandomWaitingMessage, translate_text
+from ws_bom_robot_app.llm.tools.models.main import NoopInput,DocumentRetrieverInput,ImageGeneratorInput
+from pydantic import BaseModel, ConfigDict
+
+class ToolConfig(BaseModel):
+    function: Callable
+    model: Optional[Type[BaseModel]] = NoopInput
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True
+    )
+
+class ToolManager:
+    """
+    ToolManager is responsible for managing various tools used in the application.
+
+    Attributes:
+        app_tool (LlmAppTool): The application tool configuration.
+        api_key (str): The API key for accessing external services.
+        callbacks (list): A list of callback functions to be executed.
+
+    Methods:
+        document_retriever(query: str): Asynchronously retrieves documents based on the query.
+        image_generator(query: str, language: str = "it"): Asynchronously generates an image based on the query.
+        get_coroutine(): Retrieves the coroutine function based on the tool configuration.
+    """
+
+    def __init__(
+        self,
+        llm: LlmInterface,
+        app_tool: LlmAppTool,
+        callbacks: list,
+        queue: Optional[Queue] = None
+    ):
+        self.llm = llm
+        self.app_tool = app_tool
+        self.callbacks = callbacks
+        self.queue = queue
+
+
+    #region functions
+    async def document_retriever(self, query: str) -> list:
+        """
+        Asynchronously retrieves documents based on the provided query using the specified search settings.
+
+        Args:
+          query (str): The search query string.
+
+        Returns:
+          list: A list of retrieved documents based on the search criteria.
+
+        Raises:
+          ValueError: If the configuration for the tool is invalid or the vector database is not found.
+
+        Notes:
+          - The function supports different search types such as "similarity", "similarity_score_threshold", "mmr", and "mixed".
+          - The search settings can be customized through the `app_tool.search_settings` attribute.
+          - If a queue is provided, a waiting message is put into the queue before invoking the search.
+        """
+        if (
+            self.app_tool.type == "function" and self.app_tool.vector_db
+            #and self.settings.get("dataSource") == "knowledgebase"
+        ):
+            search_type = "similarity"
+            search_kwargs = {"k": 4}
+            if self.app_tool.search_settings:
+                search_settings = self.app_tool.search_settings # type: ignore
+                if search_settings.search_type == "similarityScoreThreshold":
+                    search_type = "similarity_score_threshold"
+                    search_kwargs = {
+                        "score_threshold": search_settings.score_threshold_id if search_settings.score_threshold_id else  0.5,
+                        "k": search_settings.search_k if search_settings.search_k else 100
+                    }
+                elif search_settings.search_type == "mmr":
+                    search_type = "mmr"
+                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
+                elif search_settings.search_type == "default":
+                    search_type = "similarity"
+                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
+                else:
+                    search_type = "mixed"
+                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
+            if self.queue:
+              await self.queue.put(getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False))
+
+            return await VectorDbManager.get_strategy(self.app_tool.vector_type).invoke(
+                self.llm.get_embeddings(),
+                self.app_tool.vector_db,
+                query,
+                search_type,
+                search_kwargs,
+                app_tool=self.app_tool,
+                llm=self.llm.get_llm()
+                )
+        return []
+        #raise ValueError(f"Invalid configuration for {self.settings.name} tool of type {self.settings.type}. Must be a function or vector db not found.")
+
+    async def image_generator(self, query: str, language: str = "it"):
+        """
+        Asynchronously generates an image based on the query.
+        set OPENAI_API_KEY in your environment variables
+        """
+        from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
+        model = self.app_tool.model or "dall-e-3"
+        random_waiting_message = getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False)
+        if not language:
+            language = "it"
+        await translate_text(
+            self.llm, language, random_waiting_message, self.callbacks
+        )
+        try:
+            #set os.environ.get("OPENAI_API_KEY")!
+            image_url = DallEAPIWrapper(model=model).run(query)  # type: ignore
+            return image_url
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    #endregion
+
+    #class variables (static)
+    _list: dict[str,ToolConfig] = {
+        "document_retriever": ToolConfig(function=document_retriever, model=DocumentRetrieverInput),
+        "image_generator": ToolConfig(function=image_generator, model=ImageGeneratorInput),
+    }
+
+    #instance methods
+    def get_coroutine(self):
+        tool_cfg = self._list.get(self.app_tool.function_name)
+        return getattr(self, tool_cfg.function.__name__)  # type: ignore

ws_bom_robot_app/llm/tools/utils.py

@@ -1,25 +1,25 @@
-import random, os
-from langchain_openai import ChatOpenAI
-from langchain_core.prompts import PromptTemplate
-from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
-from ws_bom_robot_app.llm.utils.print import print_string
-
-def __print_output(data: str) -> str:
-  return print_string(data) if os.environ.get("AGENT_HANDLER_FORMATTED") == str(True) else f"{data} "
-
-def getRandomWaitingMessage(waiting_messages: str, traduction: bool = True) -> str:
-  if not waiting_messages: return ""
-  messages = [msg.strip() for msg in waiting_messages.split(";") if msg.strip()]
-  if not messages: return ""
-  chosen_message = random.choice(messages) + "\n"
-  if not traduction:
-      return __print_output(chosen_message)
-  return chosen_message
-
-async def translate_text(llm: LlmInterface, language, text: str, callbacks: list) -> str:
-  if language == "it":
-      return __print_output(text)
-  sys_message = """Il tuo compito è di tradurre il testo_da_tradurre nella seguente lingua: \n\n lingua: {language}\n\n testo_da_tradurre: {testo_da_tradurre} \n\nTraduci il testo_da_tradurre nella lingua {language} senza aggiungere altro:"""
-  prompt = PromptTemplate.from_template(sys_message)
-  chain = prompt | llm.get_llm()
-  await chain.ainvoke({"language":language, "testo_da_tradurre": text}, {"callbacks": callbacks})
+import random, os
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
+from ws_bom_robot_app.llm.utils.print import print_string
+
+def __print_output(data: str) -> str:
+  return print_string(data) if os.environ.get("AGENT_HANDLER_FORMATTED") == str(True) else f"{data} "
+
+def getRandomWaitingMessage(waiting_messages: str, traduction: bool = True) -> str:
+  if not waiting_messages: return ""
+  messages = [msg.strip() for msg in waiting_messages.split(";") if msg.strip()]
+  if not messages: return ""
+  chosen_message = random.choice(messages) + "\n"
+  if not traduction:
+      return __print_output(chosen_message)
+  return chosen_message
+
+async def translate_text(llm: LlmInterface, language, text: str, callbacks: list) -> str:
+  if language == "it":
+      return __print_output(text)
+  sys_message = """Il tuo compito è di tradurre il testo_da_tradurre nella seguente lingua: \n\n lingua: {language}\n\n testo_da_tradurre: {testo_da_tradurre} \n\nTraduci il testo_da_tradurre nella lingua {language} senza aggiungere altro:"""
+  prompt = PromptTemplate.from_template(sys_message)
+  chain = prompt | llm.get_llm()
+  await chain.ainvoke({"language":language, "testo_da_tradurre": text}, {"callbacks": callbacks})

ws_bom_robot_app/llm/utils/agent.py

@@ -1,17 +1,19 @@
-import os
-from langchain_core.embeddings import Embeddings
-from ws_bom_robot_app.llm.models.api import LlmRules
-from ws_bom_robot_app.llm.utils.print import HiddenPrints
-from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager
-
-async def get_rules(embeddings: Embeddings, rules: LlmRules, input: str) -> str:
-  with HiddenPrints():
-    if any([input=="",rules is None,rules and rules.vector_db == "",rules and not os.path.exists(rules.vector_db)]):
-      return ""
-    rules_prompt = ""
-    rules_doc = await VectorDbManager.get_strategy(rules.vector_type).invoke(embeddings, rules.vector_db,input,search_type="similarity_score_threshold", search_kwargs={"score_threshold": rules.threshold}) #type: ignore
-    if len(rules_doc) > 0:
-      rules_prompt = "\nFollow this rules: \n RULES: \n"
-      for rule_doc in rules_doc:
-        rules_prompt += "- " + rule_doc.page_content + "\n"
-    return rules_prompt
+import os
+from langchain_core.embeddings import Embeddings
+from ws_bom_robot_app.llm.models.api import LlmRules
+from ws_bom_robot_app.llm.utils.print import HiddenPrints
+from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager
+import warnings
+
+async def get_rules(embeddings: Embeddings, rules: LlmRules, input: str) -> str:
+  with warnings.catch_warnings():
+    warnings.simplefilter("ignore", category=Warning)
+    if any([input=="",rules is None,rules and rules.vector_db == "",rules and not os.path.exists(rules.vector_db)]):
+      return ""
+    rules_prompt = ""
+    rules_doc = await VectorDbManager.get_strategy(rules.vector_type).invoke(embeddings, rules.vector_db,input,search_type="similarity_score_threshold", search_kwargs={"score_threshold": rules.threshold}) #type: ignore
+    if len(rules_doc) > 0:
+      rules_prompt = "\nFollow this rules: \n RULES: \n"
+      for rule_doc in rules_doc:
+        rules_prompt += "- " + rule_doc.page_content + "\n"
+    return rules_prompt

ws_bom_robot_app/llm/utils/download.py

@@ -1,79 +1,79 @@
-from typing import List,Optional
-import os, logging, aiohttp, asyncio
-from tqdm.asyncio import tqdm
-
-async def download_files(urls: List[str], destination_folder: str, authorization: str = None):
-    tasks = [download_file(file, os.path.join(destination_folder, os.path.basename(file)), authorization=authorization) for file in urls]
-    results = await asyncio.gather(*tasks, return_exceptions=False)
-    for i, result in enumerate(results):
-        if not result:
-            raise Exception(f"Download failed for file: {urls[i]}")
-
-async def download_file(url: str, destination: str, chunk_size: int = 8192, authorization: str = None) -> Optional[str]:
-  """
-  Downloads a file from a given URL to a destination path asynchronously.
-
-  Args:
-      url: The URL of the file to download
-      destination: The local path where the file should be saved
-      chunk_size: Size of chunks to download (default: 8192 bytes)
-
-  Returns:
-      str: Path to the downloaded file if successful, None otherwise
-
-  Raises:
-      Various exceptions are caught and logged
-  """
-  try:
-      # Ensure the destination directory exists
-      os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
-
-      async with aiohttp.ClientSession() as session:
-          if authorization:
-            headers = {'Authorization': authorization}
-            session.headers.update(headers)
-          async with session.get(url) as response:
-              # Check if the request was successful
-              if response.status != 200:
-                  logging.error(f"Failed to download file. Status code: {response.status}")
-                  return None
-
-              # Get the total file size if available
-              total_size = int(response.headers.get('content-length', 0))
-              # Open the destination file and write chunks
-              with open(destination, 'wb') as f:
-                  with tqdm(
-                      total=total_size,
-                      desc="Downloading",
-                      unit='B',
-                      unit_scale=True,
-                      unit_divisor=1024
-                  ) as pbar:
-                      async for chunk in response.content.iter_chunked(chunk_size):
-                          if chunk:
-                              f.write(chunk)
-                              pbar.update(len(chunk))
-
-              logging.info(f"File downloaded successfully to {destination}")
-              return destination
-
-  except aiohttp.ClientError as e:
-      logging.error(f"Network error occurred: {str(e)}")
-      return None
-  except asyncio.TimeoutError:
-      logging.error("Download timed out")
-      return None
-  except IOError as e:
-      logging.error(f"IO error occurred: {str(e)}")
-      return None
-  except Exception as e:
-      logging.error(f"Unexpected error occurred: {str(e)}")
-      return None
-  finally:
-      # If download failed and file was partially created, clean it up
-      if os.path.exists(destination) and os.path.getsize(destination) == 0:
-          try:
-              os.remove(destination)
-              logging.info(f"Cleaned up incomplete download: {destination}")
-          except OSError:
-              pass
+from typing import List,Optional
+import os, logging, aiohttp, asyncio
+from tqdm.asyncio import tqdm
+
+async def download_files(urls: List[str], destination_folder: str, authorization: str = None):
+    tasks = [download_file(file, os.path.join(destination_folder, os.path.basename(file)), authorization=authorization) for file in urls]
+    results = await asyncio.gather(*tasks, return_exceptions=False)
+    for i, result in enumerate(results):
+        if not result:
+            raise Exception(f"Download failed for file: {urls[i]}")
+
+async def download_file(url: str, destination: str, chunk_size: int = 8192, authorization: str = None) -> Optional[str]:
+  """
+  Downloads a file from a given URL to a destination path asynchronously.
+
+  Args:
+      url: The URL of the file to download
+      destination: The local path where the file should be saved
+      chunk_size: Size of chunks to download (default: 8192 bytes)
+
+  Returns:
+      str: Path to the downloaded file if successful, None otherwise
+
+  Raises:
+      Various exceptions are caught and logged
+  """
+  try:
+      # Ensure the destination directory exists
+      os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+
+      async with aiohttp.ClientSession() as session:
+          if authorization:
+            headers = {'Authorization': authorization}
+            session.headers.update(headers)
+          async with session.get(url) as response:
+              # Check if the request was successful
+              if response.status != 200:
+                  logging.error(f"Failed to download file. Status code: {response.status}")
+                  return None
+
+              # Get the total file size if available
+              total_size = int(response.headers.get('content-length', 0))
+              # Open the destination file and write chunks
+              with open(destination, 'wb') as f:
+                  with tqdm(
+                      total=total_size,
+                      desc="Downloading",
+                      unit='B',
+                      unit_scale=True,
+                      unit_divisor=1024
+                  ) as pbar:
+                      async for chunk in response.content.iter_chunked(chunk_size):
+                          if chunk:
+                              f.write(chunk)
+                              pbar.update(len(chunk))
+
+              logging.info(f"File downloaded successfully to {destination}")
+              return destination
+
+  except aiohttp.ClientError as e:
+      logging.error(f"Network error occurred: {str(e)}")
+      return None
+  except asyncio.TimeoutError:
+      logging.error("Download timed out")
+      return None
+  except IOError as e:
+      logging.error(f"IO error occurred: {str(e)}")
+      return None
+  except Exception as e:
+      logging.error(f"Unexpected error occurred: {str(e)}")
+      return None
+  finally:
+      # If download failed and file was partially created, clean it up
+      if os.path.exists(destination) and os.path.getsize(destination) == 0:
+          try:
+              os.remove(destination)
+              logging.info(f"Cleaned up incomplete download: {destination}")
+          except OSError:
+              pass

ws_bom_robot_app/llm/utils/print.py

@@ -1,29 +1,29 @@
-import os, sys, json
-
-class HiddenPrints:
-    def __enter__(self):
-        self._original_stdout = sys.stdout
-        self._original_stderr = sys.stderr
-
-        sys.stdout = open(os.devnull, 'w')
-        sys.stderr = open(os.devnull, 'w')
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        sys.stdout.close()
-        sys.stderr.close()
-        sys.stdout = self._original_stdout
-        sys.stderr = self._original_stderr
-
-def print_json(data) -> str:
-    return print_single_json(data) + ","
-
-def print_single_json(data) -> str:
-    return json.dumps(data, sort_keys=True)
-
-def print_string(data: str) -> str:
-    if data != "":
-        return print_json(data)
-
-def print_single_string(data: str) -> str:
-    if data != "":
-        return print_single_json(data)
+import os, sys, json
+
+class HiddenPrints:
+    def __enter__(self):
+        self._original_stdout = sys.stdout
+        self._original_stderr = sys.stderr
+
+        sys.stdout = open(os.devnull, 'w')
+        sys.stderr = open(os.devnull, 'w')
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        sys.stdout.close()
+        sys.stderr.close()
+        sys.stdout = self._original_stdout
+        sys.stderr = self._original_stderr
+
+def print_json(data) -> str:
+    return print_single_json(data) + ","
+
+def print_single_json(data) -> str:
+    return json.dumps(data, sort_keys=True)
+
+def print_string(data: str) -> str:
+    if data != "":
+        return print_json(data)
+
+def print_single_string(data: str) -> str:
+    if data != "":
+        return print_single_json(data)