ws-bom-robot-app 0.0.23__tar.gz → 0.0.24__tar.gz

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ws_bom_robot_app
-Version: 0.0.23
+Version: 0.0.24
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa
@@ -30,12 +30,12 @@ Requires-Dist: unstructured-ingest[azure]
 Requires-Dist: unstructured-ingest[confluence]
 Requires-Dist: unstructured-ingest[dropbox]
 Requires-Dist: unstructured-ingest[gcs]
-Requires-Dist: unstructured-ingest[google_drive]
 Requires-Dist: unstructured-ingest[github]
+Requires-Dist: unstructured-ingest[google_drive]
 Requires-Dist: unstructured-ingest[jira]
 Requires-Dist: unstructured-ingest[s3]
-Requires-Dist: unstructured-ingest[slack]
 Requires-Dist: unstructured-ingest[sftp]
+Requires-Dist: unstructured-ingest[slack]
 Requires-Dist: html5lib==1.1
 Requires-Dist: markdownify==0.14.1
 Requires-Dist: nebuly==0.3.33

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="ws_bom_robot_app",
-    version="0.0.23",
+    version="0.0.24",
     description="A FastAPI application serving ws bom/robot/llm platform ai.",
     long_description=open("README.md", encoding='utf-8').read(),
     long_description_content_type="text/markdown",

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app/llm/agent_handler.py

@@ -1,3 +1,4 @@
+from asyncio import Queue
 from langchain_core.agents import AgentFinish
 from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
 from langchain.callbacks.base import AsyncCallbackHandler
@@ -16,13 +17,13 @@ import json
 
 class AgentHandler(AsyncCallbackHandler):
 
-    def __init__(self, threadId) -> None:
+    def __init__(self, queue: Queue, threadId: str = None) -> None:
         super().__init__()
         self._threadId = threadId
-        self.json_cards = None
         self.json_block = ""
         self.is_json_block = False
         self.backtick_count = 0  # Conteggio dei backticks per il controllo accurato
+        self.queue = queue
 
     async def on_llm_start(
         self,
@@ -39,7 +40,7 @@ class AgentHandler(AsyncCallbackHandler):
             "type": "info",
             "threadId": self._threadId,
         }
-        printJson(firstChunk)
+        await self.queue.put(printString(firstChunk))
 
     """async def on_chat_model_start(self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], *, run_id: UUID = None, parent_run_id = None, tags = None, metadata = None, **kwargs: Any) -> Any:
         pass"""
@@ -75,7 +76,7 @@ class AgentHandler(AsyncCallbackHandler):
             elif self.is_json_block:
                 self.json_block += token
             else:
-                printString(token)
+                await self.queue.put(printString(token))
         pass
 
     async def on_agent_finish(
@@ -92,12 +93,9 @@ class AgentHandler(AsyncCallbackHandler):
                 AIMessage(content=finish.return_values["output"]),
             ]
         )
-        if self.json_cards:
-          for card in self.json_cards:
-            printJson(card)
-          self.json_cards = None
         finalChunk = {"type": "end"}
-        printJson(finalChunk)
+        await self.queue.put(printJson(finalChunk))
+        await self.queue.put(None)
 
     async def process_json_block(self, json_block: str):
       """Processa il blocco JSON completo."""
@@ -108,15 +106,16 @@ class AgentHandler(AsyncCallbackHandler):
           try:
               # Prova a fare il parsing del JSON
               parsed_json = json.loads(json_block_clean)
-              printJson(parsed_json)
+              await self.queue.put(printJson(parsed_json))
           except json.JSONDecodeError as e:
               # Se il JSON è malformato, logga l'errore
               raise e
 
 class RawAgentHandler(AsyncCallbackHandler):
 
-    def __init__(self) -> None:
+    def __init__(self,queue: Queue) -> None:
         super().__init__()
+        self.queue = queue
 
     async def on_llm_start(
         self,
@@ -147,10 +146,9 @@ class RawAgentHandler(AsyncCallbackHandler):
         tags: Optional[List[str]] = None,
         **kwargs: Any,
     ) -> None:
-        """Gestisce i nuovi token durante lo streaming."""
-        if token != "":
-            print(token)
-        pass
+        """Handles new tokens during streaming."""
+        if token:  # Only process non-empty tokens
+            await self.queue.put(token)
 
     async def on_agent_finish(
         self,
@@ -166,3 +164,4 @@ class RawAgentHandler(AsyncCallbackHandler):
                 AIMessage(content=finish.return_values["output"]),
             ]
         )
+        await self.queue.put(None)

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app/llm/api.py

@@ -25,18 +25,10 @@ async def _invoke(rq: InvokeRequest):
 async def _stream(rq: StreamRequest) -> StreamingResponse:
     return StreamingResponse(stream(rq), media_type="application/json")
 
-@router.post("/stream/none")
-async def _stream_none(rq: StreamRequest) -> None:
-    await stream_none(rq)
-
 @router.post("/stream/raw")
 async def _stream_raw(rq: StreamRequest) -> StreamingResponse:
     return StreamingResponse(stream(rq, formatted=False), media_type="application/json")
 
-@router.post("/stream/raw/none")
-async def _stream_raw_none(rq: StreamRequest) -> None:
-     await stream_none(rq, formatted=False)
-
 @router.post("/kb")
 async def _kb(rq: KbRequest) -> VectorDbResponse:
     return await kb(rq)

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app/llm/main.py

@@ -10,6 +10,7 @@ from nebuly.providers.langchain import LangChainTrackingHandler
 from langchain_core.callbacks.base import AsyncCallbackHandler
 import warnings, asyncio, os, io, sys, json
 from typing import List
+from asyncio import Queue
 
 async def invoke(rq: InvokeRequest) -> str:
   await rq.initialize()
@@ -22,12 +23,12 @@ async def invoke(rq: InvokeRequest) -> str:
   result: AIMessage = await processor.run_agent(_msg)
   return {"result": result.content}
 
-async def __stream(rq: StreamRequest,formatted: bool = True) -> None:
+async def __stream(rq: StreamRequest,queue: Queue,formatted: bool = True) -> None:
   await rq.initialize()
   if formatted:
-    agent_handler = AgentHandler(rq.thread_id)
+    agent_handler = AgentHandler(queue,rq.thread_id)
   else:
-    agent_handler = RawAgentHandler()
+    agent_handler = RawAgentHandler(queue)
   os.environ["AGENT_HANDLER_FORMATTED"] = str(formatted)
   callbacks: List[AsyncCallbackHandler] = [agent_handler]
   settings.init()
@@ -53,7 +54,7 @@ async def __stream(rq: StreamRequest,formatted: bool = True) -> None:
   processor = AgentLcel(
       openai_config={"api_key": rq.secrets["openAIApiKey"], "openai_model": rq.model, "temperature": rq.temperature},
       sys_message=rq.system_message,
-      tools=get_structured_tools(tools=rq.app_tools, api_key=rq.secrets["openAIApiKey"], callbacks=[callbacks[0]]),
+      tools=get_structured_tools(tools=rq.app_tools, api_key=rq.secrets["openAIApiKey"], callbacks=[callbacks[0]], queue=queue),
       rules=rq.rules
   )
 
@@ -71,25 +72,20 @@ async def __stream(rq: StreamRequest,formatted: bool = True) -> None:
         {"callbacks": callbacks},
     )
 
+  # Signal the end of streaming
+  await queue.put(None)
+
 async def stream(rq: StreamRequest,formatted:bool = True) -> AsyncGenerator[str, None]:
-    sys_stdout = io.StringIO()
-    original_stdout = sys.stdout
-    sys.stdout = sys_stdout
+    queue = Queue()
+    task = asyncio.create_task(__stream(rq, queue, formatted))
     try:
-        task = asyncio.create_task(__stream(rq,formatted))
-        while not task.done():
-            await asyncio.sleep(0.1)  # yield control to avoid blocking
-            output = sys_stdout.getvalue()
-            if output:
-                yield output
-                sys_stdout.truncate(0)
-                sys_stdout.seek(0)
-        # capture any remaining output after the task completes
-        output = sys_stdout.getvalue()
-        if output:
-            yield output
+        while True:
+            token = await queue.get()
+            if token is None:  # None indicates the end of streaming
+                break
+            yield token
     finally:
-        sys.stdout = original_stdout
+        await task
 
 async def stream_none(rq: StreamRequest, formatted: bool = True) -> None:
   await __stream(rq, formatted)

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app/llm/tools/tool_builder.py

@@ -1,12 +1,13 @@
+from asyncio import Queue
 from langchain.tools import StructuredTool
 from ws_bom_robot_app.llm.models.api import LlmAppTool
 from ws_bom_robot_app.llm.tools.tool_manager import ToolManager
 
-def get_structured_tools(tools: list[LlmAppTool], api_key:str, callbacks:list) -> list[StructuredTool]:
+def get_structured_tools(tools: list[LlmAppTool], api_key:str, callbacks:list, queue: Queue) -> list[StructuredTool]:
   _structured_tools :list[StructuredTool] = []
   for tool in [tool for tool in tools if tool.is_active]:
     if _tool_config := ToolManager._list.get(tool.function_name):
-      _tool_instance = ToolManager(tool, api_key, callbacks)
+      _tool_instance = ToolManager(tool, api_key, callbacks, queue)
       _structured_tool = StructuredTool.from_function(
         coroutine=_tool_instance.get_coroutine(),
         name=tool.function_id,

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app/llm/tools/tool_manager.py

@@ -1,3 +1,4 @@
+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.utils.faiss_helper import FaissHelper
@@ -33,10 +34,12 @@ class ToolManager:
         app_tool: LlmAppTool,
         api_key: str,
         callbacks: list,
+        queue: Optional[Queue] = None
     ):
         self.app_tool = app_tool
         self.api_key = api_key
         self.callbacks = callbacks
+        self.queue = queue
 
 
     #region functions
@@ -64,7 +67,8 @@ class ToolManager:
                 else:
                     search_type = "mixed"
                     search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
-            getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False)
+            if self.queue:
+              await self.queue.put(getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False))
             return await FaissHelper.invoke(self.app_tool.vector_db, self.api_key, query, search_type, search_kwargs)
         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.")

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app/llm/tools/utils.py

@@ -3,8 +3,8 @@ from langchain_openai import ChatOpenAI
 from langchain_core.prompts import PromptTemplate
 from ws_bom_robot_app.llm.utils.print import printString
 
-def __print_output(data: str) -> None:
-  printString(data) if os.environ.get("AGENT_HANDLER_FORMATTED") == str(True) else print(f"{data} ")
+def __print_output(data: str) -> str:
+  return printString(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 ""
@@ -12,13 +12,12 @@ def getRandomWaitingMessage(waiting_messages: str, traduction: bool = True) -> s
   if not messages: return ""
   chosen_message = random.choice(messages) + "\n"
   if not traduction:
-      __print_output(chosen_message)
+      return __print_output(chosen_message)
   return chosen_message
 
 async def translate_text(api_key, language, text: str, callbacks: list) -> str:
   if language == "it":
-      __print_output(text)
-      return
+      return __print_output(text)
   llm = ChatOpenAI(api_key=api_key, model="gpt-3.5-turbo-0125", streaming=True)
   sys_message = """Il tuo compito è di tradurre il testo_da_tradure nella seguente lingua: \n\n lingua: {language}\n\n testo_da_tradure: {testo_da_tradure} \n\nTraduci il testo_da_tradure nella lingua {language} senza aggiungere altro:"""
   prompt = PromptTemplate.from_template(sys_message)

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app/llm/utils/print.py

@@ -14,16 +14,16 @@ class HiddenPrints:
         sys.stdout = self._original_stdout
         sys.stderr = self._original_stderr
 
-def printJson(data) -> None:
-    print(json.dumps(data, indent=2, sort_keys=True), end=",", flush=True)
+def printJson(data) -> str:
+    return f"{json.dumps(data, indent=2, sort_keys=True)},"
 
 def printSingleJson(data) -> str:
-    print(json.dumps(data, indent=2, sort_keys=True), end="", flush=True)
+    return f"{json.dumps(data, indent=2, sort_keys=True)}"
 
-def printString(data: str) -> None:
+def printString(data: str) -> str:
     if data != "":
-        printJson(data)
+        return printJson(data)
 
-def printSingleString(data: str) -> None:
+def printSingleString(data: str) -> str:
     if data != "":
-        printSingleJson(data)
+        return printSingleJson(data)

ws_bom_robot_app-0.0.24/ws_bom_robot_app/llm/vector_store/integration/sharepoint.py

@@ -0,0 +1,51 @@
+import asyncio
+from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy, UnstructuredIngest
+from unstructured_ingest.v2.processes.connectors.sharepoint  import SharepointIndexerConfig, SharepointDownloaderConfig, SharepointConnectionConfig, SharepointAccessConfig
+from langchain_core.documents import Document
+from ws_bom_robot_app.llm.vector_store.loader.base import Loader
+from typing import Union, Optional
+from pydantic import BaseModel, Field, AliasChoices
+
+class SharepointParams(BaseModel):
+  client_id : str = Field(validation_alias=AliasChoices("clientId","client_id"))
+  client_secret : str = Field(validation_alias=AliasChoices("clientSecret","client_secret"))
+  site_url: str = Field(validation_alias=AliasChoices("siteUrl","site_url"))
+  site_path: str = Field(default=None,validation_alias=AliasChoices("sitePath","site_path"))
+  recursive: bool = Field(default=False)
+  omit_files: bool = Field(default=False, validation_alias=AliasChoices("omitFiles","omit_files")),
+  omit_pages: bool = Field(default=False, validation_alias=AliasChoices("omitPages","omit_pages")),
+  omit_lists: bool = Field(default=False, validation_alias=AliasChoices("omitLists","omit_lists")),
+  extension: list[str] = Field(default=None)
+class Sharepoint(IntegrationStrategy):
+  def __init__(self, knowledgebase_path: str, data: dict[str, Union[str,int,list]]):
+    super().__init__(knowledgebase_path, data)
+    self.__data = SharepointParams.model_validate(self.data)
+    self.__unstructured_ingest = UnstructuredIngest(self.working_directory)
+  def working_subdirectory(self) -> str:
+    return 'sharepoint'
+  def run(self) -> None:
+    indexer_config = SharepointIndexerConfig(
+      path=self.__data.site_path,
+      recursive=self.__data.recursive,
+      omit_files=self.__data.omit_files,
+      omit_pages=self.__data.omit_pages,
+      omit_lists=self.__data.omit_lists
+    )
+    downloader_config = SharepointDownloaderConfig(
+      download_dir=self.working_directory
+    )
+    connection_config = SharepointConnectionConfig(
+      access_config=SharepointAccessConfig(client_cred=self.__data.client_secret),
+      client_id=self.__data.client_id,
+      site=self.__data.site_url,
+      permissions_config=None
+    )
+    self.__unstructured_ingest.pipeline(
+      indexer_config,
+      downloader_config,
+      connection_config,
+      extension=self.__data.extension).run()
+  async def load(self) -> list[Document]:
+      await asyncio.to_thread(self.run)
+      await asyncio.sleep(1)
+      return await Loader(self.working_directory).load()

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app/llm/vector_store/loader/base.py

@@ -12,7 +12,10 @@ from ws_bom_robot_app.llm.vector_store.loader.json_loader import JsonLoader
 
 class LoaderConfig(BaseModel):
   loader: type[BaseLoader]
-  kwargs: Optional[dict[str, Any]] = {}
+  kwargs: Optional[dict[str, Any]] = {
+       'chunking_strategy': 'basic',
+       'max_characters': 10_000
+       }
   #post_processors: Optional[list[Callable[[str], str]]] = None
 
 class Loader():
@@ -45,7 +48,7 @@ class Loader():
        'strategy':'ocr_only', #https://docs.unstructured.io/open-source/core-functionality/partitioning auto,ocr_only,hi_res
        'split_pdf_page': False,
        'chunking_strategy': 'basic',
-       'max_characters': 1000000,
+       'max_characters': 10_000,
        'include_page_breaks': True,
        'include_orig_elements': False}),
     '.png': LoaderConfig(loader=UnstructuredLoader,kwargs={"strategy":"ocr_only"}),

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app/requirements.txt

@@ -27,12 +27,12 @@ unstructured-ingest[azure]
 unstructured-ingest[confluence]
 unstructured-ingest[dropbox]
 unstructured-ingest[gcs]
-unstructured-ingest[google_drive]
 unstructured-ingest[github]
+unstructured-ingest[google_drive]
 unstructured-ingest[jira]
 unstructured-ingest[s3]
-unstructured-ingest[slack]
 unstructured-ingest[sftp]
+unstructured-ingest[slack]
 html5lib==1.1 #beautifulsoup4 parser
 
 #integrations

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ws_bom_robot_app
-Version: 0.0.23
+Version: 0.0.24
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa
@@ -30,12 +30,12 @@ Requires-Dist: unstructured-ingest[azure]
 Requires-Dist: unstructured-ingest[confluence]
 Requires-Dist: unstructured-ingest[dropbox]
 Requires-Dist: unstructured-ingest[gcs]
-Requires-Dist: unstructured-ingest[google_drive]
 Requires-Dist: unstructured-ingest[github]
+Requires-Dist: unstructured-ingest[google_drive]
 Requires-Dist: unstructured-ingest[jira]
 Requires-Dist: unstructured-ingest[s3]
-Requires-Dist: unstructured-ingest[slack]
 Requires-Dist: unstructured-ingest[sftp]
+Requires-Dist: unstructured-ingest[slack]
 Requires-Dist: html5lib==1.1
 Requires-Dist: markdownify==0.14.1
 Requires-Dist: nebuly==0.3.33

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ ws_bom_robot_app/llm/vector_store/integration/jira.py
 ws_bom_robot_app/llm/vector_store/integration/manager.py
 ws_bom_robot_app/llm/vector_store/integration/s3.py
 ws_bom_robot_app/llm/vector_store/integration/sftp.py
+ws_bom_robot_app/llm/vector_store/integration/sharepoint.py
 ws_bom_robot_app/llm/vector_store/integration/sitemap.py
 ws_bom_robot_app/llm/vector_store/integration/slack.py
 ws_bom_robot_app/llm/vector_store/loader/__init__.py

{ws_bom_robot_app-0.0.23 → ws_bom_robot_app-0.0.24}/ws_bom_robot_app.egg-info/requires.txt

@@ -18,12 +18,12 @@ unstructured-ingest[azure]
 unstructured-ingest[confluence]
 unstructured-ingest[dropbox]
 unstructured-ingest[gcs]
-unstructured-ingest[google_drive]
 unstructured-ingest[github]
+unstructured-ingest[google_drive]
 unstructured-ingest[jira]
 unstructured-ingest[s3]
-unstructured-ingest[slack]
 unstructured-ingest[sftp]
+unstructured-ingest[slack]
 html5lib==1.1
 markdownify==0.14.1
 nebuly==0.3.33