ws-bom-robot-app 0.0.11__tar.gz → 0.0.12__tar.gz

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ws_bom_robot_app
-Version: 0.0.11
+Version: 0.0.12
 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.11 → ws_bom_robot_app-0.0.12}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="ws_bom_robot_app",
-    version="0.0.11",
+    version="0.0.12",
     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.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/config.py

@@ -1,7 +1,7 @@
 from typing import Optional
 from pydantic import BaseModel, ConfigDict
 from pydantic_settings import BaseSettings
-
+import os
 
 class Settings(BaseSettings):
     robot_env: str = 'local'
@@ -13,6 +13,7 @@ class Settings(BaseSettings):
     robot_data_db_folder_out: str = 'out'
     robot_data_db_folder_store: str = 'store'
     robot_data_db_retention_days: float = 60
+    robot_task_max_concurrent: int = os.cpu_count() or 1
     robot_task_retention_days: float = 1
     robot_cms_host: str = ''
     robot_cms_auth: str = ''
@@ -26,38 +27,37 @@ class Settings(BaseSettings):
     )
 
     class RuntimeOptions(BaseModel):
-        def _is_multi_process() -> bool:
+        @staticmethod
+        def _get_number_of_workers() -> int:
             """
-            Checks if the application is running with multiple worker processes.
+            Returns the number of worker processes to use for the application.
 
-            This function inspects the command-line arguments to determine if the
-            application is configured to run with more than one worker process. It
-            looks for the "--workers" argument and checks if the subsequent value
-            is greater than 1.
+            This function inspects the command-line arguments to determine the number
+            of worker processes to use. It looks for the "--workers" argument and
+            returns the subsequent value as an integer.
             Sample of command-line arguments:
+            fastapi dev main.py --port 6001
             fastapi run main.py --port 6001 --workers 4
             uvicorn main:app --port 6001 --workers 4
 
             Returns:
-                bool: True if the application is running with multiple worker
-                      processes, False otherwise.
+                Optional[int]: The number of worker processes to use, or 1 if
+                               the argument is not found or the value is invalid.
             """
-            import sys, os
+            import sys
             try:
                 for i, arg in enumerate(sys.argv):
                     if arg == "--workers" and i + 1 < len(sys.argv):
-                        workers = int(sys.argv[i + 1])
-                        if workers > 1:
-                            return True
+                        return int(sys.argv[i + 1])
             except (ValueError, IndexError):
                 pass
-            # Fallback: Compare process and parent process IDs
-            return False #os.getpid() != os.getppid()
+            return 1
         debug: bool
         loader_strategy: str
         loader_show_progress: bool
         loader_silent_errors: bool
-        is_multi_process: bool = _is_multi_process()
+        number_of_workers: int = _get_number_of_workers()
+        is_multi_process: bool = _get_number_of_workers() > 1
 
 
     def runtime_options(self) -> RuntimeOptions:

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/cron_manager.py

@@ -60,7 +60,7 @@ class CronManager:
             Job('cleanup-data',kb_cleanup_data_file, interval=180 * 60),
         ]
     def __get_jobstore_strategy() -> JobstoreStrategy:
-        if config.runtime_options().is_multi_process:
+        if True or config.runtime_options().is_multi_process:
             return MemoryJobstoreStrategy()
         return PersistentJobstoreStrategy()
     def __init__(self, strategy: JobstoreStrategy = None, enable_defaults: bool = True):
@@ -101,7 +101,7 @@ class CronManager:
               trigger=trigger,
               id=job.name,
               name=job.name,
-              replace_existing=False
+              replace_existing=True
           )
 
     def start(self):
@@ -114,6 +114,7 @@ class CronManager:
                     if existing_job is None:
                         self.add_job(job)
 
+
     def get_job(self, job_id: str):
         return self.scheduler.get_job(job_id)
 

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/llm/models/api.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, Optional
+from typing import List, Dict, Optional, Union
 from datetime import datetime
 from pydantic import AliasChoices, BaseModel, Field, ConfigDict
 from ws_bom_robot_app.llm.models.kb import LlmKbEndpoint, LlmKbIntegration
@@ -125,7 +125,7 @@ class VectorDbRequest(BaseModel):
   def api_key(self):
     return self.secrets.get("openAIApiKey", "")
   def out_name(self):
-    return "vector_db_" + datetime.now().strftime("%Y-%m-%d_%H-%M-%S-%f")[:-3]
+    return f"db_{datetime.now().strftime("%Y-%m-%d_%H-%M-%S-%f")[:-3]}_{os.getpid()}"
 
 class RulesRequest(VectorDbRequest):
   type: Optional[str] = 'rules'

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/llm/models/kb.py

@@ -144,7 +144,7 @@ async def load_endpoints(endpoints: list[LlmKbEndpoint], destination_directory:
             documents = await JsonLoader(
               file_path,
               meta_fields=[field.name for field in endpoint.fields_mapping.meta_fields] if endpoint.fields_mapping.meta_fields else []
-            ).load()
+            ).aload()
             _documents.extend(documents)
             await aiofiles.os.remove(file_path)
           except Exception as e:

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/llm/vector_store/generator.py

@@ -9,7 +9,7 @@ from ws_bom_robot_app.llm.vector_store.integration.manager import IntegrationMan
 from ws_bom_robot_app.llm.utils.faiss_helper import FaissHelper
 from ws_bom_robot_app.util import timer
 
-@timer
+#@timer
 async def rules(rq: RulesRequest) -> VectorDbResponse:
   api_key = rq.api_key()
   _config = rq.config()

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/llm/vector_store/integration/sitemap.py

@@ -1,3 +1,4 @@
+from typing import Any
 import aiofiles
 import aiofiles.os
 from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy
@@ -6,21 +7,20 @@ from langchain_community.document_transformers import MarkdownifyTransformer as
 from langchain_core.documents import Document
 from bs4 import BeautifulSoup, Tag
 
-
 class Sitemap(IntegrationStrategy):
-    """_summary_
+    """Class to load a sitemap.xml file and extract text from the URLs.
       Load a sitemap.xml file and extract text from the urls.
     Args:
         data (dict[str, str]):
         data["sitemapUrl"] (str): absolute/relative url of the sitemap.xml
         data["outputFormat"] (str): ["text", "html", "markdown"] default to "text"
-        data["filterUrls"] list: list of regex pattern to filter urls ["https://www.example.com/en/products", "^.*products.*$"]
-        data["includeOnlySelector"] : [".content", "#main-article", "article p"]
-        data["excludeTag"] (str): default to ["script", "noscript", "style", "head", "header","nav","footer", "iframe"]
-        data["excludeClass"] (str): ["class1", "class2"]
-        data["excludeId"] (str): ["id1", "id2"]
+        data["filterUrls"] list[str]: list of regex pattern to filter urls ["https://www.example.com/en/products", "^.*products.*$"]
+        data["includeOnlySelector"] : list[str] [".content", "#main-article", "article p"]
+        data["excludeTag"] (list[str]): default to ["script", "noscript", "style", "head", "header","nav","footer", "iframe"]
+        data["excludeClass"] (list[str]): ["class1", "class2"]
+        data["excludeId"] (list[str]): ["id1", "id2"]
     """
-    def __init__(self, knowledgebase_path: str, data: dict[str, str]):
+    def __init__(self, knowledgebase_path: str, data: dict[str, Any]):
         super().__init__(knowledgebase_path, data)
         self.__sitemap_url = self.data.get("sitemapUrl")
         self.__filter_urls: list[str] = self.data.get("filterUrls",[]) # type: ignore
@@ -29,12 +29,12 @@ class Sitemap(IntegrationStrategy):
         self.__exclude_tag: list[str] = self.data.get("excludeTag",[]) # type: ignore
         self.__exclude_class: list[str] = self.data.get("excludeClass",[]) # type: ignore
         self.__exclude_id: list[str] = self.data.get("excludeId",[]) # type: ignore
-    def working_subdirectory(self) -> str: # type: ignore
+    def working_subdirectory(self) -> str:
         return ""
     def _extract(self, tag: Tag) -> str:
         return tag.get_text() if self.__output_format == "text" else tag.prettify()
     def _output(self, documents: list[Document]) -> list[Document]:
-        return list(markdownify().transform_documents(documents)) if (self.__output_format == "markdown") else documents
+        return list(markdownify().transform_documents(documents)) if self.__output_format == "markdown" else documents
     def _parse(self,content: BeautifulSoup) -> str:
         if self.__include_only_selectors:
             extracted = []
@@ -54,21 +54,25 @@ class Sitemap(IntegrationStrategy):
                 for _ in content.select(element):
                     _.decompose()
             return str(self._extract(content))
-    async def load(self) -> list[Document]:
-        def _is_local(url: str) -> bool:
-            return not url.startswith("http")
-        def _remap_if_local(url: str) -> str:
-            return f"{self.knowledgebase_path}/{url}" if _is_local(url) else url
+    def _is_local(self, url: str) -> bool:
+        return not url.startswith("http")
 
+    def _remap_if_local(self, url: str) -> str:
+        return f"{self.knowledgebase_path}/{url}" if self._is_local(url) else url
+
+    async def load(self) -> list[Document]:
         if (self.__sitemap_url):
             _loader = SitemapLoader(
-                web_path=_remap_if_local(self.__sitemap_url),
+                web_path=self._remap_if_local(self.__sitemap_url),
                 filter_urls=self.__filter_urls,
                 parsing_function=self._parse,
-                is_local=_is_local(self.__sitemap_url)
+                is_local=self._is_local(self.__sitemap_url)
             )
             _docs = self._output([document async for document in _loader.alazy_load()])
-            if _is_local(self.__sitemap_url):
-              await aiofiles.os.remove(_loader.web_path)
+            if self._is_local(self.__sitemap_url):
+              try:
+                  await aiofiles.os.remove(_loader.web_path)
+              except FileNotFoundError:
+                  pass
             return _docs
         return []

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/llm/vector_store/loader/base.py

@@ -109,4 +109,5 @@ class Loader():
   #@timer
   async def load(self) -> list[Document]:
     loaders = MergedDataLoader(self.__directory_loader())
-    return await asyncio.to_thread(loaders.load)
+    return await loaders.aload()
+    #return await asyncio.to_thread(loaders.load)

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/llm/vector_store/loader/json_loader.py

@@ -2,7 +2,6 @@ import json
 from typing import Optional
 from langchain_core.documents import Document
 from langchain_community.document_loaders.base import BaseLoader
-import aiofiles
 
 class JsonLoader(BaseLoader):
   def __init__(self, file_path: str, meta_fields:Optional[list[str]] = [],encoding: Optional[str] = "utf-8"):
@@ -10,9 +9,9 @@ class JsonLoader(BaseLoader):
     self.meta_fields = meta_fields
     self.encoding = encoding
 
-  async def load(self) -> list[Document]:
-    async with aiofiles.open(self.file_path, "r", encoding=self.encoding) as file:
-      data = json.loads(await file.read())
+  def load(self) -> list[Document]:
+    with open(self.file_path, "r", encoding=self.encoding) as file:
+      data = json.load(file)
     _list = data if isinstance(data, list) else [data]
     return [
       Document(

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/main.py

@@ -56,6 +56,7 @@ def diag(authenticate: bool = Depends(authenticate)):
                 "version": platform.version(),
                 "type": platform.machine(),
                 "processor": platform.processor(),
+                "cpu": os.cpu_count(),
                 "architecture": platform.architecture()
             },
             "sys": {

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app/task_manager.py

@@ -1,8 +1,10 @@
+from collections import deque
 import inspect
+from math import floor
 import asyncio, os
 from datetime import datetime, timedelta
 from enum import Enum
-from typing import Annotated, Literal, TypeVar, Optional, Dict, Union, Any
+from typing import Annotated, Coroutine, Literal, TypeVar, Optional, Dict, Union, Any
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 from uuid import uuid4
 from fastapi import APIRouter, HTTPException
@@ -11,41 +13,52 @@ from ws_bom_robot_app.llm.models.base import IdentifiableEntity
 from ws_bom_robot_app.llm.utils.webhooks import WebhookNotifier
 from ws_bom_robot_app.util import _log
 from sqlalchemy import create_engine, Column, String, JSON, DateTime, Enum
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.orm import sessionmaker, registry
 from abc import ABC, abstractmethod
 
 T = TypeVar('T')
 
 #region models
-class TaskStatistics(BaseModel):
-    class TaskStatisticExecutionTime(BaseModel):
-        min: str
-        max: str
-        avg: str
-    retention_days: float = config.robot_task_retention_days
-    total: int
-    pending: int
-    completed: int
-    failure: int
-    exec_time: TaskStatisticExecutionTime
-
 class TaskHeader(BaseModel):
+    """
+    TaskHeader model representing the header information for a task.
+    Example:
+    ```bash
+    curl -X POST "http://localhost:6001/api/llm/kb/task"
+      -H  "x-ws-bom-msg-id: 1234"
+      -H  "x-ws-bom-msg-type: generate.knowledgebase"
+      -H  "x-ws-bom-msg-extra: key1=value1,key2=value2"
+      -H  "x-ws-bom-webhooks: http://localhost:8000/api/webhook"
+      -d "{\"api_key\":\"string\"}"
+    ```
+    Attributes:
+      x_ws_bom_msg_id (Optional[str]): The message ID for the task. If not provided, a UUID will be generated.
+      x_ws_bom_msg_type (Optional[str]): The message type for the task, e.g. "send.email" or "generate.knowledgebase".
+      x_ws_bom_msg_extra (Optional[str]): Any extra information for the task, in comma separated key=value pairs. e.g. "key1=value1,key2=value2".
+      x_ws_bom_webhooks (Optional[str]): Webhooks associated with the task, called when the task is completed or failed.
+    """
+    x_ws_bom_msg_id: Optional[str] = None
     x_ws_bom_msg_type: Optional[str] = None
+    x_ws_bom_msg_extra: Optional[str] = None
     x_ws_bom_webhooks: Optional[str] = None
     model_config = ConfigDict(
         extra='allow'
     )
 
 class TaskMetaData(BaseModel):
-    start_time: str
-    end_time: Optional[str] = None
+    created_at: str
+    start_at: Optional[str] = None
+    end_at: Optional[str] = None
     @computed_field
     @property
     def elapsed_time(self) -> Union[str, None]:
-        return str((datetime.now() if not self.end_time else datetime.fromisoformat(self.end_time)) - datetime.fromisoformat(self.start_time))
+        return str(
+            (datetime.now() if not self.end_at else datetime.fromisoformat(self.end_at))
+            - datetime.fromisoformat(self.created_at if not self.start_at else self.start_at)
+            )
     source: Optional[str] = None
     pid: Optional[int] = None
+    extra: Optional[dict[str,str]] = None
 
 class TaskStatus(IdentifiableEntity):
     type: Optional[str] = None
@@ -59,6 +72,7 @@ class TaskStatus(IdentifiableEntity):
 
 class TaskEntry(IdentifiableEntity):
     task: Annotated[asyncio.Task, Field(default=None, validate_default=False)] = None
+    coroutine: Coroutine = None
     headers: TaskHeader | None = None
     status: Union[TaskStatus, None] = None
     def _get_coroutine_name(self, coroutine: asyncio.coroutines) -> str:
@@ -66,6 +80,15 @@ class TaskEntry(IdentifiableEntity):
             return coroutine.cr_code.co_name
         return "<unknown>"
     def __init__(self, **data):
+        def _metadata_extra(data: str) -> dict[str,str] | None:
+            if data:
+                _values = data.split(",")
+                if _values:
+                    try:
+                        return {k: v for k,v in [val.split("=") for val in _values]}
+                    except Exception as e:
+                        return None
+            return None
         #separate task from data to handle asyncio.Task
         task = data.pop('task',None)
         super().__init__(**data)
@@ -75,22 +98,47 @@ class TaskEntry(IdentifiableEntity):
         if not self.status:
           self.status = TaskStatus(
               id=self.id,
-              type=self.headers.x_ws_bom_msg_type if self.headers and self.headers.x_ws_bom_msg_type else self._get_coroutine_name(task._coro) if task else None,
+              type=self.headers.x_ws_bom_msg_type if self.headers and self.headers.x_ws_bom_msg_type else self._get_coroutine_name(self.coroutine) if self.coroutine else None,
               status="pending",
               metadata=TaskMetaData(
-                 start_time=str(datetime.now().isoformat()),
-                 source=self._get_coroutine_name(task._coro) if task else None,
-                 pid=os.getpid())
+                 created_at=str(datetime.now().isoformat()),
+                 source=self._get_coroutine_name(self.coroutine) if self.coroutine else None,
+                 pid=os.getpid(),
+                 extra=_metadata_extra(self.headers.x_ws_bom_msg_extra) if self.headers and self.headers.x_ws_bom_msg_extra else None
+                 )
               )
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
         validate_assignment=True
     )
 
+class TaskStatistics(BaseModel):
+    class TaskStatisticExecutionInfo(BaseModel):
+        retention_days: float = config.robot_task_retention_days
+        max_concurrent: int
+        running: list[TaskStatus]
+        slowest: list
+    class TaskStatisticExecutionTime(BaseModel):
+        min: str
+        max: str
+        avg: str
+    total: int
+    pending: int
+    completed: int
+    failure: int
+    exec_time: TaskStatisticExecutionTime
+    exec_info: TaskStatisticExecutionInfo
+
 #endregion
 
 #region interface
 class TaskManagerStrategy(ABC):
+    def __init__(self, max_concurrent_tasks: int = floor(2 * config.robot_task_max_concurrent / config.runtime_options().number_of_workers)):
+        self.max_concurrent_tasks = max_concurrent_tasks
+        self.semaphore = asyncio.Semaphore(self.max_concurrent_tasks)
+        self.running_tasks = dict[str, TaskEntry]()
+        self.loop = asyncio.get_event_loop()
+
     @abstractmethod
     def create_task(self, coroutine, headers: TaskHeader | None = None) -> IdentifiableEntity:
         pass
@@ -105,7 +153,7 @@ class TaskManagerStrategy(ABC):
         pass
 
     @abstractmethod
-    def get_tasks(self) -> list[TaskStatus] | None:
+    def get_tasks(self) -> list[TaskStatus]:
         pass
 
     @abstractmethod
@@ -121,7 +169,7 @@ class TaskManagerStrategy(ABC):
         pass
 
     def task_cleanup_rule(self, task: TaskEntry) -> bool:
-        return task.status.status in {"completed", "failure"} and datetime.fromisoformat(task.status.metadata.end_time) < datetime.now() - timedelta(days=config.robot_task_retention_days)
+        return task.status.status in {"completed", "failure"} and datetime.fromisoformat(task.status.metadata.end_at) < datetime.now() - timedelta(days=config.robot_task_retention_days)
 
     def task_done_callback(self, task_entry: TaskEntry, headers: TaskHeader | None = None) -> callable:
         def callback(task: asyncio.Task):
@@ -133,7 +181,7 @@ class TaskManagerStrategy(ABC):
                 task_entry.status.status = "failure"
                 task_entry.status.error = str(e)
             finally:
-                task_entry.status.metadata.end_time = str(datetime.now().isoformat())
+                task_entry.status.metadata.end_at = str(datetime.now().isoformat())
                 #strategy-specific behavior
                 self.update_task_status(task_entry)
                 #notify webhooks
@@ -142,14 +190,32 @@ class TaskManagerStrategy(ABC):
                           WebhookNotifier().notify_webhook(task_entry.status,headers.x_ws_bom_webhooks)
                           )
         return callback
+
     def create_task_entry(self, coroutine: asyncio.coroutines, headers: TaskHeader | None = None) -> TaskEntry:
+        _id = headers and headers.x_ws_bom_msg_id or str(uuid4())
         task = TaskEntry(
-            id=str(uuid4()),
-            task=asyncio.create_task(coroutine),
+            id=_id,
+            coroutine=coroutine,
             headers=headers)
-        task.task.add_done_callback(self.task_done_callback(task, headers))
+        self.loop.create_task(self._run_task_with_semaphore(task)) # run the task
         return task
 
+    async def _run_task_with_semaphore(self, task_entry: TaskEntry):
+        """Run a task with semaphore control to limit concurrency."""
+        async with self.semaphore:
+          self.running_tasks[task_entry.id]=task_entry
+          await self._execute_task(task_entry)
+          del self.running_tasks[task_entry.id]
+
+    async def _execute_task(self, task_entry: TaskEntry):
+        """Execute a task and handle its lifecycle."""
+        task_entry.status.metadata.start_at = str(datetime.now().isoformat())
+        task_entry.task = asyncio.create_task(task_entry.coroutine)
+        task_entry.task.add_done_callback(self.task_done_callback(task_entry, task_entry.headers))
+        await task_entry.task
+
+    def running_task(self):
+        return self.running_tasks.values()
     def stats(self) -> TaskStatistics:
         def __string_to_timedelta(value: str) -> timedelta:
             if "." in value:
@@ -163,12 +229,13 @@ class TaskManagerStrategy(ABC):
             minutes, seconds = divmod(remainder, 60)
             return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}.{td.microseconds}"
         _all = self.get_tasks()
-        _not_pending = _all and [task for task in _all if task.status != "pending"]
-        _total_not_pending = len(_not_pending)
-        elapsed_times = [__string_to_timedelta(task.metadata.elapsed_time) for task in _not_pending]
-        _avg_exec_time = sum(elapsed_times, timedelta()) / _total_not_pending if _total_not_pending > 0 else timedelta()
-        _min_exec_time = min(elapsed_times) if _total_not_pending > 0 else timedelta()
-        _max_exec_time = max(elapsed_times) if _total_not_pending > 0 else timedelta()
+        _not_pending = _all and [task for task in _all if task.status != "pending"] or []
+        _total_not_pending = _not_pending and len(_not_pending) if _not_pending else 0
+        elapsed_times = _not_pending and [__string_to_timedelta(task.metadata.elapsed_time) for task in _not_pending]
+        _avg_exec_time = sum(elapsed_times, timedelta()) / _total_not_pending if elapsed_times and _total_not_pending > 0 else timedelta()
+        _min_exec_time = min(elapsed_times) if elapsed_times and _total_not_pending > 0 else timedelta()
+        _max_exec_time = max(elapsed_times) if elapsed_times and _total_not_pending > 0 else timedelta()
+        _slowest: list[TaskStatus] = _not_pending and sorted(_not_pending, key=lambda x: __string_to_timedelta(x.metadata.elapsed_time), reverse=True)[:3]
         return TaskStatistics(
             total= _all and len(_all) or 0,
             pending=_all and len([task for task in _all if task.status == "pending"]) or 0,
@@ -178,6 +245,12 @@ class TaskManagerStrategy(ABC):
                 min=__timedelta_to_string(_min_exec_time),
                 max=__timedelta_to_string(_max_exec_time),
                 avg=__timedelta_to_string(_avg_exec_time)
+            ),
+            exec_info=TaskStatistics.TaskStatisticExecutionInfo(
+                retention_days=config.robot_task_retention_days,
+                max_concurrent=self.max_concurrent_tasks,
+                running=[task.status for task in self.running_task()],
+                slowest=_slowest
             )
         )
 
@@ -186,6 +259,7 @@ class TaskManagerStrategy(ABC):
 #memory implementation
 class MemoryTaskManagerStrategy(TaskManagerStrategy):
     def __init__(self):
+        super().__init__()
         self.tasks: Dict[str, TaskEntry] = {}
 
     def create_task(self, coroutine: asyncio.coroutines, headers: TaskHeader | None = None) -> IdentifiableEntity:
@@ -199,7 +273,7 @@ class MemoryTaskManagerStrategy(TaskManagerStrategy):
 
     def get_task(self, id: str) -> TaskStatus | None:
         if _task := self.tasks.get(id):
-            return _task
+            return _task.status
         return None
 
     def get_tasks(self) -> list[TaskStatus] | None:
@@ -217,7 +291,7 @@ class MemoryTaskManagerStrategy(TaskManagerStrategy):
 #endregion
 
 #db implementation
-Base = declarative_base()
+Base = registry().generate_base()
 class TaskEntryModel(Base):
     __tablename__ = "entry"
     id = Column(String, primary_key=True)
@@ -227,6 +301,7 @@ class TaskEntryModel(Base):
     )
 class DatabaseTaskManagerStrategy(TaskManagerStrategy):
     def __init__(self, db_url: str = "sqlite:///.data/db/tasks.sqlite"):
+        super().__init__()
         self.engine = create_engine(db_url)
         self.Session = sessionmaker(bind=self.engine)
         Base.metadata.create_all(self.engine)
@@ -249,15 +324,15 @@ class DatabaseTaskManagerStrategy(TaskManagerStrategy):
         with self.Session() as session:
             task = session.query(TaskEntryModel).filter_by(id=id).first()
             if task:
-                return TaskEntry(**task.__dict__)
+                return TaskEntry(**task.__dict__).status
         return None
 
-    def get_tasks(self) -> list[TaskStatus] | None:
+    def get_tasks(self) -> list[TaskStatus]:
         with self.Session() as session:
             tasks = session.query(TaskEntryModel).all()
             if tasks:
                 return [TaskEntry(**task.__dict__).status for task in tasks]
-        return None
+        return []
 
     def remove_task(self, id: str) -> None:
         with self.Session() as session:
@@ -286,10 +361,10 @@ router = APIRouter(prefix="/api/task", tags=["task"])
 
 @router.get("/status/{id}")
 async def _status_task(id: str) -> TaskStatus:
-    task = task_manager.get_task(id)
-    if not task:
+    task_status = task_manager.get_task(id)
+    if not task_status:
         raise HTTPException(status_code=404, detail="Task not found")
-    return task.status
+    return task_status
 
 @router.get("/status")
 async def _status_task_list() -> list[TaskStatus]:
@@ -308,4 +383,5 @@ async def _remove_task_list():
 @router.get("/stats")
 async def _stats() -> TaskStatistics:
     return task_manager.stats()
+
 #endregion

{ws_bom_robot_app-0.0.11 → ws_bom_robot_app-0.0.12}/ws_bom_robot_app.egg-info/PKG-INFO

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