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

pygeai/organization/limits/clients.py

@@ -0,0 +1,281 @@
+
+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, \
+    GET_ALL_PROJECT_USAGE_LIMIT_V2, GET_LATEST_PROJECT_USAGE_LIMIT_V2, GET_PROJECT_ACTIVE_USAGE_LIMIT_V2, \
+    DELETE_PROJECT_USAGE_LIMIT_V2, SET_PROJECT_HARD_LIMIT_V2, SET_PROJECT_SOFT_LIMIT_V2, \
+    SET_PROJECT_RENEWAL_STATUS_V2
+
+
+class UsageLimitClient(BaseClient):
+
+    def set_organization_usage_limit(self, organization: str, usage_limit: dict) -> dict:
+        """
+        Defines a new usage limit for an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param usage_limit: dict - A dictionary containing the usage limit configuration. Example structure:
+            {
+                "subscriptionType": "Freemium" | "Daily" | "Weekly" | "Monthly",
+                "usageUnit": "Requests" | "Cost",
+                "softLimit": number,
+                "hardLimit": number,  # Must be greater than or equal to softLimit
+                "renewalStatus": "Renewable" | "NonRenewable"
+            } (Required)
+        :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)
+        response = self.api_service.post(
+            endpoint=endpoint,
+            data=usage_limit
+        )
+        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:
+        """
+        Retrieves the latest usage limit defined for a given organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :return: dict - The API response as a JSON object containing details of the latest usage limit.
+        """
+        endpoint = GET_ORGANIZATION_LATEST_USAGE_LIMIT_V2.format(organization=organization)
+        response = self.api_service.get(endpoint=endpoint)
+        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:
+        """
+        Retrieves all usage limits defined for a given organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :return: dict - The API response as a JSON object containing a list of all usage limits.
+        """
+        endpoint = GET_ALL_ORGANIZATION_USAGE_LIMITS_V2.format(organization=organization)
+        response = self.api_service.get(endpoint=endpoint)
+        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:
+        """
+        Deletes a specific usage limit from an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param limit_id: str - The unique identifier of the usage limit to be deleted. (Required)
+        :return: dict - The API response as a JSON object indicating the result of the delete operation.
+        """
+        endpoint = DELETE_ORGANIZATION_USAGE_LIMIT_V2.format(organization=organization, id=limit_id)
+        response = self.api_service.delete(endpoint=endpoint)
+        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:
+        """
+        Updates the hard limit for a specific usage limit in an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param limit_id: str - The unique identifier of the usage limit to be updated. (Required)
+        :param hard_limit: float - The new hard limit value. Must be greater than or equal to the soft limit. (Required)
+        :return: dict - The API response as a JSON object confirming the update.
+        """
+        endpoint = SET_ORGANIZATION_HARD_LIMIT_V2.format(organization=organization, id=limit_id)
+        response = self.api_service.put(
+            endpoint=endpoint,
+            data={
+                "hardLimit": hard_limit
+            }
+        )
+        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:
+        """
+        Updates the soft limit for a specific usage limit in an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param limit_id: str - The unique identifier of the usage limit to be updated. (Required)
+        :param soft_limit: float - The new soft limit value. Must be less than or equal to the hard limit. (Required)
+        :return: dict - The API response as a JSON object confirming the update.
+        """
+        endpoint = SET_ORGANIZATION_SOFT_LIMIT_V2.format(organization=organization, id=limit_id)
+        response = self.api_service.put(
+            endpoint=endpoint,
+            data={
+                "softLimit": soft_limit
+            }
+        )
+        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:
+        """
+        Updates the renewal status for a specific usage limit in an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param limit_id: str - The unique identifier of the usage limit to be updated. (Required)
+        :param renewal_status: str - The new renewal status. Must be either "Renewable" or "NonRenewable". (Required)
+        :return: dict - The API response as a JSON object confirming the update.
+        """
+        endpoint = SET_ORGANIZATION_RENEWAL_STATUS_V2.format(organization=organization, id=limit_id)
+        response = self.api_service.put(
+            endpoint=endpoint,
+            data={
+                "renewalStatus": renewal_status
+            }
+        )
+        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:
+        """
+        Defines a new usage limit for a specific project within an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param project: str - The unique identifier of the project. (Required)
+        :param usage_limit: dict - A dictionary containing usage limit details. Example structure:
+            {
+                "subscriptionType": "Freemium" | "Daily" | "Weekly" | "Monthly",
+                "usageUnit": "Requests" | "Cost",
+                "softLimit": float,
+                "hardLimit": float,
+                "renewalStatus": "Renewable" | "NonRenewable"
+            } (Required)
+        :return: dict - The API response as a JSON object containing details about the created project usage limit.
+        """
+        endpoint = SET_PROJECT_USAGE_LIMIT_V2.format(organization=organization, project=project)
+        response = self.api_service.post(
+            endpoint=endpoint,
+            data=usage_limit
+        )
+        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:
+        """
+        Retrieves all usage limits associated with a specific project within an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param project: str - The unique identifier of the project. (Required)
+        :return: dict - A JSON object containing details of all usage limits set for the specified project.
+        """
+        endpoint = GET_ALL_PROJECT_USAGE_LIMIT_V2.format(organization=organization, project=project)
+        response = self.api_service.get(endpoint=endpoint)
+        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:
+        """
+        Retrieves the most recent usage limit configured for a specific project within an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param project: str - The unique identifier of the project. (Required)
+        :return: dict - A JSON object containing details of the latest usage limit for the specified project.
+        """
+        endpoint = GET_LATEST_PROJECT_USAGE_LIMIT_V2.format(organization=organization, project=project)
+        response = self.api_service.get(endpoint=endpoint)
+        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:
+        """
+        Retrieves the currently active usage limit for a specific project within an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param project: str - The unique identifier of the project. (Required)
+        :return: dict - A JSON object containing details of the active usage limit for the specified project.
+        """
+        endpoint = GET_PROJECT_ACTIVE_USAGE_LIMIT_V2.format(organization=organization, project=project)
+        response = self.api_service.get(endpoint=endpoint)
+        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:
+        """
+        Deletes a specific usage limit for a given project within an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param project: str - The unique identifier of the project. (Required)
+        :param limit_id: str - The unique identifier of the usage limit to be deleted. (Required)
+        :return: dict - A JSON object containing the response of the delete operation.
+        """
+        endpoint = DELETE_PROJECT_USAGE_LIMIT_V2.format(organization=organization, project=project, id=limit_id)
+        response = self.api_service.delete(endpoint=endpoint)
+        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,
+            organization: str,
+            project: str,
+            limit_id: str,
+            hard_limit: float
+    ) -> dict:
+        """
+        Sets the hard limit for an active usage limit of a project within an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param project: str - The unique identifier of the project. (Required)
+        :param limit_id: str - The unique identifier of the usage limit. (Required)
+        :param hard_limit: float - The new hard limit value to be set. (Required)
+        :return: dict - A JSON object containing the response of the update operation.
+        """
+        endpoint = SET_PROJECT_HARD_LIMIT_V2.format(organization=organization, project=project, id=limit_id)
+        response = self.api_service.put(
+            endpoint=endpoint,
+            data={
+                "hardLimit": hard_limit
+            }
+        )
+        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,
+            organization: str,
+            project: str,
+            limit_id: str,
+            soft_limit: float
+    ) -> dict:
+        """
+        Sets the soft limit for an active usage limit of a project within an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param project: str - The unique identifier of the project. (Required)
+        :param limit_id: str - The unique identifier of the usage limit. (Required)
+        :param soft_limit: float - The new soft limit value to be set. (Required)
+        :return: dict - A JSON object containing the response of the update operation.
+        """
+        endpoint = SET_PROJECT_SOFT_LIMIT_V2.format(organization=organization, project=project, id=limit_id)
+        response = self.api_service.put(
+            endpoint=endpoint,
+            data={
+                "softLimit": soft_limit
+            }
+        )
+        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:
+        """
+        Updates the renewal status of a project's usage limit within an organization.
+
+        :param organization: str - The unique identifier of the organization. (Required)
+        :param project: str - The unique identifier of the project. (Required)
+        :param limit_id: str - The unique identifier of the usage limit. (Required)
+        :param renewal_status: str - The new renewal status to be set. Options: "Renewable", "NonRenewable". (Required)
+        :return: dict - A JSON object containing the response of the update operation.
+        """
+        endpoint = SET_PROJECT_RENEWAL_STATUS_V2.format(organization=organization, project=project, id=limit_id)
+        response = self.api_service.put(
+            endpoint=endpoint,
+            data={
+                "renewalStatus": renewal_status
+            }
+        )
+        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/endpoints.py

@@ -0,0 +1,15 @@
+SET_ORGANIZATION_USAGE_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/limits"	# POST -> Defines a new usage limit for an organization
+GET_ORGANIZATION_LATEST_USAGE_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/limits/latest"	 # GET -> Retrieves the latest usage limit defined for the organization
+GET_ALL_ORGANIZATION_USAGE_LIMITS_V2 = "v2/usageLimits/organizations/{organization}/limits"	# GET -> Retrieves all usage limits defined for the organization
+DELETE_ORGANIZATION_USAGE_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/limits/{id}"	# DELETE -> Deletes a usage limit for the organization
+SET_ORGANIZATION_HARD_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/limits/{id}/hardLimit"	# PUT -> Modifies the hardLimit of an active usage limit for the organization
+SET_ORGANIZATION_SOFT_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/limits/{id}/softLimit"	 # PUT -> Modifies the softLimit of an active usage limit for the organization
+SET_ORGANIZATION_RENEWAL_STATUS_V2 = "v2/usageLimits/organizations/{organization}/limits/{id}/renewalStatus"	 # PUT -> Modifies the renewalStatus of an active usage limit for the organization
+SET_PROJECT_USAGE_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/projects/{project}/limits"	 # POST -> Defines a new usage limit for a project
+GET_ALL_PROJECT_USAGE_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/projects/{project}/limits"	 # GET -> Retrieves all usage limits for a project
+GET_LATEST_PROJECT_USAGE_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/projects/{project}/limits/latest"	 # GET -> Retrieves the latest usage limit defined for a project
+GET_PROJECT_ACTIVE_USAGE_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/projects/{project}/limits/active"	 # GET -> Retrieves the active usage limit for a project
+DELETE_PROJECT_USAGE_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/projects/{project}/limits/{id}"    # DELETE -> Deletes an active usage limit for a project
+SET_PROJECT_HARD_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/projects/{project}/limits/{id}/hardLimit"  # PUT -> Modifies the hardLimit for an active usage limit for a project
+SET_PROJECT_SOFT_LIMIT_V2 = "v2/usageLimits/organizations/{organization}/projects/{project}/limits/{id}/softLimit"  # PUT -> Modifies the softLimit for an active usage limit for a project
+SET_PROJECT_RENEWAL_STATUS_V2 = "v2/usageLimits/organizations/{organization}/projects/{project}/limits/{id}/renewalStatus"  # PUT -> Modifies the renewalStatus for an active usage limit for a project

pygeai/organization/limits/managers.py

@@ -0,0 +1,331 @@
+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:
+    """
+    Manages usage limits for an organization and its projects.
+
+    This class provides methods to set, retrieve, update, and delete usage limits
+    at both the organization and project levels. It interacts with the `UsageLimitClient`
+    to perform API operations.
+
+    Attributes:
+        __client (UsageLimitClient): Client for making API requests.
+        __organization_id (str): The organization ID for which usage limits are managed.
+    """
+
+    def __init__(
+            self,
+            api_key: str = None,
+            base_url: str = None,
+            alias: str = None,
+            organization_id: str = None
+    ):
+        self.__client = UsageLimitClient(api_key, base_url, alias)
+        self.__organization_id = organization_id
+
+    def set_organization_usage_limit(self, usage_limit: UsageLimit) -> UsageLimit:
+        """
+        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 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 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.
+
+        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 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:
+            response_data = self.__client.set_organization_hard_limit(
+                organization=self.__organization_id,
+                limit_id=usage_limit.id,
+                hard_limit=usage_limit.hard_limit
+            )
+        if usage_limit.soft_limit:
+            response_data = self.__client.set_organization_soft_limit(
+                organization=self.__organization_id,
+                limit_id=usage_limit.id,
+                soft_limit=usage_limit.soft_limit
+            )
+        if usage_limit.renewal_status:
+            response_data = self.__client.set_organization_renewal_status(
+                organization=self.__organization_id,
+                limit_id=usage_limit.id,
+                renewal_status=usage_limit.renewal_status
+            )
+
+        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 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,
+            project=project_id,
+            usage_limit=usage_limit.to_dict()
+        )
+
+        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 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 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 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,
+            project=project_id,
+            limit_id=usage_limit.id
+        )
+
+        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:
+            response_data = self.__client.set_hard_limit_for_active_usage_limit_from_project(
+                organization=self.__organization_id,
+                project=project_id,
+                limit_id=usage_limit.id,
+                hard_limit=usage_limit.hard_limit
+            )
+        if usage_limit.soft_limit:
+            response_data = self.__client.set_soft_limit_for_active_usage_limit_from_project(
+                organization=self.__organization_id,
+                project=project_id,
+                limit_id=usage_limit.id,
+                soft_limit=usage_limit.soft_limit
+            )
+        if usage_limit.renewal_status:
+            response_data = self.__client.set_project_renewal_status(
+                organization=self.__organization_id,
+                project=project_id,
+                limit_id=usage_limit.id,
+                renewal_status=usage_limit.renewal_status
+            )
+
+        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

pygeai/organization/limits/mappers.py

@@ -0,0 +1,21 @@
+from pygeai.core.models import UsageLimit
+
+
+class UsageLimitMapper:
+
+    @classmethod
+    def map_to_usage_limit(cls, data: dict) -> UsageLimit:
+        return UsageLimit(
+            hard_limit=data.get('hardLimit'),
+            usage_limit_id=data.get('id'),
+            related_entity_name=data.get('relatedEntityName'),
+            remaining_usage=data.get('remainingUsage'),
+            renewal_status=data.get('renewalStatus'),
+            soft_limit=data.get('softLimit'),
+            status=data.get('status'),
+            subscription_type=data.get('subscriptionType'),
+            usage_unit=data.get('usageUnit'),
+            used_amount=data.get('usedAmount'),
+            valid_from=data.get('validFrom'),
+            valid_until=data.get('validUntil'),
+        )