ws-bom-robot-app 0.0.63__py3-none-any.whl → 0.0.103__py3-none-any.whl

ws_bom_robot_app/main.py

@@ -1,154 +1,156 @@
 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
-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
-
+from fastapi import FastAPI
+from ws_bom_robot_app.util import is_app_subprocess
 _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")
+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("/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("/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("/")
+  async def root():
+      return health()
+  @app.get("/favicon.ico")
+  async def favicon():
+      return FileResponse("./favicon.ico")
 
-@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 pkg_resources, 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
+  @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)
 
-    svmem = psutil.virtual_memory()
-    swap = psutil.swap_memory()
-    try:
-      ws_bom_robot_app_version = pkg_resources.get_distribution("ws_bom_robot_app").version
-    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("")
+  @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
 
-# 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")
+      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/subprocess_runner.py

@@ -0,0 +1,106 @@
+import logging
+import multiprocessing as mp
+from multiprocessing.connection import Connection
+import dill as _pickler
+import types, traceback
+import asyncio, sys
+from ws_bom_robot_app.config import config
+
+def _worker_run_pickled(serialized_task: bytes, conn: Connection):
+    """
+    Unpickle the object (should be an awaitable or callable), run it inside its own asyncio loop,
+    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.")
+
+        obj = _pickler.loads(serialized_task)
+
+        # If obj is a coroutine object, run directly; if it's a callable, call it and maybe await result.
+        async def _wrap_and_run(o):
+            if asyncio.iscoroutine(o):
+                return await o
+            elif isinstance(o, types.FunctionType) or callable(o):
+                # call it; if returns coroutine, await it
+                result = o()
+                if asyncio.iscoroutine(result):
+                    return await result
+                return result
+            else:
+                # not callable / awaitable
+                return o
+
+        # Run inside asyncio.run (fresh loop)
+        result = asyncio.run(_wrap_and_run(obj))
+        # try to pickle result for sending, if fails, str() it
+        try:
+            payload = _pickler.dumps(("ok", result))
+        except Exception:
+            payload = _pickler.dumps(("ok", str(result)))
+        conn.send_bytes(payload)
+    except Exception as e:
+        # send back the error details
+        try:
+            tb = traceback.format_exc()
+            payload = _pickler.dumps(("err", {"error": str(e), "traceback": tb}))
+            conn.send_bytes(payload)
+        except Exception:
+            # last resort: send plain text
+            try:
+                conn.send_bytes(b'ERR:' + str(e).encode("utf-8"))
+            except Exception:
+                pass
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+async def _recv_from_connection_async(conn: Connection):
+    """
+    Blocking recv wrapped for asyncio using a threadpool.
+    We expect worker to use conn.send_bytes(payload) — we use conn.recv_bytes() to get bytes.
+    """
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, conn.recv_bytes)  # blocking call inside executor
+def _start_subprocess_for_coroutine(coroutine_obj):
+    """
+    Try to start a subprocess that will run the provided coroutine/callable.
+    Returns tuple (process, parent_conn, used_subprocess_flag)
+    If cannot serialize, returns (None, None, False)
+    """
+    def _get_mp_start_method():
+        """Get the multiprocessing start method.
+
+        For Windows + Jupyter compatibility, 'spawn' is required
+        'spawn' guarantees that every worker starts fresh and doesn't carry Python heap or native allocations from the parent.
+        'fork' to get faster startup and lower initial memory cost, carries over everything in parent memory, including global variables and open resources: can be unsafe with threads, async loops
+
+        Returns:
+            str: The multiprocessing start method.
+        """
+        if sys.platform == "win32":
+            return "spawn"
+        return config.robot_task_mp_method
+
+    try:
+        serialized = _pickler.dumps(coroutine_obj)
+    except Exception:
+        # cannot serialize the coroutine/callable -> fall back to in-process
+        return (None, None, False)
+
+    parent_conn, child_conn = mp.Pipe(duplex=False)
+
+    ctx = mp.get_context(_get_mp_start_method())
+    p = ctx.Process(target=_worker_run_pickled, args=(serialized, child_conn), daemon=False)
+    p.start()
+    # close child conn in parent process
+    try:
+        child_conn.close()
+    except Exception:
+        pass
+    return (p, parent_conn, True)