pygeai 0.1.51b3__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,11 +1,13 @@
-import json
-from json import JSONDecodeError
 
+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
 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):
@@ -29,12 +31,8 @@ class AssistantClient(BaseClient):
                 "detail": detail
             }
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "get assistant data for ID", assistant_id=assistant_id)
 
     def create_assistant(
             self,
@@ -86,12 +84,8 @@ class AssistantClient(BaseClient):
             endpoint=CREATE_ASSISTANT_V1,
             data=data
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "create assistant with name", name=name)
 
     def update_assistant(
             self,
@@ -163,12 +157,8 @@ class AssistantClient(BaseClient):
             endpoint=endpoint,
             data=data
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "update assistant", assistant_id=assistant_id)
 
     def delete_assistant(
             self,
@@ -184,14 +174,9 @@ class AssistantClient(BaseClient):
         response = self.api_service.delete(
             endpoint=endpoint
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "delete assistant", assistant_id=assistant_id)
 
-    @handler_server_error
     def send_chat_request(
             self,
             assistant_name: str,
@@ -222,12 +207,8 @@ class AssistantClient(BaseClient):
             endpoint=SEND_CHAT_REQUEST_V1,
             data=data
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        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,
@@ -243,12 +224,8 @@ class AssistantClient(BaseClient):
         response = self.api_service.get(
             endpoint=endpoint
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "get request status for ID", request_id=request_id)
 
     def cancel_request(
             self,
@@ -267,12 +244,8 @@ class AssistantClient(BaseClient):
                 "requestId": request_id
             }
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "cancel request", request_id=request_id)
 
 
 

pygeai/assistant/data/clients.py

@@ -6,6 +6,7 @@ from pygeai.assistant.endpoints import GET_ASSISTANT_DATA_V1, CREATE_ASSISTANT_V
 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):

pygeai/assistant/data_analyst/clients.py

@@ -1,8 +1,11 @@
-from json import JSONDecodeError
 from pathlib import Path
 
+from pygeai import logger
 from pygeai.assistant.clients import AssistantClient
 from pygeai.assistant.data_analyst.endpoints import GET_DATA_ANALYST_STATUS_V1, EXTEND_DATA_ANALYST_DATASET_V1
+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 DataAnalystAssistantClient(AssistantClient):
@@ -32,12 +35,8 @@ class DataAnalystAssistantClient(AssistantClient):
             headers=headers
         )
 
-        try:
-            result = response.json()
-        except JSONDecodeError:
-            result = {"error": "Failed to parse JSON response", "response_text": response.text}
-
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "get status for assistant ID", assistant_id=assistant_id)
 
     def extend_dataset(
         self,
@@ -67,11 +66,8 @@ class DataAnalystAssistantClient(AssistantClient):
                 endpoint=endpoint,
                 files=files
             )
-            try:
-                result = response.json()
-            except JSONDecodeError as e:
-                result = response.text
-            return result
+            validate_status_code(response)
+            return parse_json_response(response, "extend dataset for assistant ID", assistant_id=assistant_id)
         finally:
             for _, file_handle in files:
                 file_handle.close()