pygeai 0.1.6__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/analytics/mappers.py

@@ -0,0 +1,207 @@
+from pygeai.analytics.responses import (
+    AgentsCreatedAndModifiedResponse, AgentsCreatedAndModifiedPerDayResponse, AgentActivityPerDayItem,
+    FlowsCreatedAndModifiedResponse, FlowsCreatedAndModifiedPerDayResponse, FlowActivityPerDayItem,
+    ProcessesCreatedAndModifiedResponse, AgentUsagePerUserResponse, AgentUsagePerUserItem,
+    AverageCostPerRequestResponse, AverageCostPerUserResponse, AverageCostPerUserPerDateResponse,
+    CostPerUserPerDateItem, AverageRequestTimeResponse, AverageRequestsPerDayResponse,
+    AverageRequestsPerUserResponse, AverageRequestsPerUserPerDateResponse, RequestsPerUserPerDateItem,
+    AverageTokensPerRequestResponse, AverageUsersPerAgentResponse, UsersPerAgentItem,
+    AverageUsersPerProjectResponse, UsersPerProjectItem, NumberOfTokensResponse,
+    NumberOfTokensPerAgentResponse, TokensPerAgentItem, NumberOfTokensPerDayResponse, TokensPerDayItem,
+    OverallErrorRateResponse, Top10AgentsByRequestsResponse, AgentByRequestsItem,
+    Top10AgentsByTokensResponse, AgentByTokensItem, Top10UsersByCostResponse, UserByCostItem,
+    Top10UsersByRequestsResponse, UserByRequestsItem, TotalActiveAgentsResponse,
+    TotalActiveProjectsResponse, TotalActiveUsersResponse, TotalCostResponse,
+    TotalCostPerDayResponse, CostPerDayItem, TotalRequestTimeResponse, TotalRequestsResponse,
+    TotalRequestsPerDayResponse, RequestsPerDayItem, TotalRequestsWithErrorResponse, TotalTokensResponse
+)
+
+
+class AnalyticsResponseMapper:
+
+    @classmethod
+    def map_to_agents_created_and_modified_response(cls, data: dict) -> AgentsCreatedAndModifiedResponse:
+        return AgentsCreatedAndModifiedResponse(
+            createdAgents=data.get("createdAgents", 0),
+            modifiedAgents=data.get("modifiedAgents", 0)
+        )
+
+    @classmethod
+    def map_to_agents_created_and_modified_per_day_response(cls, data: dict) -> AgentsCreatedAndModifiedPerDayResponse:
+        items_data = data.get("agentsCreatedAndModifiedPerDay", [])
+        items = [AgentActivityPerDayItem.model_validate(item) for item in items_data]
+        return AgentsCreatedAndModifiedPerDayResponse(agentsCreatedAndModifiedPerDay=items)
+
+    @classmethod
+    def map_to_flows_created_and_modified_response(cls, data: dict) -> FlowsCreatedAndModifiedResponse:
+        return FlowsCreatedAndModifiedResponse(
+            createdFlows=data.get("createdFlows", 0),
+            modifiedFlows=data.get("modifiedFlows", 0)
+        )
+
+    @classmethod
+    def map_to_flows_created_and_modified_per_day_response(cls, data: dict) -> FlowsCreatedAndModifiedPerDayResponse:
+        items_data = data.get("flowsCreatedAndModifiedPerDay", [])
+        items = [FlowActivityPerDayItem.model_validate(item) for item in items_data]
+        return FlowsCreatedAndModifiedPerDayResponse(flowsCreatedAndModifiedPerDay=items)
+
+    @classmethod
+    def map_to_processes_created_and_modified_response(cls, data: dict) -> ProcessesCreatedAndModifiedResponse:
+        return ProcessesCreatedAndModifiedResponse(
+            createdProcesses=data.get("createdProcesses", 0),
+            modifiedProcesses=data.get("modifiedProcesses", 0)
+        )
+
+    @classmethod
+    def map_to_agent_usage_per_user_response(cls, data: dict) -> AgentUsagePerUserResponse:
+        items_data = data.get("agentUsagePerUser", [])
+        items = [AgentUsagePerUserItem.model_validate(item) for item in items_data]
+        return AgentUsagePerUserResponse(agentUsagePerUser=items)
+
+    @classmethod
+    def map_to_average_cost_per_request_response(cls, data: dict) -> AverageCostPerRequestResponse:
+        return AverageCostPerRequestResponse(averageCost=data.get("averageCost", 0.0))
+
+    @classmethod
+    def map_to_average_cost_per_user_response(cls, data: dict) -> AverageCostPerUserResponse:
+        return AverageCostPerUserResponse(averageCost=data.get("averageCost", 0.0))
+
+    @classmethod
+    def map_to_average_cost_per_user_per_date_response(cls, data: dict) -> AverageCostPerUserPerDateResponse:
+        items_data = data.get("averageCostPerUserPerDate", [])
+        items = [CostPerUserPerDateItem.model_validate(item) for item in items_data]
+        return AverageCostPerUserPerDateResponse(averageCostPerUserPerDate=items)
+
+    @classmethod
+    def map_to_average_request_time_response(cls, data: dict) -> AverageRequestTimeResponse:
+        return AverageRequestTimeResponse(averageTime=data.get("averageTime", 0.0))
+
+    @classmethod
+    def map_to_average_requests_per_day_response(cls, data: dict) -> AverageRequestsPerDayResponse:
+        return AverageRequestsPerDayResponse(averageRequests=data.get("averageRequests", 0.0))
+
+    @classmethod
+    def map_to_average_requests_per_user_response(cls, data: dict) -> AverageRequestsPerUserResponse:
+        return AverageRequestsPerUserResponse(averageRequests=data.get("averageRequests", 0.0))
+
+    @classmethod
+    def map_to_average_requests_per_user_per_date_response(cls, data: dict) -> AverageRequestsPerUserPerDateResponse:
+        items_data = data.get("averageRequestsPerUserPerDate", [])
+        items = [RequestsPerUserPerDateItem.model_validate(item) for item in items_data]
+        return AverageRequestsPerUserPerDateResponse(averageRequestsPerUserPerDate=items)
+
+    @classmethod
+    def map_to_average_tokens_per_request_response(cls, data: dict) -> AverageTokensPerRequestResponse:
+        return AverageTokensPerRequestResponse(
+            averageInputTokens=data.get("averageInputTokens", 0.0),
+            averageOutputTokens=data.get("averageOutputTokens", 0.0),
+            averageTotalTokens=data.get("averageTotalTokens", 0.0)
+        )
+
+    @classmethod
+    def map_to_average_users_per_agent_response(cls, data: dict) -> AverageUsersPerAgentResponse:
+        items_data = data.get("averageUsersPerAgent", [])
+        items = [UsersPerAgentItem.model_validate(item) for item in items_data]
+        return AverageUsersPerAgentResponse(averageUsersPerAgent=items)
+
+    @classmethod
+    def map_to_average_users_per_project_response(cls, data: dict) -> AverageUsersPerProjectResponse:
+        items_data = data.get("averageUsersPerProject", [])
+        items = [UsersPerProjectItem.model_validate(item) for item in items_data]
+        return AverageUsersPerProjectResponse(averageUsersPerProject=items)
+
+    @classmethod
+    def map_to_number_of_tokens_response(cls, data: dict) -> NumberOfTokensResponse:
+        return NumberOfTokensResponse(
+            totalInputTokens=data.get("totalInputTokens", 0),
+            totalOutputTokens=data.get("totalOutputTokens", 0),
+            totalTokens=data.get("totalTokens", 0)
+        )
+
+    @classmethod
+    def map_to_number_of_tokens_per_agent_response(cls, data: dict) -> NumberOfTokensPerAgentResponse:
+        items_data = data.get("tokensPerAgent", [])
+        items = [TokensPerAgentItem.model_validate(item) for item in items_data]
+        return NumberOfTokensPerAgentResponse(tokensPerAgent=items)
+
+    @classmethod
+    def map_to_number_of_tokens_per_day_response(cls, data: dict) -> NumberOfTokensPerDayResponse:
+        items_data = data.get("tokensPerDay", [])
+        items = [TokensPerDayItem.model_validate(item) for item in items_data]
+        return NumberOfTokensPerDayResponse(tokensPerDay=items)
+
+    @classmethod
+    def map_to_overall_error_rate_response(cls, data: dict) -> OverallErrorRateResponse:
+        return OverallErrorRateResponse(errorRate=data.get("errorRate", 0.0))
+
+    @classmethod
+    def map_to_top_10_agents_by_requests_response(cls, data: dict) -> Top10AgentsByRequestsResponse:
+        items_data = data.get("topAgents", [])
+        items = [AgentByRequestsItem.model_validate(item) for item in items_data]
+        return Top10AgentsByRequestsResponse(topAgents=items)
+
+    @classmethod
+    def map_to_top_10_agents_by_tokens_response(cls, data: dict) -> Top10AgentsByTokensResponse:
+        items_data = data.get("topAgents", [])
+        items = [AgentByTokensItem.model_validate(item) for item in items_data]
+        return Top10AgentsByTokensResponse(topAgents=items)
+
+    @classmethod
+    def map_to_top_10_users_by_cost_response(cls, data: dict) -> Top10UsersByCostResponse:
+        items_data = data.get("topUsers", [])
+        items = [UserByCostItem.model_validate(item) for item in items_data]
+        return Top10UsersByCostResponse(topUsers=items)
+
+    @classmethod
+    def map_to_top_10_users_by_requests_response(cls, data: dict) -> Top10UsersByRequestsResponse:
+        items_data = data.get("topUsers", [])
+        items = [UserByRequestsItem.model_validate(item) for item in items_data]
+        return Top10UsersByRequestsResponse(topUsers=items)
+
+    @classmethod
+    def map_to_total_active_agents_response(cls, data: dict) -> TotalActiveAgentsResponse:
+        return TotalActiveAgentsResponse(totalActiveAgents=data.get("totalActiveAgents", 0))
+
+    @classmethod
+    def map_to_total_active_projects_response(cls, data: dict) -> TotalActiveProjectsResponse:
+        return TotalActiveProjectsResponse(totalActiveProjects=data.get("totalActiveProjects", 0))
+
+    @classmethod
+    def map_to_total_active_users_response(cls, data: dict) -> TotalActiveUsersResponse:
+        return TotalActiveUsersResponse(totalActiveUsers=data.get("totalActiveUsers", 0))
+
+    @classmethod
+    def map_to_total_cost_response(cls, data: dict) -> TotalCostResponse:
+        return TotalCostResponse(totalCost=data.get("totalCost", 0.0))
+
+    @classmethod
+    def map_to_total_cost_per_day_response(cls, data: dict) -> TotalCostPerDayResponse:
+        items_data = data.get("costPerDay", [])
+        items = [CostPerDayItem.model_validate(item) for item in items_data]
+        return TotalCostPerDayResponse(costPerDay=items)
+
+    @classmethod
+    def map_to_total_request_time_response(cls, data: dict) -> TotalRequestTimeResponse:
+        return TotalRequestTimeResponse(totalTime=data.get("totalTime", 0.0))
+
+    @classmethod
+    def map_to_total_requests_response(cls, data: dict) -> TotalRequestsResponse:
+        return TotalRequestsResponse(totalRequests=data.get("totalRequests", 0))
+
+    @classmethod
+    def map_to_total_requests_per_day_response(cls, data: dict) -> TotalRequestsPerDayResponse:
+        items_data = data.get("requestsPerDay", [])
+        items = [RequestsPerDayItem.model_validate(item) for item in items_data]
+        return TotalRequestsPerDayResponse(requestsPerDay=items)
+
+    @classmethod
+    def map_to_total_requests_with_error_response(cls, data: dict) -> TotalRequestsWithErrorResponse:
+        return TotalRequestsWithErrorResponse(totalRequestsWithError=data.get("totalRequestsWithError", 0))
+
+    @classmethod
+    def map_to_total_tokens_response(cls, data: dict) -> TotalTokensResponse:
+        return TotalTokensResponse(
+            totalInputTokens=data.get("totalInputTokens", 0),
+            totalOutputTokens=data.get("totalOutputTokens", 0),
+            totalTokens=data.get("totalTokens", 0)
+        )

pygeai/analytics/responses.py

@@ -0,0 +1,240 @@
+from pydantic.main import BaseModel
+from typing import Optional
+
+
+class AgentsCreatedAndModifiedResponse(BaseModel):
+    createdAgents: int
+    modifiedAgents: int
+
+
+class AgentActivityPerDayItem(BaseModel):
+    date: str
+    createdAgents: int
+    modifiedAgents: int
+
+
+class AgentsCreatedAndModifiedPerDayResponse(BaseModel):
+    agentsCreatedAndModifiedPerDay: list[AgentActivityPerDayItem]
+
+
+class FlowsCreatedAndModifiedResponse(BaseModel):
+    createdFlows: int
+    modifiedFlows: int
+
+
+class FlowActivityPerDayItem(BaseModel):
+    date: str
+    createdFlows: int
+    modifiedFlows: int
+
+
+class FlowsCreatedAndModifiedPerDayResponse(BaseModel):
+    flowsCreatedAndModifiedPerDay: list[FlowActivityPerDayItem]
+
+
+class ProcessesCreatedAndModifiedResponse(BaseModel):
+    createdProcesses: int
+    modifiedProcesses: int
+
+
+class AgentUsagePerUserItem(BaseModel):
+    userId: str
+    userName: Optional[str] = None
+    totalCost: float
+    totalRequests: int
+    totalTokens: int
+
+
+class AgentUsagePerUserResponse(BaseModel):
+    agentUsagePerUser: list[AgentUsagePerUserItem]
+
+
+class AverageCostPerRequestResponse(BaseModel):
+    averageCost: float
+
+
+class AverageCostPerUserResponse(BaseModel):
+    averageCost: float
+
+
+class CostPerUserPerDateItem(BaseModel):
+    date: str
+    userId: str
+    userName: Optional[str] = None
+    averageCost: float
+
+
+class AverageCostPerUserPerDateResponse(BaseModel):
+    averageCostPerUserPerDate: list[CostPerUserPerDateItem]
+
+
+class AverageRequestTimeResponse(BaseModel):
+    averageTime: float
+
+
+class AverageRequestsPerDayResponse(BaseModel):
+    averageRequests: float
+
+
+class AverageRequestsPerUserResponse(BaseModel):
+    averageRequests: float
+
+
+class RequestsPerUserPerDateItem(BaseModel):
+    date: str
+    userId: str
+    userName: Optional[str] = None
+    averageRequests: float
+
+
+class AverageRequestsPerUserPerDateResponse(BaseModel):
+    averageRequestsPerUserPerDate: list[RequestsPerUserPerDateItem]
+
+
+class AverageTokensPerRequestResponse(BaseModel):
+    averageInputTokens: float
+    averageOutputTokens: float
+    averageTotalTokens: float
+
+
+class UsersPerAgentItem(BaseModel):
+    agentName: str
+    averageUsers: float
+
+
+class AverageUsersPerAgentResponse(BaseModel):
+    averageUsersPerAgent: list[UsersPerAgentItem]
+
+
+class UsersPerProjectItem(BaseModel):
+    projectId: str
+    projectName: Optional[str] = None
+    averageUsers: float
+
+
+class AverageUsersPerProjectResponse(BaseModel):
+    averageUsersPerProject: list[UsersPerProjectItem]
+
+
+class NumberOfTokensResponse(BaseModel):
+    totalInputTokens: int
+    totalOutputTokens: int
+    totalTokens: int
+
+
+class TokensPerAgentItem(BaseModel):
+    agentName: str
+    model: str
+    inputTokens: int
+    outputTokens: int
+    totalTokens: int
+
+
+class NumberOfTokensPerAgentResponse(BaseModel):
+    tokensPerAgent: list[TokensPerAgentItem]
+
+
+class TokensPerDayItem(BaseModel):
+    date: str
+    inputTokens: int
+    outputTokens: int
+    totalTokens: int
+
+
+class NumberOfTokensPerDayResponse(BaseModel):
+    tokensPerDay: list[TokensPerDayItem]
+
+
+class OverallErrorRateResponse(BaseModel):
+    errorRate: float
+
+
+class AgentByRequestsItem(BaseModel):
+    agentName: str
+    totalRequests: int
+
+
+class Top10AgentsByRequestsResponse(BaseModel):
+    topAgents: list[AgentByRequestsItem]
+
+
+class AgentByTokensItem(BaseModel):
+    agentName: str
+    totalTokens: int
+
+
+class Top10AgentsByTokensResponse(BaseModel):
+    topAgents: list[AgentByTokensItem]
+
+
+class UserByCostItem(BaseModel):
+    userId: str
+    userName: Optional[str] = None
+    totalCost: float
+
+
+class Top10UsersByCostResponse(BaseModel):
+    topUsers: list[UserByCostItem]
+
+
+class UserByRequestsItem(BaseModel):
+    userId: str
+    userName: Optional[str] = None
+    totalRequests: int
+
+
+class Top10UsersByRequestsResponse(BaseModel):
+    topUsers: list[UserByRequestsItem]
+
+
+class TotalActiveAgentsResponse(BaseModel):
+    totalActiveAgents: int
+
+
+class TotalActiveProjectsResponse(BaseModel):
+    totalActiveProjects: int
+
+
+class TotalActiveUsersResponse(BaseModel):
+    totalActiveUsers: int
+
+
+class TotalCostResponse(BaseModel):
+    totalCost: float
+
+
+class CostPerDayItem(BaseModel):
+    date: str
+    totalCost: float
+
+
+class TotalCostPerDayResponse(BaseModel):
+    costPerDay: list[CostPerDayItem]
+
+
+class TotalRequestTimeResponse(BaseModel):
+    totalTime: float
+
+
+class TotalRequestsResponse(BaseModel):
+    totalRequests: int
+
+
+class RequestsPerDayItem(BaseModel):
+    date: str
+    totalRequests: int
+    totalRequestsWithError: int
+
+
+class TotalRequestsPerDayResponse(BaseModel):
+    requestsPerDay: list[RequestsPerDayItem]
+
+
+class TotalRequestsWithErrorResponse(BaseModel):
+    totalRequestsWithError: int
+
+
+class TotalTokensResponse(BaseModel):
+    totalInputTokens: int
+    totalOutputTokens: int
+    totalTokens: int

pygeai/assistant/clients.py

@@ -1,9 +1,13 @@
-import json
 
+from pygeai import logger
 from pygeai.assistant.endpoints import GET_ASSISTANT_DATA_V1, CREATE_ASSISTANT_V1, UPDATE_ASSISTANT_V1, BEGIN_CONVERSATION_V1, \
-    SEND_TEXT_PROMPT_V1, SEND_CHAT_REQUEST_V1, GET_REQUEST_STATUS_V1, CANCEL_REQUEST_V1, GET_DATA_ANALYST_STATUS_V1, \
-    EXTEND_DATA_ANALYST_DATASET_V1
+    SEND_TEXT_PROMPT_V1, SEND_CHAT_REQUEST_V1, GET_REQUEST_STATUS_V1, CANCEL_REQUEST_V1
+from pygeai.assistant.data_analyst.endpoints import GET_DATA_ANALYST_STATUS_V1, EXTEND_DATA_ANALYST_DATASET_V1
 from pygeai.core.base.clients import BaseClient
+from pygeai.core.common.decorators import handler_server_error
+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
 
 
 class AssistantClient(BaseClient):
@@ -27,8 +31,8 @@ class AssistantClient(BaseClient):
                 "detail": detail
             }
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "get assistant data for ID", assistant_id=assistant_id)
 
     def create_assistant(
             self,
@@ -68,19 +72,20 @@ class AssistantClient(BaseClient):
             } (Optional)
         :return: dict - The API response as a JSON object containing details about the created assistant.
         """
+        data = {
+            "type": assistant_type,
+            "name": name,
+            "prompt": prompt,
+            "description": description,
+            "llmSettings": llm_settings,
+            "welcomeData": welcome_data
+        }
         response = self.api_service.post(
             endpoint=CREATE_ASSISTANT_V1,
-            data={
-                "type": assistant_type,
-                "name": name,
-                "prompt": prompt,
-                "description": description,
-                "llmSettings": llm_settings,
-                "welcomeData": welcome_data
-            }
+            data=data
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "create assistant with name", name=name)
 
     def update_assistant(
             self,
@@ -152,8 +157,8 @@ class AssistantClient(BaseClient):
             endpoint=endpoint,
             data=data
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "update assistant", assistant_id=assistant_id)
 
     def delete_assistant(
             self,
@@ -169,15 +174,16 @@ class AssistantClient(BaseClient):
         response = self.api_service.delete(
             endpoint=endpoint
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "delete assistant", assistant_id=assistant_id)
 
     def send_chat_request(
             self,
-            assistant_name,
-            messages,
-            revision,
-            revision_name
+            assistant_name: str,
+            messages: list[dict],
+            revision: str = None,
+            revision_name: str = None,
+            variables: list[dict] = None
     ) -> dict:
         """
         Sends a chat request to the specified assistant.
@@ -189,17 +195,20 @@ class AssistantClient(BaseClient):
         :param revision_name: str - The name of the revision to be used for the chat request. (Required)
         :return: dict - The API response as a JSON object with the result of the chat request.
         """
+        data = {
+            "assistant": assistant_name,
+            "messages": messages,
+            "revision": revision,
+            "revisionName": revision_name,
+            "variables": variables
+        }
+
         response = self.api_service.post(
             endpoint=SEND_CHAT_REQUEST_V1,
-            data={
-                "assistant": assistant_name,
-                "messages": messages,
-                "revision": revision,
-                "revisionName": revision_name
-            }
+            data=data
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "send chat request to assistant", assistant_name=assistant_name)
 
     def get_request_status(
             self,
@@ -215,8 +224,8 @@ class AssistantClient(BaseClient):
         response = self.api_service.get(
             endpoint=endpoint
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "get request status for ID", request_id=request_id)
 
     def cancel_request(
             self,
@@ -230,31 +239,13 @@ class AssistantClient(BaseClient):
         """
         endpoint = CANCEL_REQUEST_V1.format(id=request_id)
         response = self.api_service.post(
-            endpoint=endpoint
-        )
-        result = json.loads(response.content)
-        return result
-
-    def get_data_analyst_status(
-            self,
-            assistant_id: str
-    ) -> dict:
-        endpoint = GET_DATA_ANALYST_STATUS_V1.format(id=assistant_id)
-        response = self.api_service.get(
-            endpoint=endpoint
+            endpoint=endpoint,
+            data={
+                "requestId": request_id
+            }
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "cancel request", request_id=request_id)
 
-    def extend_data_analyst_dataset(
-            self,
-            assistant_id: str
-    ) -> dict:
-        endpoint = EXTEND_DATA_ANALYST_DATASET_V1.format(id=assistant_id)
-        response = self.api_service.post(
-            endpoint=endpoint
-        )
-        result = json.loads(response.content)
-        return result
 
 

pygeai/assistant/data/clients.py

@@ -0,0 +1,15 @@
+import json
+
+from pygeai.assistant.clients import AssistantClient
+from pygeai.assistant.endpoints import GET_ASSISTANT_DATA_V1, CREATE_ASSISTANT_V1, UPDATE_ASSISTANT_V1, BEGIN_CONVERSATION_V1, \
+    SEND_TEXT_PROMPT_V1, SEND_CHAT_REQUEST_V1, GET_REQUEST_STATUS_V1, CANCEL_REQUEST_V1
+from pygeai.assistant.data_analyst.endpoints import GET_DATA_ANALYST_STATUS_V1, EXTEND_DATA_ANALYST_DATASET_V1
+from pygeai.core.base.clients import BaseClient
+from pygeai.core.common.decorators import handler_server_error
+from pygeai.core.utils.validators import validate_status_code
+
+
+class ChatWithDataAssistantClient(AssistantClient):
+    # TODO -> load_metadata(
+    pass
+