ws-bom-robot-app 0.0.83__tar.gz → 0.0.85__tar.gz

{ws_bom_robot_app-0.0.83/ws_bom_robot_app.egg-info → ws_bom_robot_app-0.0.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ws_bom_robot_app
-Version: 0.0.83
+Version: 0.0.85
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/setup.py

@@ -4,7 +4,7 @@ _requirements = [line.split('#')[0].strip() for line in open("requirements.txt")
 
 setup(
     name="ws_bom_robot_app",
-    version="0.0.83",
+    version="0.0.85",
     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.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/config.py

@@ -23,6 +23,8 @@ class Settings(BaseSettings):
     robot_task_strategy: str = 'memory' # memory / db
     robot_task_mp_enable: bool = True
     robot_task_mp_method: str = 'spawn' # spawn / fork
+    robot_task_mp_max_retries: int = 1
+    robot_task_mp_retry_delay: float = 60 # seconds
     robot_cron_strategy: str = 'memory' # memory / db
     robot_cms_host: str = ''
     robot_cms_auth: str = ''

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/cron_manager.py

@@ -56,9 +56,9 @@ class Job:
 
 class CronManager:
     _list_default = [
-            Job('cleanup-task-history',task_cleanup_history, interval=5 * 60),
-            Job('cleanup-kb-data',kb_cleanup_data_file, interval=180 * 60),
-            Job('cleanup-chat-attachment',chat_cleanup_attachment, interval=120 * 60),
+            Job('cleanup-task-history',task_cleanup_history, interval=4 * 60 * 60),
+            Job('cleanup-kb-data',kb_cleanup_data_file, interval=8 * 60 * 60),
+            Job('cleanup-chat-attachment',chat_cleanup_attachment, interval=6 * 60 * 60),
         ]
     def __get_jobstore_strategy(self) -> JobstoreStrategy:
         if config.robot_cron_strategy == 'memory':

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/llm/utils/chunker.py

@@ -1,12 +1,17 @@
 from langchain_core.documents import Document
 from langchain_text_splitters import CharacterTextSplitter
+import logging
 
 class DocumentChunker:
+  _MAX_CHUNK_SIZE = 10_000
   @staticmethod
   def chunk(documents: list[Document]) -> list[Document]:
-      text_splitter = CharacterTextSplitter(chunk_size=10_000, chunk_overlap=500)
+      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(

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/llm/utils/cleanup.py

@@ -1,7 +1,6 @@
 import os, logging
 from ws_bom_robot_app.config import config
 from datetime import datetime, timedelta
-from ws_bom_robot_app.task_manager import task_manager
 
 def _cleanup_data_file(folders: list[str], retention: float) -> dict:
     """
@@ -78,4 +77,5 @@ def task_cleanup_history() -> None:
     """
     clean up task queue
     """
+    from ws_bom_robot_app.task_manager import task_manager
     task_manager.cleanup_task()

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/llm/vector_store/db/base.py

@@ -50,8 +50,8 @@ class VectorDBStrategy(ABC):
           Asynchronously invokes multiple retrievers in parallel, then merges
           their results while removing duplicates.
       """
+    MAX_TOKENS_PER_BATCH = 300_000 * 0.8
     def __init__(self):
-        self.max_tokens_per_batch = 300_000 * 0.8  # conservative limit below 300k openai limit: https://platform.openai.com/docs/api-reference/embeddings/create
         try:
             self.encoding = tiktoken.get_encoding("cl100k_base")  # text-embedding-3-small, text-embedding-3-large: https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken
         except Exception:
@@ -78,7 +78,7 @@ class VectorDBStrategy(ABC):
       for doc in documents:
           doc_tokens = self._count_tokens(doc.page_content)
           # check if adding this document exceeds the limit
-          if current_token_count + doc_tokens > self.max_tokens_per_batch:
+          if current_token_count + doc_tokens > VectorDBStrategy.MAX_TOKENS_PER_BATCH:
               # start new batch if current batch is not empty
               if current_batch:
                   batches.append(current_batch)

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/llm/vector_store/loader/base.py

@@ -113,6 +113,38 @@ class Loader():
 
   #@timer
   async def load(self) -> list[Document]:
+    #region log
+    import warnings
+    warnings.filterwarnings("ignore", message=".*pin_memory.*no accelerator is found.*")
+    log_msg_to_ignore = [
+        "Going to convert document batch...",
+        "Initializing pipeline for",
+        "Accelerator device:",
+        "detected formats:",
+    ]
+    class MessageFilter(logging.Filter):
+        def __init__(self, patterns):
+            super().__init__()
+            self.log_msg_to_ignore = patterns
+
+        def filter(self, record):
+            for pattern in self.log_msg_to_ignore:
+                if pattern in record.getMessage():
+                    return False
+            return True
+    message_filter = MessageFilter(log_msg_to_ignore)
+    loggers_to_filter = [
+        'docling',
+        'docling.document_converter',
+        'docling.datamodel',
+        'docling.datamodel.document',
+        'docling.utils.accelerator_utils',
+        'unstructured'
+    ]
+    for logger_name in loggers_to_filter:
+        logging.getLogger(logger_name).addFilter(message_filter)
+    #endregion log
+
     MAX_RETRIES = 3
     loaders: MergedDataLoader = MergedDataLoader(self.__directory_loader())
     try:
@@ -132,5 +164,8 @@ class Loader():
         finally:
            del _documents
     finally:
+      # Remove logging filters
+      for logger_name in loggers_to_filter:
+          logging.getLogger(logger_name).removeFilter(message_filter)
       del loaders
       gc.collect()

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/llm/vector_store/loader/docling.py

@@ -6,6 +6,7 @@ from langchain_core.runnables import run_in_executor
 from docling.document_converter import DocumentConverter, InputFormat, PdfFormatOption, ImageFormatOption
 from docling.datamodel.pipeline_options import PdfPipelineOptions, TableStructureOptions, TableFormerMode, TesseractCliOcrOptions
 from langchain_community.document_loaders import UnstructuredFileLoader
+from ws_bom_robot_app.llm.vector_store.db.base import VectorDBStrategy
 
 class DoclingLoader(BaseLoader):
   def __init__(self, file_path: str | list[str], **kwargs: Any) -> None:
@@ -37,28 +38,37 @@ class DoclingLoader(BaseLoader):
           if doc is done:
               break
           yield doc  # type: ignore[misc]
+  def _fallback_loader(self, source: str, error: Exception = None) -> Iterator[Document]:
+      if 'fallback' in self._kwargs:
+          if issubclass(self._kwargs['fallback'], (BaseLoader, UnstructuredFileLoader)):
+            logging.info(f"Using fallback loader {self._kwargs['fallback']} for {source}")
+            try:
+              loader: Union[BaseLoader, UnstructuredFileLoader] = self._kwargs['fallback'](
+                  source,
+                  **{k: v for k, v in self._kwargs.items() if k != 'fallback'}
+                  )
+              yield from loader.lazy_load()
+            except Exception as e:
+              logging.warning(f"Failed to load document from {source}: {e} | {traceback.format_exc()}")
+          else:
+              logging.warning(f"Invalid fallback loader {self._kwargs['fallback']}[{type(self._kwargs['fallback'])}] for {source}")
+      else:
+        logging.warning(f"Failed to load document from {source}: {error}")
   def lazy_load(self) -> Iterator[Document]:
       for source in self._file_paths:
           try:
-            _result = self._converter.convert(
-               os.path.abspath(source),
-               raises_on_error=True)
-            doc = _result.document
-            text = doc.export_to_markdown(image_placeholder="")
-            yield Document(page_content=text, metadata={"source": source})
-          except Exception as e:
-            if 'fallback' in self._kwargs:
-                if issubclass(self._kwargs['fallback'], (BaseLoader, UnstructuredFileLoader)):
-                  logging.info(f"Using fallback loader {self._kwargs['fallback']} for {source}")
-                  try:
-                    loader: Union[BaseLoader, UnstructuredFileLoader] = self._kwargs['fallback'](
-                       source,
-                       **{k: v for k, v in self._kwargs.items() if k != 'fallback'}
-                       )
-                    yield from loader.lazy_load()
-                  except Exception as e:
-                    logging.warning(f"Failed to load document from {source}: {e} | {traceback.format_exc()}")
-                else:
-                   logging.warning(f"Invalid fallback loader {self._kwargs['fallback']}[{type(self._kwargs['fallback'])}] for {source}")
+            #manage only small file with header, preventing header stripping and improper chunking
+            if (source.endswith('.csv') or source.endswith('.xlsx')) \
+                and 'fallback' in self._kwargs \
+                and os.path.getsize(source) > (VectorDBStrategy.MAX_TOKENS_PER_BATCH // 4): #rough token estimate
+              yield from self._fallback_loader(source)
             else:
-              logging.warning(f"Failed to load document from {source}: {e} | {traceback.format_exc()}")
+              _result = self._converter.convert(
+                os.path.abspath(source),
+                raises_on_error=True)
+              doc = _result.document
+              text = doc.export_to_markdown(image_placeholder="")
+              yield Document(page_content=text, metadata={"source": source})
+          except Exception as e:
+             yield from self._fallback_loader(source,e)
+

ws_bom_robot_app-0.0.85/ws_bom_robot_app/main.py

@@ -0,0 +1,156 @@
+import datetime
+from fastapi import FastAPI
+from ws_bom_robot_app.util import is_app_subprocess
+_uptime = datetime.datetime.now()
+app = FastAPI(redoc_url=None,docs_url=None,openapi_url=None)
+
+if not is_app_subprocess():
+  import platform
+  from fastapi.responses import FileResponse
+  import os, sys
+  from fastapi import Depends
+  from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
+  from fastapi.openapi.utils import get_openapi
+  from ws_bom_robot_app.auth import authenticate
+  from ws_bom_robot_app.config import config
+  from ws_bom_robot_app.util import _log
+  from ws_bom_robot_app.llm.api import router as llm
+  from ws_bom_robot_app.task_manager import router as task
+  from ws_bom_robot_app.cron_manager import (
+      router as cron,
+      cron_manager)
+  cron_manager.start()
+  app.include_router(llm,dependencies=[Depends(authenticate)])
+  app.include_router(task,dependencies=[Depends(authenticate)])
+  app.include_router(cron,dependencies=[Depends(authenticate)])
+
+  @app.get("/")
+  async def root():
+      return health()
+  @app.get("/favicon.ico")
+  async def favicon():
+      return FileResponse("./favicon.ico")
+
+  @app.get("/docs", include_in_schema=False)
+  async def get_swagger_documentation(authenticate: bool = Depends(authenticate)):
+      return get_swagger_ui_html(openapi_url="/openapi.json", title="docs")
+  @app.get("/redoc", include_in_schema=False)
+  async def get_redoc_documentation(authenticate: bool = Depends(authenticate)):
+      return get_redoc_html(openapi_url="/openapi.json", title="docs")
+  @app.get("/openapi.json", include_in_schema=False)
+  async def openapi(authenticate: bool = Depends(authenticate)):
+      return get_openapi(title=app.title, version=app.version, routes=app.routes)
+
+  @app.get("/api/health",tags=["diag"])
+  def health():
+      return {"status": "ok"}
+  def __get_size(bytes, suffix="B"):
+      """
+      Scale bytes to its proper format
+      e.g:
+          1253656 => '1.20MB'
+          1253656678 => '1.17GB'
+      """
+      factor = 1024
+      for unit in ["", "K", "M", "G", "T", "P"]:
+          if bytes < factor:
+              return f"{bytes:.2f}{unit}{suffix}"
+          bytes /= factor
+  def __get_disk_info():
+      import psutil
+      partitions = psutil.disk_partitions()
+      _disks:list = []
+      for partition in partitions:
+          device = partition.device
+          mountpoint = partition.mountpoint
+          fstype = partition.fstype
+          try:
+              usage = psutil.disk_usage(mountpoint)
+          except PermissionError:
+              continue
+          total = __get_size(usage.total)
+          used = __get_size(usage.used)
+          free = __get_size(usage.free)
+          percent = f"{usage.percent}%"
+          _disks.append({"device": device, "mountpoint": mountpoint, "fstype": fstype, "total": total, "used": used, "free": free, "percent": percent})
+      return _disks
+  @app.get("/api/diag",tags=["diag"])
+  def diag(authenticate: bool = Depends(authenticate)):
+      import importlib,psutil
+      from ws_bom_robot_app.llm.providers.llm_manager import LlmManager as wsllm
+      from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager as wsdb
+      from ws_bom_robot_app.llm.vector_store.loader.base import Loader as wsldr
+      from ws_bom_robot_app.llm.vector_store.integration.manager import IntegrationManager as wsim
+      from ws_bom_robot_app.llm.tools.tool_manager import ToolManager as wstm
+      from ws_bom_robot_app.llm.agent_description import AgentDescriptor as wsad
+
+      svmem = psutil.virtual_memory()
+      swap = psutil.swap_memory()
+      try:
+        ws_bom_robot_app_version = importlib.metadata.version("ws_bom_robot_app")
+      except:
+        ws_bom_robot_app_version = "unknown"
+      peer_process_ids = [c.pid for c in psutil.Process(os.getppid()).children()] if config.runtime_options().is_multi_process else None
+      return {
+          "status":"ok",
+          "uptime": {'from':_uptime,'elapsed':str(datetime.datetime.now()-_uptime)},
+          "system": {
+              "platform": {
+                  "node": platform.node(),
+                  "system": platform.system(),
+                  "platform": platform.platform(),
+                  "version": platform.version(),
+                  "type": platform.machine(),
+                  "processor": platform.processor(),
+                  "architecture": platform.architecture()
+              },
+              "cpu": {
+                  "physical_core": psutil.cpu_count(logical=False),
+                  "total_core": psutil.cpu_count(logical=True),
+                  "load": f"{psutil.cpu_percent(interval=1)}%"
+              },
+              "memory": {
+                  "total": f"{__get_size(svmem.total)}",
+                  "available": f"{__get_size(svmem.available)}",
+                  "used": f"{__get_size(svmem.used)}",
+                  "free": f"{__get_size(svmem.free)}",
+                  "percent": f"{svmem.percent}%"
+              },
+              "swap": {
+                  "total": f"{__get_size(swap.total)}",
+                  "used": f"{__get_size(swap.used)}",
+                  "free": f"{__get_size(swap.free)}",
+                  "percent": f"{swap.percent}%"
+              },
+              "disk": __get_disk_info(),
+              "sys": {
+                  "version": sys.version,
+                  "platform": sys.platform,
+                  "executable": sys.executable,
+                  "args": {k: arg for k, arg in enumerate(sys.argv)}
+              },
+              "os": {
+                  "ppid": os.getppid(),
+                  "pid": os.getpid(),
+                  "pids": peer_process_ids,
+                  "cwd": os.getcwd(),
+                  "ws_bom_robot_app": ws_bom_robot_app_version,
+                  "env": os.environ,
+              },
+          },
+          "config":config,
+          "runtime":config.runtime_options(),
+          "extension": {
+              "provider":({item[0]: type(item[1]).__name__} for item in wsllm._list.items()),
+              "db":({item[0]: type(item[1]).__name__} for item in wsdb._list.items()),
+              "loader": ({item[0]: item[1].loader.__name__ if item[1] else None} for item in sorted(wsldr._list.items(), key=lambda x: x[0]) if item[1]),
+              "integration":({item[0]: type(item[1]).__name__} for item in wsim._list.items()),
+              "tool": ({item[0]: item[1].function.__name__} for item in wstm._list.items()),
+              "agent":({item[0]: type(item[1]).__name__} for item in wsad._list.items())
+              }
+          }
+  @app.post("/diag/reload",tags=["diag"])
+  def reset(authenticate: bool = Depends(authenticate)):
+      _log.info("restart server")
+      with open(".reloadfile","w") as f:
+          f.write("")

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/subprocess_runner.py

@@ -12,6 +12,9 @@ def _worker_run_pickled(serialized_task: bytes, conn: Connection):
     capture return value or exception and send back via conn.send((ok_flag, payload_serialized)).
     This runs in a separate process and must be top-level for multiprocessing.
     """
+    import os
+    # mark as a subprocess
+    os.environ['IS_ROBOT_APP_SUBPROCESS'] = 'true'
     try:
         if _pickler is None:
             raise RuntimeError("No pickler available in worker process.")

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/task_manager.py

@@ -69,6 +69,7 @@ class TaskStatus(IdentifiableEntity):
     result: Optional[T] = None
     metadata: TaskMetaData = None
     error: Optional[str] = None
+    retry: int = 0
     model_config = ConfigDict(
         arbitrary_types_allowed=True
     )
@@ -118,7 +119,8 @@ class TaskEntry(IdentifiableEntity):
 class TaskStatistics(BaseModel):
     class TaskStatisticExecutionInfo(BaseModel):
         retention_days: float = config.robot_task_retention_days
-        max_concurrent: int
+        max_parallelism: int
+        slot_available: int
         pid: int = os.getpid()
         running: list[TaskStatus]
         slowest: list
@@ -137,9 +139,12 @@ class TaskStatistics(BaseModel):
 
 #region interface
 class TaskManagerStrategy(ABC):
-    def __init__(self, max_concurrent_tasks: int = max(1,floor(config.robot_task_max_total_parallelism / config.runtime_options().number_of_workers))):
-        self.max_concurrent_tasks = max_concurrent_tasks
-        self.semaphore = asyncio.Semaphore(self.max_concurrent_tasks)
+    def __init__(self, max_concurrent_tasks: Optional[int] = None):
+        if max_concurrent_tasks is None:
+            workers = config.runtime_options().number_of_workers
+            max_concurrent_tasks = max(1, floor(config.robot_task_max_total_parallelism / max(1, workers)))
+        self.max_parallelism = max_concurrent_tasks
+        self.semaphore = asyncio.Semaphore(max_concurrent_tasks)
         self.running_tasks = dict[str, TaskEntry]()
         self.loop = asyncio.get_event_loop()
 
@@ -201,14 +206,15 @@ class TaskManagerStrategy(ABC):
           #remove from running tasks
           if task_entry.id in self.running_tasks:
               del self.running_tasks[task_entry.id]
-          #notify webhooks
-          if task_entry.headers and task_entry.headers.x_ws_bom_webhooks:
-            try:
-                asyncio.create_task(
-                    WebhookNotifier().notify_webhook(task_entry.status, task_entry.headers.x_ws_bom_webhooks)
-                )
-            except Exception as e:
-                _log.error(f"Failed to schedule webhook notification for task {task_entry.id}: {e}")
+          #notify webhooks: a task has completed or failed, if failed with retry policy the task remains in pending state, and will not be notified until complete/failure
+          if task_entry.status.status in ["completed","failure"]:
+            if task_entry.headers and task_entry.headers.x_ws_bom_webhooks:
+              try:
+                  asyncio.create_task(
+                      WebhookNotifier().notify_webhook(task_entry.status, task_entry.headers.x_ws_bom_webhooks)
+                  )
+              except Exception as e:
+                  _log.error(f"Failed to schedule webhook notification for task {task_entry.id}: {e}")
 
     def task_done_callback(self, task_entry: TaskEntry) -> Callable:
         def callback(task: asyncio.Task, context: Any | None = None):
@@ -260,6 +266,55 @@ class TaskManagerStrategy(ABC):
         async with self.semaphore:
           await self._execute_task(task_entry)
 
+    async def _monitor_subprocess(self, task_entry: TaskEntry, proc, conn):
+        try:
+            # Wait for the worker to send bytes (this blocks, so run via executor wrapper)
+            data_bytes = await _recv_from_connection_async(conn)
+            # unpickle bytes to get payload
+            try:
+                payload = _pickler.loads(data_bytes)
+            except Exception:
+                # fallback if pickler fails
+                payload = ("err", {"error": "Failed to unpickle subprocess result"})
+            if isinstance(payload, tuple) and payload[0] == "ok":
+                result = payload[1]
+                # write results into task_entry
+                self._update_task_by_event(task_entry, "completed", result)
+            else:
+                # error
+                err_info = payload[1]["error"] if isinstance(payload, tuple) else str(payload)
+                self._update_task_by_event(task_entry, "failure", err_info) # give up, no retry
+        except Exception:
+            # maybe subprocess is no more alive / killed due to memory pressure
+            if task_entry.status.retry < config.robot_task_mp_max_retries:
+                task_entry.status.retry += 1
+                _log.warning(f"Task {task_entry.id} failure, retrying {task_entry.status.retry}...")
+                async def delayed_retry():
+                    _delay = config.robot_task_mp_retry_delay # help to backpressure when overloaded
+                    if self.semaphore._value > 0:  # free semaphore slots available
+                        _delay = 5  # small/no delay if retry can run immediately
+                    await asyncio.sleep(_delay)  # delay in seconds
+                    await self._run_task_with_semaphore(task_entry)
+                asyncio.create_task(delayed_retry())
+                # semaphore is released, so new task can be executed
+                return
+            else:
+                self._update_task_by_event(task_entry, "failure", "subprocess monitor error: failed to receive data from connection")
+        finally:
+            # ensure process termination / cleanup
+            try:
+                conn.close()
+            except Exception:
+                pass
+            try:
+              if proc.is_alive():
+                  proc.terminate()
+              proc.join(timeout=1)
+            except Exception:
+                pass
+            # callback
+            self._update_task_by_event(task_entry, "callback", None)
+
     async def _execute_task(self, task_entry: TaskEntry):
         """
         Execute the task. Try to run it inside a subprocess (if serializable).
@@ -269,56 +324,19 @@ class TaskManagerStrategy(ABC):
         """
         self.running_tasks[task_entry.id]=task_entry
         task_entry.status.metadata.start_at = str(datetime.now().isoformat())
-        # Try to spawn subprocess (non-blocking)
+        # try to spawn subprocess (non-blocking)
         can_use_subprocess = task_entry.status.metadata.extra.get("can_use_subprocess", False)
         if config.robot_task_mp_enable and can_use_subprocess:
             proc, conn, used_subprocess = _start_subprocess_for_coroutine(task_entry.coroutine)
             if used_subprocess and proc is not None and conn is not None:
-                # We will monitor the subprocess asynchronously
+                # monitor subprocess asynchronously
                 task_entry.status.status = "pending"
                 task_entry.status.metadata.pid_child = proc.pid
                 _log.info(f"Task {task_entry.id} started in subprocess (pid={proc.pid})")
-
-            async def _monitor_subprocess():
-                try:
-                    # Wait for the worker to send bytes (this blocks, so run via executor wrapper)
-                    data_bytes = await _recv_from_connection_async(conn)
-                    # unpickle bytes to get payload
-                    try:
-                        payload = _pickler.loads(data_bytes)
-                    except Exception:
-                        # fallback if pickler fails
-                        payload = ("err", {"error": "Failed to unpickle subprocess result"})
-                    if isinstance(payload, tuple) and payload[0] == "ok":
-                        result = payload[1]
-                        # write results into task_entry
-                        self._update_task_by_event(task_entry, "completed", result)
-                    else:
-                        # error
-                        err_info = payload[1]["error"] if isinstance(payload, tuple) else str(payload)
-                        self._update_task_by_event(task_entry, "failure", err_info)
-                except Exception:
-                    # maybe subprocess is no more alive / killed
-                    self._update_task_by_event(task_entry, "failure", "subprocess monitor error: failed to receive data from connection")
-                finally:
-                    # Ensure process termination / cleanup
-                    try:
-                        conn.close()
-                    except Exception:
-                        pass
-                    try:
-                      if proc.is_alive():
-                          proc.terminate()
-                      proc.join(timeout=1)
-                    except Exception:
-                        pass
-                    # callback
-                    self._update_task_by_event(task_entry, "callback", None)
-
-            # schedule monitor task and return
-            asyncio.create_task(_monitor_subprocess())
-            return
-        # fallback
+                # await monitor process, then return: important to acquire semaphore
+                await self._monitor_subprocess(task_entry, proc, conn)
+                return
+        # default fallback (in-process)
         try:
             async def _callable_to_coroutine(func: Any) -> Any:
                 if callable(func) and not inspect.iscoroutine(func):
@@ -373,7 +391,8 @@ class TaskManagerStrategy(ABC):
             ),
             exec_info=TaskStatistics.TaskStatisticExecutionInfo(
                 retention_days=config.robot_task_retention_days,
-                max_concurrent=self.max_concurrent_tasks,
+                max_parallelism=self.max_parallelism,
+                slot_available=self.semaphore._value,
                 running=[task.status for task in self.running_task()],
                 slowest=_slowest
             )
@@ -383,8 +402,8 @@ class TaskManagerStrategy(ABC):
 
 #region memory implementation
 class MemoryTaskManagerStrategy(TaskManagerStrategy):
-    def __init__(self):
-        super().__init__()
+    def __init__(self, max_concurrent_tasks: Optional[int] = None):
+        super().__init__(max_concurrent_tasks)
         self.tasks: Dict[str, TaskEntry] = {}
 
     def create_task(self, coroutine: Any, headers: TaskHeader | None = None) -> IdentifiableEntity:
@@ -425,8 +444,8 @@ class TaskEntryModel(Base):
         arbitrary_types_allowed=True
     )
 class DatabaseTaskManagerStrategy(TaskManagerStrategy):
-    def __init__(self, db_url: str = f"sqlite:///{config.robot_data_folder}/db/tasks.sqlite"):
-        super().__init__()
+    def __init__(self, db_url: str = f"sqlite:///{config.robot_data_folder}/db/tasks.sqlite", max_concurrent_tasks: Optional[int] = None):
+        super().__init__(max_concurrent_tasks)
         self.engine = create_engine(db_url)
         self.Session = sessionmaker(bind=self.engine)
         Base.metadata.create_all(self.engine)

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85}/ws_bom_robot_app/util.py

@@ -22,6 +22,12 @@ def logger_instance(name: str) -> logging.Logger:
 _log: logging.Logger = locals().get("_loc", logger_instance(__name__))
 #endregion
 
+#region task
+def is_app_subprocess():
+    """Check if we're running a task in a subprocess."""
+    return os.environ.get('IS_ROBOT_APP_SUBPROCESS', '').lower() == 'true'
+#endregion
+
 #region cache
 _cache = {}
 _cache_timestamps = {}

{ws_bom_robot_app-0.0.83 → ws_bom_robot_app-0.0.85/ws_bom_robot_app.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ws_bom_robot_app
-Version: 0.0.83
+Version: 0.0.85
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa

ws_bom_robot_app-0.0.83/ws_bom_robot_app/main.py

@@ -1,157 +0,0 @@
-import datetime
-import platform
-from fastapi.responses import FileResponse
-import uvicorn, os, sys
-from fastapi import FastAPI, Depends
-from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
-from fastapi.openapi.utils import get_openapi
-from ws_bom_robot_app.auth import authenticate
-from ws_bom_robot_app.config import config
-from ws_bom_robot_app.llm.api import router as llm
-from ws_bom_robot_app.task_manager import router as task
-from ws_bom_robot_app.cron_manager import (
-    router as cron,
-    cron_manager)
-from ws_bom_robot_app.util import _log
-
-_uptime = datetime.datetime.now()
-cron_manager.start()
-app = FastAPI(redoc_url=None,docs_url=None,openapi_url=None)
-app.include_router(llm,dependencies=[Depends(authenticate)])
-app.include_router(task,dependencies=[Depends(authenticate)])
-app.include_router(cron,dependencies=[Depends(authenticate)])
-
-@app.get("/")
-async def root():
-    return health()
-@app.get("/favicon.ico")
-async def favicon():
-    return FileResponse("./favicon.ico")
-
-@app.get("/docs", include_in_schema=False)
-async def get_swagger_documentation(authenticate: bool = Depends(authenticate)):
-    return get_swagger_ui_html(openapi_url="/openapi.json", title="docs")
-@app.get("/redoc", include_in_schema=False)
-async def get_redoc_documentation(authenticate: bool = Depends(authenticate)):
-    return get_redoc_html(openapi_url="/openapi.json", title="docs")
-@app.get("/openapi.json", include_in_schema=False)
-async def openapi(authenticate: bool = Depends(authenticate)):
-    return get_openapi(title=app.title, version=app.version, routes=app.routes)
-
-@app.get("/api/health",tags=["diag"])
-def health():
-    return {"status": "ok"}
-def __get_size(bytes, suffix="B"):
-    """
-    Scale bytes to its proper format
-    e.g:
-        1253656 => '1.20MB'
-        1253656678 => '1.17GB'
-    """
-    factor = 1024
-    for unit in ["", "K", "M", "G", "T", "P"]:
-        if bytes < factor:
-            return f"{bytes:.2f}{unit}{suffix}"
-        bytes /= factor
-def __get_disk_info():
-    import psutil
-    partitions = psutil.disk_partitions()
-    _disks:list = []
-    for partition in partitions:
-        device = partition.device
-        mountpoint = partition.mountpoint
-        fstype = partition.fstype
-        try:
-            usage = psutil.disk_usage(mountpoint)
-        except PermissionError:
-            continue
-        total = __get_size(usage.total)
-        used = __get_size(usage.used)
-        free = __get_size(usage.free)
-        percent = f"{usage.percent}%"
-        _disks.append({"device": device, "mountpoint": mountpoint, "fstype": fstype, "total": total, "used": used, "free": free, "percent": percent})
-    return _disks
-@app.get("/api/diag",tags=["diag"])
-def diag(authenticate: bool = Depends(authenticate)):
-    import importlib,psutil
-    from ws_bom_robot_app.llm.providers.llm_manager import LlmManager as wsllm
-    from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager as wsdb
-    from ws_bom_robot_app.llm.vector_store.loader.base import Loader as wsldr
-    from ws_bom_robot_app.llm.vector_store.integration.manager import IntegrationManager as wsim
-    from ws_bom_robot_app.llm.tools.tool_manager import ToolManager as wstm
-    from ws_bom_robot_app.llm.agent_description import AgentDescriptor as wsad
-
-    svmem = psutil.virtual_memory()
-    swap = psutil.swap_memory()
-    try:
-      ws_bom_robot_app_version = importlib.metadata.version("ws_bom_robot_app")
-    except:
-      ws_bom_robot_app_version = "unknown"
-    peer_process_ids = [c.pid for c in psutil.Process(os.getppid()).children()] if config.runtime_options().is_multi_process else None
-    return {
-        "status":"ok",
-        "uptime": {'from':_uptime,'elapsed':str(datetime.datetime.now()-_uptime)},
-        "system": {
-            "platform": {
-                "node": platform.node(),
-                "system": platform.system(),
-                "platform": platform.platform(),
-                "version": platform.version(),
-                "type": platform.machine(),
-                "processor": platform.processor(),
-                "architecture": platform.architecture()
-            },
-            "cpu": {
-                "physical_core": psutil.cpu_count(logical=False),
-                "total_core": psutil.cpu_count(logical=True),
-                "load": f"{psutil.cpu_percent(interval=1)}%"
-            },
-            "memory": {
-                "total": f"{__get_size(svmem.total)}",
-                "available": f"{__get_size(svmem.available)}",
-                "used": f"{__get_size(svmem.used)}",
-                "free": f"{__get_size(svmem.free)}",
-                "percent": f"{svmem.percent}%"
-            },
-            "swap": {
-                "total": f"{__get_size(swap.total)}",
-                "used": f"{__get_size(swap.used)}",
-                "free": f"{__get_size(swap.free)}",
-                "percent": f"{swap.percent}%"
-            },
-            "disk": __get_disk_info(),
-            "sys": {
-                "version": sys.version,
-                "platform": sys.platform,
-                "executable": sys.executable,
-                "args": {k: arg for k, arg in enumerate(sys.argv)}
-            },
-            "os": {
-                "ppid": os.getppid(),
-                "pid": os.getpid(),
-                "pids": peer_process_ids,
-                "cwd": os.getcwd(),
-                "ws_bom_robot_app": ws_bom_robot_app_version,
-                "env": os.environ,
-            },
-        },
-        "config":config,
-        "runtime":config.runtime_options(),
-        "extension": {
-            "provider":({item[0]: type(item[1]).__name__} for item in wsllm._list.items()),
-            "db":({item[0]: type(item[1]).__name__} for item in wsdb._list.items()),
-            "loader": ({item[0]: item[1].loader.__name__ if item[1] else None} for item in sorted(wsldr._list.items(), key=lambda x: x[0]) if item[1]),
-            "integration":({item[0]: type(item[1]).__name__} for item in wsim._list.items()),
-            "tool": ({item[0]: item[1].function.__name__} for item in wstm._list.items()),
-            "agent":({item[0]: type(item[1]).__name__} for item in wsad._list.items())
-            }
-        }
-@app.post("/diag/reload",tags=["diag"])
-def reset(authenticate: bool = Depends(authenticate)):
-    _log.info("restart server")
-    with open(".reloadfile","w") as f:
-        f.write("")
-
-# Start the FastAPI server
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=6001, env_file="../.env", reload=True, log_level="debug")