ws-bom-robot-app 0.0.75__py3-none-any.whl → 0.0.77__py3-none-any.whl

ws_bom_robot_app/llm/tools/utils.py

@@ -1,41 +1,41 @@
-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})
-
-async def fetch_page(session, url):
-    try:
-        async with session.get(url, timeout=10, ssl=False) as response:
-            if response.status == 200:
-                text = await response.text()
-                return {"url": url, "html": text}
-            else:
-                return {"url": url, "html": None}
-    except Exception as e:
-        return {"url": url, "html": None}
-
-async def extract_content_with_trafilatura(html):
-    """Estrae solo il testo principale usando trafilatura"""
-    import trafilatura
-    return trafilatura.extract(html)
+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})
+
+async def fetch_page(session, url):
+    try:
+        async with session.get(url, timeout=10, ssl=False) as response:
+            if response.status == 200:
+                text = await response.text()
+                return {"url": url, "html": text}
+            else:
+                return {"url": url, "html": None}
+    except Exception as e:
+        return {"url": url, "html": None}
+
+async def extract_content_with_trafilatura(html):
+    """Estrae solo il testo principale usando trafilatura"""
+    import trafilatura
+    return trafilatura.extract(html)

ws_bom_robot_app/llm/utils/agent.py

@@ -1,34 +1,34 @@
-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, query: str | list) -> str:
-  with warnings.catch_warnings():
-    warnings.simplefilter("ignore", category=Warning)
-    # check if the input is multimodal and convert it to text
-    if isinstance(query, list):
-      query = " ".join(obj.get("text", "") for obj in query)
-    # check if the input is empty or the rules are not provided
-    if any([query=="",rules is None,rules and rules.vector_db == "",rules and not os.path.exists(rules.vector_db)]):
-      return ""
-    # get the rules from the vector db and return prompt with rules
-    rules_prompt = ""
-    rules_doc = await VectorDbManager.get_strategy(rules.vector_type).invoke(
-      embeddings,
-      rules.vector_db,
-      query,
-      search_type="similarity_score_threshold",
-      search_kwargs={
-        "score_threshold": rules.threshold,
-        "k": 500,
-        "fetch_k": 500,
-      },
-      source = None) #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, query: str | list) -> str:
+  with warnings.catch_warnings():
+    warnings.simplefilter("ignore", category=Warning)
+    # check if the input is multimodal and convert it to text
+    if isinstance(query, list):
+      query = " ".join(obj.get("text", "") for obj in query)
+    # check if the input is empty or the rules are not provided
+    if any([query=="",rules is None,rules and rules.vector_db == "",rules and not os.path.exists(rules.vector_db)]):
+      return ""
+    # get the rules from the vector db and return prompt with rules
+    rules_prompt = ""
+    rules_doc = await VectorDbManager.get_strategy(rules.vector_type).invoke(
+      embeddings,
+      rules.vector_db,
+      query,
+      search_type="similarity_score_threshold",
+      search_kwargs={
+        "score_threshold": rules.threshold,
+        "k": 500,
+        "fetch_k": 500,
+      },
+      source = None) #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/cms.py

@@ -1,114 +1,114 @@
-import logging, aiohttp
-from typing import Any, List, Optional
-from pydantic import AliasChoices, BaseModel, ConfigDict, Field
-from ws_bom_robot_app.llm.models.api import LlmAppTool, LlmRules, StreamRequest
-from ws_bom_robot_app.llm.models.kb import LlmKbEndpoint, LlmKbIntegration
-from ws_bom_robot_app.util import cache_with_ttl
-
-class CmsAppCredential(BaseModel):
-  app_key: str = Field(..., description="The app key for the credential", validation_alias=AliasChoices("appKey","app_key"))
-  api_key: str = Field(..., description="The api key for the credential", validation_alias=AliasChoices("apiKey","api_key"))
-  model_config = ConfigDict(extra='ignore')
-class CmsApp(BaseModel):
-  id: str = Field(..., description="Unique identifier for the app")
-  name: str = Field(..., description="Name of the app")
-  mode: str
-  prompt_samples: Optional[List[str]]
-  credentials: CmsAppCredential = None
-  rq: StreamRequest
-  kb: Optional[Any] = None
-  model_config = ConfigDict(extra='ignore')
-
-@cache_with_ttl(600)  # Cache for 10 minutes
-async def get_apps() -> list[CmsApp]:
-  import json
-  from ws_bom_robot_app.config import config
-  class DictObject(object):
-      def __init__(self, dict_):
-          self.__dict__.update(dict_)
-      def __repr__(self):
-          return json.dumps(self.__dict__)
-      @classmethod
-      def from_dict(cls, d):
-          return json.loads(json.dumps(d), object_hook=DictObject)
-  def __attr(obj, *attrs, default=None):
-      for attr in attrs:
-          obj = getattr(obj, attr, default)
-          if obj is None:
-              break
-      return obj
-  host = config.robot_cms_host
-  if host:
-    url = f"{host}/api/llmApp?depth=1&pagination=false&locale=it"
-    auth = config.robot_cms_auth
-    headers = {"Authorization": auth} if auth else {}
-    async with aiohttp.ClientSession() as session:
-      async with session.get(url, headers=headers) as response:
-        if response.status == 200:
-          _apps=[]
-          cms_apps = await response.json()
-          for cms_app in cms_apps:
-             if __attr(cms_app,"isActive",default=True) == True:
-                _cms_app_dict = DictObject.from_dict(cms_app)
-                try:
-                  _app: CmsApp = CmsApp(
-                    id=_cms_app_dict.id,
-                    name=_cms_app_dict.name,
-                    mode=_cms_app_dict.mode,
-                    prompt_samples=[__attr(sample,'sampleInputText') or f"{sample.__dict__}" for sample in _cms_app_dict.contents.sampleInputTexts],
-                    credentials=CmsAppCredential(app_key=_cms_app_dict.settings.credentials.appKey,api_key=_cms_app_dict.settings.credentials.apiKey),
-                    rq=StreamRequest(
-                      #thread_id=str(uuid.uuid1()),
-                      messages=[],
-                      secrets={
-                        "apiKey": __attr(_cms_app_dict.settings,'llmConfig','secrets','apiKey', default=''),
-                        "langChainApiKey": __attr(_cms_app_dict.settings,'llmConfig','secrets','langChainApiKey', default=''),
-                        "nebulyApiKey": __attr(_cms_app_dict.settings,'llmConfig','secrets','nebulyApiKey', default=''),
-                        },
-                      system_message=__attr(_cms_app_dict.settings,'llmConfig','prompt','prompt','systemMessage') if __attr(_cms_app_dict.settings,'llmConfig','prompt','prompt','systemMessage') else __attr(_cms_app_dict.settings,'llmConfig','prompt','systemMessage'),
-                      provider= __attr(_cms_app_dict.settings,'llmConfig','provider') or 'openai',
-                      model= __attr(_cms_app_dict.settings,'llmConfig','model') or 'gpt-4o',
-                      temperature=_cms_app_dict.settings.llmConfig.temperature or 0,
-                      app_tools=[LlmAppTool(**tool) for tool in cms_app.get('settings').get('appTools',[])],
-                      rules=LlmRules(
-                        vector_type=__attr(_cms_app_dict.settings,'rules','vectorDbType', default='faiss'),
-                        vector_db=__attr(_cms_app_dict.settings,'rules','vectorDbFile','filename'),
-                        threshold=__attr(_cms_app_dict.settings,'rules','threshold', default=0.7)
-                        ) if __attr(_cms_app_dict.settings,'rules','vectorDbFile','filename') else None,
-                      #fine_tuned_model=__attr(_cms_app_dict.settings,'llmConfig','fineTunedModel'),
-                      lang_chain_tracing= __attr(_cms_app_dict.settings,'llmConfig','langChainTracing', default=False),
-                      lang_chain_project= __attr(_cms_app_dict.settings,'llmConfig','langChainProject', default='')
-                    ))
-                except Exception as e:
-                  import traceback
-                  ex = traceback.format_exc()
-                  logging.error(f"Error creating CmsApp {_cms_app_dict.name} from dict: {e}\n{ex}")
-                  continue
-                if _app.rq.app_tools:
-                  for tool in _app.rq.app_tools:
-                    _knowledgeBase = tool.knowledgeBase
-                    tool.integrations = [LlmKbIntegration(**item) for item in _knowledgeBase.get('integrations')] if _knowledgeBase.get('integrations') else []
-                    try:
-                      tool.endpoints = [LlmKbEndpoint(**item) for item in _knowledgeBase.get('externalEndpoints')] if _knowledgeBase.get('externalEndpoints') else []
-                    except Exception as e:
-                      logging.error(f"Error parsing endpoints for app {_cms_app_dict.name} tool {tool.name}: {e}")
-                    tool.vector_db = _knowledgeBase.get('vectorDbFile').get('filename') if _knowledgeBase.get('vectorDbFile') else None
-                    tool.vector_type = _knowledgeBase.get('vectorDbType') if _knowledgeBase.get('vectorDbType') else 'faiss'
-                    del tool.knowledgeBase
-                _apps.append(_app)
-          return _apps
-        else:
-          logging.error(f"Error fetching cms apps: {response.status}")
-  else:
-    logging.error("robot_cms_host environment variable is not set.")
-  return []
-
-
-async def get_app_by_id(app_id: str) -> CmsApp | None:
-    apps = await get_apps()
-    app = next((a for a in apps if a.id == app_id), None)
-    if app:
-        return app
-    else:
-        logging.error(f"App with id {app_id} not found.")
-        return None
+import logging, aiohttp
+from typing import Any, List, Optional
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+from ws_bom_robot_app.llm.models.api import LlmAppTool, LlmRules, StreamRequest
+from ws_bom_robot_app.llm.models.kb import LlmKbEndpoint, LlmKbIntegration
+from ws_bom_robot_app.util import cache_with_ttl
+
+class CmsAppCredential(BaseModel):
+  app_key: str = Field(..., description="The app key for the credential", validation_alias=AliasChoices("appKey","app_key"))
+  api_key: str = Field(..., description="The api key for the credential", validation_alias=AliasChoices("apiKey","api_key"))
+  model_config = ConfigDict(extra='ignore')
+class CmsApp(BaseModel):
+  id: str = Field(..., description="Unique identifier for the app")
+  name: str = Field(..., description="Name of the app")
+  mode: str
+  prompt_samples: Optional[List[str]]
+  credentials: CmsAppCredential = None
+  rq: StreamRequest
+  kb: Optional[Any] = None
+  model_config = ConfigDict(extra='ignore')
+
+@cache_with_ttl(600)  # Cache for 10 minutes
+async def get_apps() -> list[CmsApp]:
+  import json
+  from ws_bom_robot_app.config import config
+  class DictObject(object):
+      def __init__(self, dict_):
+          self.__dict__.update(dict_)
+      def __repr__(self):
+          return json.dumps(self.__dict__)
+      @classmethod
+      def from_dict(cls, d):
+          return json.loads(json.dumps(d), object_hook=DictObject)
+  def __attr(obj, *attrs, default=None):
+      for attr in attrs:
+          obj = getattr(obj, attr, default)
+          if obj is None:
+              break
+      return obj
+  host = config.robot_cms_host
+  if host:
+    url = f"{host}/api/llmApp?depth=1&pagination=false&locale=it"
+    auth = config.robot_cms_auth
+    headers = {"Authorization": auth} if auth else {}
+    async with aiohttp.ClientSession() as session:
+      async with session.get(url, headers=headers) as response:
+        if response.status == 200:
+          _apps=[]
+          cms_apps = await response.json()
+          for cms_app in cms_apps:
+             if __attr(cms_app,"isActive",default=True) == True:
+                _cms_app_dict = DictObject.from_dict(cms_app)
+                try:
+                  _app: CmsApp = CmsApp(
+                    id=_cms_app_dict.id,
+                    name=_cms_app_dict.name,
+                    mode=_cms_app_dict.mode,
+                    prompt_samples=[__attr(sample,'sampleInputText') or f"{sample.__dict__}" for sample in _cms_app_dict.contents.sampleInputTexts],
+                    credentials=CmsAppCredential(app_key=_cms_app_dict.settings.credentials.appKey,api_key=_cms_app_dict.settings.credentials.apiKey),
+                    rq=StreamRequest(
+                      #thread_id=str(uuid.uuid1()),
+                      messages=[],
+                      secrets={
+                        "apiKey": __attr(_cms_app_dict.settings,'llmConfig','secrets','apiKey', default=''),
+                        "langChainApiKey": __attr(_cms_app_dict.settings,'llmConfig','secrets','langChainApiKey', default=''),
+                        "nebulyApiKey": __attr(_cms_app_dict.settings,'llmConfig','secrets','nebulyApiKey', default=''),
+                        },
+                      system_message=__attr(_cms_app_dict.settings,'llmConfig','prompt','prompt','systemMessage') if __attr(_cms_app_dict.settings,'llmConfig','prompt','prompt','systemMessage') else __attr(_cms_app_dict.settings,'llmConfig','prompt','systemMessage'),
+                      provider= __attr(_cms_app_dict.settings,'llmConfig','provider') or 'openai',
+                      model= __attr(_cms_app_dict.settings,'llmConfig','model') or 'gpt-4o',
+                      temperature=_cms_app_dict.settings.llmConfig.temperature or 0,
+                      app_tools=[LlmAppTool(**tool) for tool in cms_app.get('settings').get('appTools',[])],
+                      rules=LlmRules(
+                        vector_type=__attr(_cms_app_dict.settings,'rules','vectorDbType', default='faiss'),
+                        vector_db=__attr(_cms_app_dict.settings,'rules','vectorDbFile','filename'),
+                        threshold=__attr(_cms_app_dict.settings,'rules','threshold', default=0.7)
+                        ) if __attr(_cms_app_dict.settings,'rules','vectorDbFile','filename') else None,
+                      #fine_tuned_model=__attr(_cms_app_dict.settings,'llmConfig','fineTunedModel'),
+                      lang_chain_tracing= __attr(_cms_app_dict.settings,'llmConfig','langChainTracing', default=False),
+                      lang_chain_project= __attr(_cms_app_dict.settings,'llmConfig','langChainProject', default='')
+                    ))
+                except Exception as e:
+                  import traceback
+                  ex = traceback.format_exc()
+                  logging.error(f"Error creating CmsApp {_cms_app_dict.name} from dict: {e}\n{ex}")
+                  continue
+                if _app.rq.app_tools:
+                  for tool in _app.rq.app_tools:
+                    _knowledgeBase = tool.knowledgeBase
+                    tool.integrations = [LlmKbIntegration(**item) for item in _knowledgeBase.get('integrations')] if _knowledgeBase.get('integrations') else []
+                    try:
+                      tool.endpoints = [LlmKbEndpoint(**item) for item in _knowledgeBase.get('externalEndpoints')] if _knowledgeBase.get('externalEndpoints') else []
+                    except Exception as e:
+                      logging.error(f"Error parsing endpoints for app {_cms_app_dict.name} tool {tool.name}: {e}")
+                    tool.vector_db = _knowledgeBase.get('vectorDbFile').get('filename') if _knowledgeBase.get('vectorDbFile') else None
+                    tool.vector_type = _knowledgeBase.get('vectorDbType') if _knowledgeBase.get('vectorDbType') else 'faiss'
+                    del tool.knowledgeBase
+                _apps.append(_app)
+          return _apps
+        else:
+          logging.error(f"Error fetching cms apps: {response.status}")
+  else:
+    logging.error("robot_cms_host environment variable is not set.")
+  return []
+
+
+async def get_app_by_id(app_id: str) -> CmsApp | None:
+    apps = await get_apps()
+    app = next((a for a in apps if a.id == app_id), None)
+    if app:
+        return app
+    else:
+        logging.error(f"App with id {app_id} not found.")
+        return None

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)