pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/lab/processes/mappers.py

@@ -110,8 +110,8 @@ class AgenticProcessMapper:
         """
         return [
             Variable(
-                key=var["key"],
-                value=var["value"]
+                key=var.get("key"),
+                value=var.get("value")
             )
             for var in data
         ]
@@ -370,7 +370,7 @@ class JobMapper:
         return Job(
             caption=data.get("caption"),
             name=data.get("name"),
-            parameters=cls._map_to_job_parameters(parameters_data) if parameters_data else None,
+            parameters=cls._map_to_job_parameters(parameters_data) if parameters_data else [],
             request=data.get("request"),
             token=data.get("token"),
             topic=data.get("topic"),

pygeai/lab/runners.py

@@ -0,0 +1,90 @@
+import asyncio
+from typing import Union
+
+from pygeai.chat.managers import ChatManager
+from pygeai.core.common.exceptions import WrongArgumentError
+from pygeai.core.models import ChatMessage, ChatMessageList, LlmSettings
+from pygeai.core.responses import ProviderResponse
+from pygeai.lab.models import Agent
+
+
+class Runner:
+
+    @classmethod
+    async def run(
+            cls,
+            agent: Agent,
+            user_input: Union[str | ChatMessage | ChatMessageList],
+            llm_settings: Union[dict | LlmSettings] = None
+    ) -> ProviderResponse:
+        """
+        Asynchronously executes a chat completion request for the specified agent with the provided user input and LLM settings.
+
+        :param agent: Agent - The agent configuration to use for the chat completion.
+        :param user_input: Union[str, ChatMessage, ChatMessageList] - The user input, which can be a string, a single ChatMessage, or a ChatMessageList.
+        :param llm_settings: Union[dict, LlmSettings] - Optional LLM configuration settings. If None, default settings are used.
+        :return: ProviderResponse - The ProviderResponse from the chat completion request.
+        :raises WrongArgumentError: If the user_input type is not str, ChatMessage, or ChatMessageList.
+        """
+        messages = cls._get_messages(user_input)
+        llm_settings = cls._get_llm_settings(llm_settings)
+
+        chat_manager = ChatManager()
+        response = await asyncio.to_thread(
+            chat_manager.chat_completion,
+            model=f"saia:agent:{agent.name}",
+            messages=messages,
+            llm_settings=llm_settings
+        )
+        return response
+
+    @classmethod
+    def _get_messages(cls, user_input: Union[str | ChatMessage | ChatMessageList]):
+        """
+        Converts the user input into a ChatMessageList for use in chat completion.
+
+        :param user_input: Union[str, ChatMessage, ChatMessageList] - The user input to process.
+        :return: ChatMessageList - A ChatMessageList containing the processed user input.
+        :raises WrongArgumentError: If the user_input type is not str, ChatMessage, or ChatMessageList.
+        """
+        if isinstance(user_input, str):
+            new_message = {
+                "role": "user",
+                "content": user_input
+            }
+            messages = ChatMessageList(messages=[new_message])
+        elif isinstance(user_input, ChatMessage):
+            messages = ChatMessageList(messages=[user_input])
+        elif isinstance(user_input, ChatMessageList):
+            messages = user_input
+        else:
+            raise WrongArgumentError("message must be either of string, ChatMessage or ChatMessageList type")
+
+        return messages
+
+    @classmethod
+    def _get_llm_settings(cls, llm_settings: Union[dict | LlmSettings]):
+        """
+        Processes the LLM settings into a dictionary format for chat completion.
+
+        :param llm_settings: Union[dict, LlmSettings] - The LLM settings to process. If None, default settings are applied.
+        :return: LlmSettings - A LlmSettings object containing the LLM configuration settings.
+        """
+        if not llm_settings:
+            llm_settings = LlmSettings.model_validate({
+                "temperature": 0.6,
+                "max_tokens": 800,
+                "frequency_penalty": 0.1,
+                "presence_penalty": 0.2
+            })
+        elif isinstance(llm_settings, dict):
+            llm_settings = LlmSettings(
+                provider_name=llm_settings.get("providerName") or llm_settings.get("provider") or llm_settings.get("provider_name"),
+                model_name=llm_settings.get("modelName") or llm_settings.get("model") or llm_settings.get("model_name"),
+                temperature=llm_settings.get("temperature"),
+                max_tokens=llm_settings.get("maxTokens") or llm_settings.get("max_tokens"),
+                frequency_penalty=llm_settings.get("frequency_penalty") or llm_settings.get("frequencyPenalty"),
+                presence_penalty=llm_settings.get("presence_penalty") or llm_settings.get("presencePenalty"),
+            )
+
+        return llm_settings

pygeai/lab/spec/loader.py

@@ -0,0 +1,24 @@
+import json
+from pathlib import Path
+
+from pygeai import logger
+from pygeai.core.common.exceptions import InvalidPathException, InvalidJSONException
+
+
+class JSONLoader:
+
+    @classmethod
+    def load_data(cls, file_path: str):
+        data = {}
+        file = Path(file_path)
+        if not file.exists():
+            raise InvalidPathException(f"File {file_path} doesn't exist")
+
+        with open(file_path, 'r') as f:
+            try:
+                data = json.load(f)
+            except json.JSONDecodeError as e:
+                logger.error(f"The file doesn't contain a valid JSON: {e}")
+                raise InvalidJSONException(f"File {file_path} doesn't contain valid JSON.")
+
+        return data

pygeai/lab/spec/parsers.py

@@ -0,0 +1,39 @@
+from pygeai.lab.models import Agent, Tool, Task, AgenticProcess
+
+
+class AgentParser:
+
+    @classmethod
+    def get_agent(cls, data: dict):
+        agent = Agent.model_validate(data)
+
+        return agent
+
+
+class ToolParser:
+
+    @classmethod
+    def get_tool(cls, data: dict):
+        tool = Tool.model_validate(data)
+
+        return tool
+
+
+class TaskParser:
+
+    @classmethod
+    def get_task(cls, data: dict):
+        task = Task.model_validate(data)
+
+        return task
+
+
+class AgenticProcessParser:
+
+    @classmethod
+    def get_agentic_process(cls, data: dict):
+        proces = AgenticProcess.model_validate(data)
+
+        return proces
+
+

pygeai/lab/strategies/clients.py

@@ -1,10 +1,14 @@
-from json import JSONDecodeError
-from pygeai.core.base.clients import BaseClient
+
+from pygeai import logger
+from pygeai.core.common.exceptions import InvalidAPIResponseException
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
+from pygeai.lab.clients import AILabClient
 from pygeai.lab.strategies.endpoints import LIST_REASONING_STRATEGIES_V2, CREATE_REASONING_STRATEGY_V2, \
     UPDATE_REASONING_STRATEGY_V2, UPSERT_REASONING_STRATEGY_V2, GET_REASONING_STRATEGY_V2
 
 
-class ReasoningStrategyClient(BaseClient):
+class ReasoningStrategyClient(AILabClient):
 
     def list_reasoning_strategies(
             self,
@@ -15,16 +19,16 @@ class ReasoningStrategyClient(BaseClient):
             access_scope: str = "public"
     ):
         """
-        Retrieves a list of reasoning strategies available in the system, filtered by the specified criteria.
-
-        :param name: str - Name of the reasoning strategy to filter by. Defaults to an empty string (no filtering).
-        :param start: str - Starting index for pagination. Defaults to "0".
-        :param count: str - Number of reasoning strategies to retrieve. Defaults to "100".
-        :param allow_external: bool - Whether to include external reasoning strategies in the list. Defaults to True.
-        :param access_scope: str - Access scope of the reasoning strategies, either "public" or "private". Defaults to "public".
-        :return: dict or str - JSON response containing the list of reasoning strategies if successful, otherwise the raw response text.
+        Retrieves a list of reasoning strategies filtered by specified criteria.
+
+        :param name: str, optional - Name to filter strategies (default: "").
+        :param start: str, optional - Starting index for pagination (default: "0").
+        :param count: str, optional - Number of strategies to retrieve (default: "100").
+        :param allow_external: bool, optional - Include external strategies (default: True).
+        :param access_scope: str, optional - Access scope, "public" or "private" (default: "public").
+        :return: dict - List of reasoning strategies.
         :raises ValueError: If access_scope is not "public" or "private".
-        :raises Exception: If the request fails due to network issues, authentication errors, or server-side problems.
+        :raises InvalidAPIResponseException: If the API response cannot be parsed.
         """
         valid_access_scopes = ["public", "private"]
         if access_scope not in valid_access_scopes:
@@ -39,17 +43,16 @@ class ReasoningStrategyClient(BaseClient):
             "allowExternal": allow_external,
             "accessScope": access_scope,
         }
+
+        logger.debug("Listing reasoning strategies")
+
         response = self.api_service.get(endpoint=endpoint, headers=headers, params=params)
-        try:
-            result = response.json()
-        except JSONDecodeError:
-            result = response.text
+        validate_status_code(response)
+        return parse_json_response(response, "list reasoning strategies")
 
-        return result
 
     def create_reasoning_strategy(
             self,
-            project_id: str,
             name: str,
             system_prompt: str,
             access_scope: str = "public",
@@ -60,14 +63,14 @@ class ReasoningStrategyClient(BaseClient):
         """
         Creates a new reasoning strategy in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param name: str - Name of the reasoning strategy.
-        :param system_prompt: str - System prompt for the reasoning strategy.
-        :param access_scope: str - Access scope, either 'public' or 'private'. Defaults to 'public'.
-        :param strategy_type: str - Type of the strategy, e.g., 'addendum'. Defaults to 'addendum'.
-        :param localized_descriptions: list - List of localized description dictionaries with 'language' and 'description'.
-        :param automatic_publish: bool - Whether to automatically publish the reasoning strategy after updating. Defaults to False.
-        :return: dict or str - JSON response with the created strategy details if successful, otherwise raw text.
+        :param system_prompt: str - System prompt for the strategy.
+        :param access_scope: str, optional - Access scope, "public" or "private" (default: "public").
+        :param strategy_type: str, optional - Strategy type, e.g., "addendum" (default: "addendum").
+        :param localized_descriptions: list, optional - List of localized description dictionaries.
+        :param automatic_publish: bool, optional - Publish strategy after creation (default: False).
+        :return: dict - Created strategy details.
+        :raises InvalidAPIResponseException: If the API response cannot be parsed.
         """
         endpoint = CREATE_REASONING_STRATEGY_V2
         if automatic_publish:
@@ -75,7 +78,7 @@ class ReasoningStrategyClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id,
+            "ProjectId": self.project_id,
             "Content-Type": "application/json",
             "Accept": "application/json"
         }
@@ -88,17 +91,16 @@ class ReasoningStrategyClient(BaseClient):
                 "localizedDescriptions": localized_descriptions or []
             }
         }
+
+        logger.debug(f"Creating reasoning strategy with data: {data}")
+
         response = self.api_service.post(endpoint=endpoint, headers=headers, data=data)
-        try:
-            result = response.json()
-        except JSONDecodeError:
-            result = response.text
+        validate_status_code(response)
+        return parse_json_response(response, f"create reasoning strategy for project {self.project_id}")
 
-        return result
 
     def update_reasoning_strategy(
             self,
-            project_id: str,
             reasoning_strategy_id: str,
             name: str = None,
             system_prompt: str = None,
@@ -109,19 +111,19 @@ class ReasoningStrategyClient(BaseClient):
             upsert: bool = False
     ):
         """
-        Updates an existing reasoning strategy in the specified project or upserts it if specified.
-
-        :param project_id: str - Unique identifier of the project.
-        :param reasoning_strategy_id: str - Unique identifier of the reasoning strategy to update.
-        :param name: str, optional - Updated name of the reasoning strategy.
-        :param system_prompt: str, optional - Updated system prompt for the reasoning strategy.
-        :param access_scope: str, optional - Updated access scope, either 'public' or 'private'.
-        :param strategy_type: str, optional - Updated type of the strategy, e.g., 'addendum'.
-        :param localized_descriptions: list, optional - Updated list of localized description dictionaries.
-        :param automatic_publish: bool - Whether to publish the strategy after updating. Defaults to False.
-        :param upsert: bool - Whether to insert the strategy if it does not exist (upsert) instead of just updating. Defaults to False.
-        :return: dict or str - JSON response with the updated strategy details if successful, otherwise raw text.
-        :raises ValueError: If access_scope is not 'public' or 'private', or if type is not 'addendum'.
+        Updates or upserts a reasoning strategy in the specified project.
+
+        :param reasoning_strategy_id: str - Unique identifier of the strategy.
+        :param name: str, optional - Updated strategy name.
+        :param system_prompt: str, optional - Updated system prompt.
+        :param access_scope: str, optional - Updated access scope, "public" or "private".
+        :param strategy_type: str, optional - Updated strategy type, e.g., "addendum".
+        :param localized_descriptions: list, optional - Updated localized descriptions.
+        :param automatic_publish: bool, optional - Publish strategy after update (default: False).
+        :param upsert: bool, optional - Create strategy if it doesn't exist (default: False).
+        :return: dict - Updated strategy details.
+        :raises ValueError: If access_scope is not "public" or "private", or strategy_type is not "addendum".
+        :raises InvalidAPIResponseException: If the API response cannot be parsed.
         """
         if access_scope is not None:
             valid_access_scopes = ["public", "private"]
@@ -146,6 +148,8 @@ class ReasoningStrategyClient(BaseClient):
         if localized_descriptions is not None:
             data["strategyDefinition"]["localizedDescriptions"] = localized_descriptions
 
+        logger.debug(f"Updating reasoning strategy with ID {reasoning_strategy_id} with data: {data}")
+
         endpoint = UPSERT_REASONING_STRATEGY_V2 if upsert else UPDATE_REASONING_STRATEGY_V2
         endpoint = endpoint.format(reasoningStrategyId=reasoning_strategy_id)
 
@@ -154,7 +158,7 @@ class ReasoningStrategyClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id,
+            "ProjectId": self.project_id,
             "Content-Type": "application/json",
             "Accept": "application/json"
         }
@@ -163,27 +167,23 @@ class ReasoningStrategyClient(BaseClient):
             headers=headers,
             data=data
         )
-        try:
-            result = response.json()
-        except JSONDecodeError:
-            result = response.text
+        validate_status_code(response)
+        return parse_json_response(response, f"update reasoning strategy {reasoning_strategy_id} in project {self.project_id}")
 
-        return result
 
     def get_reasoning_strategy(
             self,
-            project_id: str,
             reasoning_strategy_id: str = None,
             reasoning_strategy_name: str = None
     ):
         """
-        Retrieves details of a specific reasoning strategy in the specified project, identified by either its ID or name.
+        Retrieves a reasoning strategy by ID or name in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
-        :param reasoning_strategy_id: str, optional - Unique identifier of the reasoning strategy to retrieve. Defaults to None.
-        :param reasoning_strategy_name: str, optional - Name of the reasoning strategy to retrieve. Defaults to None.
-        :return: dict or str - JSON response containing the reasoning strategy details if successful, otherwise the raw response text.
+        :param reasoning_strategy_id: str, optional - Unique identifier of the strategy.
+        :param reasoning_strategy_name: str, optional - Name of the strategy.
+        :return: dict - Strategy details.
         :raises ValueError: If neither reasoning_strategy_id nor reasoning_strategy_name is provided.
+        :raises InvalidAPIResponseException: If the API response cannot be parsed.
         """
         if not (reasoning_strategy_id or reasoning_strategy_name):
             raise ValueError("Either reasoning_strategy_id or reasoning_strategy_name must be provided.")
@@ -193,16 +193,20 @@ class ReasoningStrategyClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
+        if reasoning_strategy_id:
+            logger.debug(f"Retrieving reasoning strategy detail with ID {reasoning_strategy_id}")
+        else:
+            logger.debug(f"Retrieving reasoning strategy detail with name {reasoning_strategy_name}")
+
         response = self.api_service.get(
             endpoint=endpoint,
             headers=headers
         )
-        try:
-            result = response.json()
-        except JSONDecodeError:
-            result = response.text
+        strategy_identifier = reasoning_strategy_id or reasoning_strategy_name
+        validate_status_code(response)
+        return parse_json_response(response, f"retrieve reasoning strategy {strategy_identifier} for project {self.project_id}")
 
-        return result
+    

pygeai/lab/strategies/mappers.py

@@ -49,7 +49,7 @@ class ReasoningStrategyMapper:
     @classmethod
     def map_to_reasoning_strategy_list(cls, data: dict) -> ReasoningStrategyList:
         strategy_list = []
-        strategies = data.get("strategies", data if isinstance(data, list) else [])
+        strategies = data.get("strategies") if isinstance(data, dict) else data if isinstance(data, list) else []
         if strategies and any(strategies):
             for strategy_data in strategies:
                 strategy = cls.map_to_reasoning_strategy(strategy_data)