ws-bom-robot-app 0.0.102__py3-none-any.whl → 0.0.104__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/chunker.py

@@ -1,20 +1,82 @@
 from langchain_core.documents import Document
-from langchain_text_splitters import CharacterTextSplitter
-import logging
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 
 class DocumentChunker:
-  _MAX_CHUNK_SIZE = 10_000
   @staticmethod
   def chunk(documents: list[Document]) -> list[Document]:
-      text_splitter = CharacterTextSplitter(chunk_size=DocumentChunker._MAX_CHUNK_SIZE, chunk_overlap=int(DocumentChunker._MAX_CHUNK_SIZE * 0.02))
-      chunked_documents = []
-      for doc in documents:
-          if len(doc.page_content) <= DocumentChunker._MAX_CHUNK_SIZE:
-              chunked_documents.append(doc)
-              continue
-          chunks = text_splitter.split_text(doc.page_content)
-          for chunk in chunks:
-              chunked_documents.append(
-                  Document(page_content=chunk, metadata=doc.metadata)
-              )
-      return chunked_documents
+       return DocumentChunker.chunk_recursive(documents)
+
+  @staticmethod
+  def chunk_recursive(documents: list[Document], chunk_size: int=3_000) -> list[Document]:
+        """
+        Recursively split documents into smaller chunks while preserving metadata.
+
+        This function takes a list of documents and splits them into smaller chunks using
+        RecursiveCharacterTextSplitter. Documents smaller than the chunk size are kept intact,
+        while larger documents are split into multiple chunks with overlapping content.
+
+        Args:
+            documents (list[Document]): A list of Document objects to be chunked.
+            chunk_size (int, optional): The maximum size of each chunk in characters. 
+                Defaults to 3,000.
+
+        Returns:
+            list[Document]: A list of Document objects where each document's content is 
+                at most chunk_size characters. Each chunk preserves the metadata from 
+                its original document.
+
+        Notes:
+            - Chunk overlap is automatically set to 10% of the chunk_size to maintain 
+              context between chunks.
+            - Documents smaller than or equal to chunk_size are returned unchanged.
+            - Metadata from the original document is copied to all resulting chunks.
+        """
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=int(chunk_size//10))
+        chunked_documents = []
+        for doc in documents:
+            if len(doc.page_content) <= chunk_size:
+                chunked_documents.append(doc)
+                continue
+            chunks = text_splitter.split_text(doc.page_content)
+            for chunk in chunks:
+                chunked_documents.append(
+                    Document(page_content=chunk, metadata=doc.metadata)
+                )
+        return chunked_documents
+
+  @staticmethod
+  def chunk_token(documents: list[Document], max_tokens: int=1_000) -> list[Document]:
+        """
+        Splits a list of documents into smaller chunks based on token count.
+
+        This function takes a list of Document objects and splits them into smaller chunks
+        using a recursive character text splitter based on tiktoken encoding. Each chunk
+        respects the maximum token limit while maintaining some overlap between consecutive
+        chunks for context preservation.
+
+        Args:
+            documents (list[Document]): A list of Document objects to be chunked. Each Document
+                should have 'page_content' (str) and 'metadata' (dict) attributes.
+            max_tokens (int, optional): The maximum number of tokens allowed per chunk.
+                Defaults to 1,000. The chunk overlap is automatically set to 10% of this value.
+
+        Returns:
+            list[Document]: A list of new Document objects where each document represents a chunk
+                of the original documents. Each chunked Document preserves the metadata from its
+                source document.
+
+        Note:
+            - Uses the "cl100k_base" tiktoken encoding (commonly used for GPT-4 and similar models)
+            - Chunk overlap is set to max_tokens // 10 to maintain context between chunks
+            - Original document metadata is preserved in all generated chunks
+        """
+        text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(encoding_name="cl100k_base",chunk_size=max_tokens, chunk_overlap=max_tokens//10)
+        chunked_documents = []
+        for doc in documents:
+            chunks = text_splitter.split_text(doc.page_content)
+            for chunk in chunks:
+                chunked_documents.append(
+                    Document(page_content=chunk, metadata=doc.metadata)
+                )
+        return chunked_documents
+

ws_bom_robot_app/llm/utils/cms.py

@@ -1,123 +1,123 @@
-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
-  def __to_dict(obj):
-      """Converts DictObject to dict recursively"""
-      if isinstance(obj, DictObject):
-          return {k: __to_dict(v) for k, v in obj.__dict__.items()}
-      elif isinstance(obj, list):
-          return [__to_dict(item) for item in obj]
-      else:
-          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=''),
-                      output_structure= __to_dict(__attr(_cms_app_dict.settings,'llmConfig','outputStructure')) if __attr(_cms_app_dict.settings,'llmConfig','outputStructure') else None
-                    ))
-                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
+  def __to_dict(obj):
+      """Converts DictObject to dict recursively"""
+      if isinstance(obj, DictObject):
+          return {k: __to_dict(v) for k, v in obj.__dict__.items()}
+      elif isinstance(obj, list):
+          return [__to_dict(item) for item in obj]
+      else:
+          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=''),
+                      output_structure= __to_dict(__attr(_cms_app_dict.settings,'llmConfig','outputStructure')) if __attr(_cms_app_dict.settings,'llmConfig','outputStructure') else None
+                    ))
+                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