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

pygeai/organization/limits/clients.py

@@ -1,6 +1,9 @@
-import json
 
+from pygeai import logger
 from pygeai.core.base.clients import BaseClient
+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.organization.limits.endpoints import SET_ORGANIZATION_USAGE_LIMIT_V2, GET_ORGANIZATION_LATEST_USAGE_LIMIT_V2, \
     GET_ALL_ORGANIZATION_USAGE_LIMITS_V2, DELETE_ORGANIZATION_USAGE_LIMIT_V2, SET_ORGANIZATION_HARD_LIMIT_V2, \
     SET_ORGANIZATION_SOFT_LIMIT_V2, SET_ORGANIZATION_RENEWAL_STATUS_V2, SET_PROJECT_USAGE_LIMIT_V2, \
@@ -27,13 +30,12 @@ class UsageLimitClient(BaseClient):
         :return: dict - The API response as a JSON object containing details about the created usage limit.
         """
         endpoint = SET_ORGANIZATION_USAGE_LIMIT_V2.format(organization=organization)
-        print(f"usage_limit: {usage_limit}")
         response = self.api_service.post(
             endpoint=endpoint,
             data=usage_limit
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"set usage limit for organization", organization=organization)
 
     def get_organization_latest_usage_limit(self, organization: str) -> dict:
         """
@@ -44,8 +46,8 @@ class UsageLimitClient(BaseClient):
         """
         endpoint = GET_ORGANIZATION_LATEST_USAGE_LIMIT_V2.format(organization=organization)
         response = self.api_service.get(endpoint=endpoint)
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"get latest usage limit for organization", organization=organization)
 
     def get_all_usage_limits_from_organization(self, organization: str) -> dict:
         """
@@ -56,8 +58,8 @@ class UsageLimitClient(BaseClient):
         """
         endpoint = GET_ALL_ORGANIZATION_USAGE_LIMITS_V2.format(organization=organization)
         response = self.api_service.get(endpoint=endpoint)
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"get all usage limits for organization", organization=organization)
 
     def delete_usage_limit_from_organization(self, organization: str, limit_id: str) -> dict:
         """
@@ -69,8 +71,8 @@ class UsageLimitClient(BaseClient):
         """
         endpoint = DELETE_ORGANIZATION_USAGE_LIMIT_V2.format(organization=organization, id=limit_id)
         response = self.api_service.delete(endpoint=endpoint)
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"delete usage limit with ID '{limit_id}' from organization", organization=organization)
 
     def set_organization_hard_limit(self, organization: str, limit_id: str, hard_limit: float) -> dict:
         """
@@ -88,8 +90,8 @@ class UsageLimitClient(BaseClient):
                 "hardLimit": hard_limit
             }
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"set hard limit for usage limit ID '{limit_id}' in organization", organization=organization)
 
     def set_organization_soft_limit(self, organization: str, limit_id: str, soft_limit: float) -> dict:
         """
@@ -107,8 +109,8 @@ class UsageLimitClient(BaseClient):
                 "softLimit": soft_limit
             }
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"set soft limit for usage limit ID '{limit_id}' in organization", organization=organization)
 
     def set_organization_renewal_status(self, organization: str, limit_id: str, renewal_status: str) -> dict:
         """
@@ -126,8 +128,8 @@ class UsageLimitClient(BaseClient):
                 "renewalStatus": renewal_status
             }
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"set renewal status for usage limit ID '{limit_id}' in organization", organization=organization)
 
     def set_project_usage_limit(self, organization: str, project: str, usage_limit: dict) -> dict:
         """
@@ -150,8 +152,8 @@ class UsageLimitClient(BaseClient):
             endpoint=endpoint,
             data=usage_limit
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"set usage limit for project '{project}' in organization", organization=organization)
 
     def get_all_usage_limits_from_project(self, organization: str, project: str) -> dict:
         """
@@ -163,8 +165,8 @@ class UsageLimitClient(BaseClient):
         """
         endpoint = GET_ALL_PROJECT_USAGE_LIMIT_V2.format(organization=organization, project=project)
         response = self.api_service.get(endpoint=endpoint)
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"get all usage limits for project '{project}' in organization", organization=organization)
 
     def get_latest_usage_limit_from_project(self, organization: str, project: str) -> dict:
         """
@@ -176,8 +178,8 @@ class UsageLimitClient(BaseClient):
         """
         endpoint = GET_LATEST_PROJECT_USAGE_LIMIT_V2.format(organization=organization, project=project)
         response = self.api_service.get(endpoint=endpoint)
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"get latest usage limit for project '{project}' in organization", organization=organization)
 
     def get_active_usage_limit_from_project(self, organization: str, project: str) -> dict:
         """
@@ -189,8 +191,8 @@ class UsageLimitClient(BaseClient):
         """
         endpoint = GET_PROJECT_ACTIVE_USAGE_LIMIT_V2.format(organization=organization, project=project)
         response = self.api_service.get(endpoint=endpoint)
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"get active usage limit for project '{project}' in organization", organization=organization)
 
     def delete_usage_limit_from_project(self, organization: str, project: str, limit_id: str) -> dict:
         """
@@ -203,8 +205,8 @@ class UsageLimitClient(BaseClient):
         """
         endpoint = DELETE_PROJECT_USAGE_LIMIT_V2.format(organization=organization, project=project, id=limit_id)
         response = self.api_service.delete(endpoint=endpoint)
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"delete usage limit with ID '{limit_id}' for project '{project}' in organization", organization=organization)
 
     def set_hard_limit_for_active_usage_limit_from_project(
             self,
@@ -229,8 +231,8 @@ class UsageLimitClient(BaseClient):
                 "hardLimit": hard_limit
             }
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"set hard limit for usage limit ID '{limit_id}' for project '{project}' in organization", organization=organization)
 
     def set_soft_limit_for_active_usage_limit_from_project(
             self,
@@ -255,8 +257,8 @@ class UsageLimitClient(BaseClient):
                 "softLimit": soft_limit
             }
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"set soft limit for usage limit ID '{limit_id}' for project '{project}' in organization", organization=organization)
 
     def set_project_renewal_status(self, organization: str, project: str, limit_id: str, renewal_status: str) -> dict:
         """
@@ -275,5 +277,5 @@ class UsageLimitClient(BaseClient):
                 "renewalStatus": renewal_status
             }
         )
-        result = json.loads(response.content)
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"set renewal status for usage limit ID '{limit_id}' for project '{project}' in organization", organization=organization)

pygeai/organization/limits/managers.py

@@ -1,6 +1,12 @@
+from pygeai import logger
 from pygeai.core.base.mappers import ErrorMapper, ModelMapper
 from pygeai.core.models import UsageLimit
 from pygeai.organization.limits.clients import UsageLimitClient
+from pygeai.core.handlers import ErrorHandler
+from pygeai.core.common.exceptions import APIError
+import logging
+
+
 
 
 class UsageLimitManager:
@@ -20,7 +26,7 @@ class UsageLimitManager:
             self,
             api_key: str = None,
             base_url: str = None,
-            alias: str = "default",
+            alias: str = None,
             organization_id: str = None
     ):
         self.__client = UsageLimitClient(api_key, base_url, alias)
@@ -30,61 +36,80 @@ class UsageLimitManager:
         """
         Sets a new usage limit for the organization.
 
+        This method sends a request to the usage limit client to set a new usage limit
+        for the specified organization.
+
         :param usage_limit: UsageLimit object containing the limit details.
         :return: UsageLimit object with the created usage limit details.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__client.set_organization_usage_limit(
             organization=self.__organization_id,
             usage_limit=usage_limit.to_dict()
         )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while setting organization usage limit: {error}")
+            raise APIError(f"Error received while setting organization usage limit: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
 
     def get_latest_usage_limit_from_organization(self) -> UsageLimit:
         """
         Retrieves the latest usage limit set for the organization.
 
+        This method queries the usage limit client to fetch the latest usage limit
+        for the specified organization.
+
         :return: UsageLimit object containing the latest usage limit details.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__client.get_organization_latest_usage_limit(
             organization=self.__organization_id
         )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving latest organization usage limit: {error}")
+            raise APIError(f"Error received while retrieving latest organization usage limit: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
 
     def get_all_usage_limits_from_organization(self) -> list[UsageLimit]:
         """
         Retrieves all usage limits associated with the organization.
 
-        :return: UsageLimit object containing all usage limits for the organization.
+        This method queries the usage limit client to fetch all usage limits
+        for the specified organization.
+
+        :return: list[UsageLimit] - A list of UsageLimit objects containing all usage limits for the organization.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__client.get_all_usage_limits_from_organization(
             organization=self.__organization_id
         )
-        
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit_list(response_data)
 
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving all organization usage limits: {error}")
+            raise APIError(f"Error received while retrieving all organization usage limits: {error}")
+
+        result = ModelMapper.map_to_usage_limit_list(response_data)
         return result
 
     def update_organization_usage_limit(self, usage_limit: UsageLimit) -> UsageLimit:
         """
         Updates the usage limits for an organization, including hard limit, soft limit, and renewal status.
 
+        This method sends requests to the usage limit client to update specific attributes
+        of the usage limit for the specified organization.
+
         :param usage_limit: UsageLimit object containing the updated limit values.
         :return: UsageLimit object with updated usage limit details.
+        :raises APIError: If the API returns errors.
         """
         response_data = {}
         if usage_limit.hard_limit:
@@ -106,39 +131,49 @@ class UsageLimitManager:
                 renewal_status=usage_limit.renewal_status
             )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while updating organization usage limit: {error}")
+            raise APIError(f"Error received while updating organization usage limit: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
 
     def delete_usage_limit_from_organization(self, limit_id: str) -> UsageLimit:
         """
         Deletes a usage limit from the organization.
 
+        This method sends a request to the usage limit client to delete a usage limit
+        identified by `limit_id` for the specified organization.
+
         :param limit_id: The ID of the usage limit to be deleted.
         :return: UsageLimit object representing the deleted limit details.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__client.delete_usage_limit_from_organization(
             organization=self.__organization_id,
             limit_id=limit_id,
         )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while deleting organization usage limit: {error}")
+            raise APIError(f"Error received while deleting organization usage limit: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
 
     def set_project_usage_limit(self, project_id: str, usage_limit: UsageLimit) -> UsageLimit:
         """
         Sets a new usage limit for a specific project within the organization.
 
+        This method sends a request to the usage limit client to set a new usage limit
+        for the specified project.
+
         :param project_id: The unique identifier of the project.
         :param usage_limit: UsageLimit object containing the limit details.
         :return: UsageLimit object with the created project usage limit details.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__client.set_project_usage_limit(
             organization=self.__organization_id,
@@ -146,77 +181,97 @@ class UsageLimitManager:
             usage_limit=usage_limit.to_dict()
         )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while setting project usage limit: {error}")
+            raise APIError(f"Error received while setting project usage limit: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
 
     def get_all_usage_limits_from_project(self, project_id: str) -> UsageLimit:
         """
         Retrieves all usage limits associated with a specific project.
 
+        This method queries the usage limit client to fetch all usage limits
+        for the specified project.
+
         :param project_id: The unique identifier of the project.
         :return: UsageLimit object containing all usage limits for the project.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__client.get_all_usage_limits_from_project(
             organization=self.__organization_id,
             project=project_id,
         )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving all project usage limits: {error}")
+            raise APIError(f"Error received while retrieving all project usage limits: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
 
     def get_latest_usage_limit_from_project(self, project_id: str) -> UsageLimit:
         """
         Retrieves the latest usage limit set for a specific project.
 
+        This method queries the usage limit client to fetch the latest usage limit
+        for the specified project.
+
         :param project_id: The unique identifier of the project.
         :return: UsageLimit object containing the latest usage limit details.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__client.get_latest_usage_limit_from_project(
             organization=self.__organization_id,
             project=project_id,
         )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving latest project usage limit: {error}")
+            raise APIError(f"Error received while retrieving latest project usage limit: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
 
     def get_active_usage_limit_from_project(self, project_id: str) -> UsageLimit:
         """
         Retrieves the currently active usage limit for a specific project.
 
+        This method queries the usage limit client to fetch the active usage limit
+        for the specified project.
+
         :param project_id: The unique identifier of the project.
         :return: UsageLimit object containing the active usage limit details.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__client.get_active_usage_limit_from_project(
             organization=self.__organization_id,
             project=project_id,
         )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving active project usage limit: {error}")
+            raise APIError(f"Error received while retrieving active project usage limit: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
 
     def delete_usage_limit_from_project(self, project_id: str, usage_limit: UsageLimit) -> UsageLimit:
         """
         Deletes a specified usage limit from a project.
 
+        This method sends a request to the usage limit client to delete a usage limit
+        identified by `usage_limit.id` for the specified project.
+
         :param project_id: The unique identifier of the project.
         :param usage_limit: The UsageLimit object representing the limit to be deleted.
         :return: UsageLimit object representing the deleted usage limit details.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__client.delete_usage_limit_from_project(
             organization=self.__organization_id,
@@ -224,20 +279,25 @@ class UsageLimitManager:
             limit_id=usage_limit.id
         )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while deleting project usage limit: {error}")
+            raise APIError(f"Error received while deleting project usage limit: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
 
     def update_project_usage_limit(self, project_id: str, usage_limit: UsageLimit) -> UsageLimit:
         """
         Updates the usage limits for a specific project, including hard limit, soft limit, and renewal status.
 
+        This method sends requests to the usage limit client to update specific attributes
+        of the usage limit for the specified project.
+
         :param project_id: The unique identifier of the project.
         :param usage_limit: UsageLimit object containing the updated limit values.
         :return: UsageLimit object with updated usage limit details.
+        :raises APIError: If the API returns errors.
         """
         response_data = {}
         if usage_limit.hard_limit:
@@ -262,11 +322,10 @@ class UsageLimitManager:
                 renewal_status=usage_limit.renewal_status
             )
 
-        if "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = ModelMapper.map_to_usage_limit(response_data)
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while updating project usage limit: {error}")
+            raise APIError(f"Error received while updating project usage limit: {error}")
 
+        result = ModelMapper.map_to_usage_limit(response_data)
         return result
-
-