lionagi 0.0.306__py3-none-any.whl → 0.0.308__py3-none-any.whl

lionagi/libs/ln_api.py

@@ -29,26 +29,27 @@ class APIUtil:
         Returns the corresponding HTTP method function from the http_session object.
 
         Args:
-            http_session: The session object from the aiohttp library.
-            method: The HTTP method as a string.
+                http_session: The session object from the aiohttp library.
+                method: The HTTP method as a string.
 
         Returns:
-            The Callable for the specified HTTP method.
+                The Callable for the specified HTTP method.
 
         Raises:
-            ValueError: If the method is not one of the allowed ones.
+                ValueError: If the method is not one of the allowed ones.
 
         Examples:
-            >>> session = aiohttp.ClientSession()
-            >>> post_method = APIUtil.api_method(session, "post")
-            >>> print(post_method)
-            <bound method ClientSession._request of <aiohttp.client.ClientSession object at 0x...>>
+                >>> session = aiohttp.ClientSession()
+                >>> post_method = APIUtil.api_method(session, "post")
+                >>> print(post_method)
+                <bound method ClientSession._request of <aiohttp.client.ClientSession object at 0x...>>
         """
-        if method not in ["post", "delete", "head", "options", "patch"]:
+        if method in {"post", "delete", "head", "options", "patch"}:
+            return getattr(http_session, method)
+        else:
             raise ValueError(
                 "Invalid request, method must be in ['post', 'delete', 'head', 'options', 'patch']"
             )
-        return getattr(http_session, method)
 
     @staticmethod
     def api_error(response_json: Mapping[str, Any]) -> bool:
@@ -56,18 +57,18 @@ class APIUtil:
         Checks if the given response_json dictionary contains an "error" key.
 
         Args:
-            response_json: The JSON assistant_response as a dictionary.
+                response_json: The JSON assistant_response as a dictionary.
 
         Returns:
-            True if there is an error, False otherwise.
+                True if there is an error, False otherwise.
 
         Examples:
-            >>> response_json_with_error = {"error": "Something went wrong"}
-            >>> APIUtil.api_error(response_json_with_error)
-            True
-            >>> response_json_without_error = {"result": "Success"}
-            >>> APIUtil.api_error(response_json_without_error)
-            False
+                >>> response_json_with_error = {"error": "Something went wrong"}
+                >>> APIUtil.api_error(response_json_with_error)
+                True
+                >>> response_json_without_error = {"result": "Success"}
+                >>> APIUtil.api_error(response_json_without_error)
+                False
         """
         if "error" in response_json:
             logging.warning(f"API call failed with error: {response_json['error']}")
@@ -80,18 +81,18 @@ class APIUtil:
         Checks if the error message in the response_json dictionary contains the phrase "Rate limit".
 
         Args:
-            response_json: The JSON assistant_response as a dictionary.
+                response_json: The JSON assistant_response as a dictionary.
 
         Returns:
-            True if the phrase "Rate limit" is found, False otherwise.
+                True if the phrase "Rate limit" is found, False otherwise.
 
         Examples:
-            >>> response_json_with_rate_limit = {"error": {"message": "Rate limit exceeded"}}
-            >>> api_rate_limit_error(response_json_with_rate_limit)
-            True
-            >>> response_json_without_rate_limit = {"error": {"message": "Another error"}}
-            >>> api_rate_limit_error(response_json_without_rate_limit)
-            False
+                >>> response_json_with_rate_limit = {"error": {"message": "Rate limit exceeded"}}
+                >>> api_rate_limit_error(response_json_with_rate_limit)
+                True
+                >>> response_json_without_rate_limit = {"error": {"message": "Another error"}}
+                >>> api_rate_limit_error(response_json_without_rate_limit)
+                False
         """
         return "Rate limit" in response_json.get("error", {}).get("message", "")
 
@@ -102,21 +103,21 @@ class APIUtil:
         Extracts the API endpoint from a given URL using a regular expression.
 
         Args:
-            request_url: The full URL to the API endpoint.
+                request_url: The full URL to the API endpoint.
 
         Returns:
-            The extracted endpoint or an empty string if the pattern does not match.
+                The extracted endpoint or an empty string if the pattern does not match.
 
         Examples:
-            >>> valid_url = "https://api.example.com/v1/users"
-            >>> api_endpoint_from_url(valid_url)
-            'users'
-            >>> invalid_url = "https://api.example.com/users"
-            >>> api_endpoint_from_url(invalid_url)
-            ''
+                >>> valid_url = "https://api.example.com/v1/users"
+                >>> api_endpoint_from_url(valid_url)
+                'users'
+                >>> invalid_url = "https://api.example.com/users"
+                >>> api_endpoint_from_url(invalid_url)
+                ''
         """
         match = re.search(r"^https://[^/]+(/.+)?/v\d+/(.+)$", request_url)
-        return match.group(2) if match else ""
+        return match[2] if match else ""
 
     @staticmethod
     async def unified_api_call(
@@ -126,22 +127,22 @@ class APIUtil:
         Makes an API call and automatically retries on rate limit error.
 
         Args:
-            http_session: The session object from the aiohttp library.
-            method: The HTTP method as a string.
-            url: The URL to which the request is made.
-            **kwargs: Additional keyword arguments to pass to the API call.
+                http_session: The session object from the aiohttp library.
+                method: The HTTP method as a string.
+                url: The URL to which the request is made.
+                **kwargs: Additional keyword arguments to pass to the API call.
 
         Returns:
-            The JSON assistant_response as a dictionary.
+                The JSON assistant_response as a dictionary.
 
         Examples:
-            >>> session = aiohttp.ClientSession()
-            >>> success_url = "https://api.example.com/v1/success"
-            >>> print(await unified_api_call(session, 'get', success_url))
-            {'result': 'Success'}
-            >>> rate_limit_url = "https://api.example.com/v1/rate_limit"
-            >>> print(await unified_api_call(session, 'get', rate_limit_url))
-            {'error': {'message': 'Rate limit exceeded'}}
+                >>> session = aiohttp.ClientSession()
+                >>> success_url = "https://api.example.com/v1/success"
+                >>> print(await unified_api_call(session, 'get', success_url))
+                {'result': 'Success'}
+                >>> rate_limit_url = "https://api.example.com/v1/rate_limit"
+                >>> print(await unified_api_call(session, 'get', rate_limit_url))
+                {'error': {'message': 'Rate limit exceeded'}}
         """
         api_call = APIUtil.api_method(http_session, method)
         retry_count = 3
@@ -189,14 +190,14 @@ class APIUtil:
         Retries an API call on failure, with exponential backoff.
 
         Args:
-            http_session: The aiohttp client session.
-            url: The URL to make the API call.
-            retries: The number of times to retry.
-            backoff_factor: The backoff factor for retries.
-            **kwargs: Additional arguments for the API call.
+                http_session: The aiohttp client session.
+                url: The URL to make the API call.
+                retries: The number of times to retry.
+                backoff_factor: The backoff factor for retries.
+                **kwargs: Additional arguments for the API call.
 
         Returns:
-            The assistant_response from the API call, if successful; otherwise, None.
+                The assistant_response from the API call, if successful; otherwise, None.
         """
         for attempt in range(retries):
             try:
@@ -227,27 +228,27 @@ class APIUtil:
         Uploads a file to a specified URL with a retry mechanism for handling failures.
 
         Args:
-            http_session: The HTTP session object to use for making the request.
-            url: The URL to which the file will be uploaded.
-            file_path: The path to the file that will be uploaded.
-            param_name: The name of the parameter expected by the server for the file upload.
-            additional_data: Additional data to be sent with the upload.
-            retries: The number of times to retry the upload in case of failure.
+                http_session: The HTTP session object to use for making the request.
+                url: The URL to which the file will be uploaded.
+                file_path: The path to the file that will be uploaded.
+                param_name: The name of the parameter expected by the server for the file upload.
+                additional_data: Additional data to be sent with the upload.
+                retries: The number of times to retry the upload in case of failure.
 
         Returns:
-            The HTTP assistant_response object.
+                The HTTP assistant_response object.
 
         Examples:
-            >>> session = aiohttp.ClientSession()
-            >>> assistant_response = await APIUtil.upload_file_with_retry(session, 'http://example.com/upload', 'path/to/file.txt')
-            >>> assistant_response.status
-            200
+                >>> session = aiohttp.ClientSession()
+                >>> assistant_response = await APIUtil.upload_file_with_retry(session, 'http://example.com/upload', 'path/to/file.txt')
+                >>> assistant_response.status
+                200
         """
         for attempt in range(retries):
             try:
                 with open(file_path, "rb") as file:
                     files = {param_name: file}
-                    additional_data = additional_data if additional_data else {}
+                    additional_data = additional_data or {}
                     async with http_session.post(
                         url, data={**files, **additional_data}
                     ) as response:
@@ -273,20 +274,20 @@ class APIUtil:
         Retrieves an OAuth token from the authentication server and caches it to avoid unnecessary requests.
 
         Args:
-            http_session: The HTTP session object to use for making the request.
-            auth_url: The URL of the authentication server.
-            client_id: The client ID for OAuth authentication.
-            client_secret: The client secret for OAuth authentication.
-            scope: The scope for which the OAuth token is requested.
+                http_session: The HTTP session object to use for making the request.
+                auth_url: The URL of the authentication server.
+                client_id: The client ID for OAuth authentication.
+                client_secret: The client secret for OAuth authentication.
+                scope: The scope for which the OAuth token is requested.
 
         Returns:
-            The OAuth token as a string.
+                The OAuth token as a string.
 
         Examples:
-            >>> session = aiohttp.ClientSession()
-            >>> token = await APIUtil.get_oauth_token_with_cache(session, 'http://auth.example.com', 'client_id', 'client_secret', 'read')
-            >>> token
-            'mock_access_token'
+                >>> session = aiohttp.ClientSession()
+                >>> token = await APIUtil.get_oauth_token_with_cache(session, 'http://auth.example.com', 'client_id', 'client_secret', 'read')
+                >>> token
+                'mock_access_token'
         """
         async with http_session.post(
             auth_url,
@@ -309,12 +310,12 @@ class APIUtil:
         Makes an API call.
 
         Args:
-            http_session: The aiohttp client session.
-            url: The URL for the API call.
-            **kwargs: Additional arguments for the API call.
+                http_session: The aiohttp client session.
+                url: The URL for the API call.
+                **kwargs: Additional arguments for the API call.
 
         Returns:
-            The assistant_response from the API call, if successful; otherwise, None.
+                The assistant_response from the API call, if successful; otherwise, None.
         """
         try:
             async with http_session.get(url, **kwargs) as response:
@@ -325,12 +326,11 @@ class APIUtil:
             return None
 
     @staticmethod
-    # @lru_cache(maxsize=1024)
     def calculate_num_token(
         payload: Mapping[str, Any] = None,
         api_endpoint: str = None,
         token_encoding_name: str = None,
-    ) -> int:
+    ) -> int:  # sourcery skip: avoid-builtin-shadow
         """
         Calculates the number of tokens required for a request based on the payload and API endpoint.
 
@@ -339,20 +339,20 @@ class APIUtil:
         for the OpenAI API.
 
         Parameters:
-            payload (Mapping[str, Any]): The payload of the request.
+                payload (Mapping[str, Any]): The payload of the request.
 
-            api_endpoint (str): The specific API endpoint for the request.
+                api_endpoint (str): The specific API endpoint for the request.
 
-            token_encoding_name (str): The name of the token encoding method.
+                token_encoding_name (str): The name of the token encoding method.
 
         Returns:
-            int: The estimated number of tokens required for the request.
+                int: The estimated number of tokens required for the request.
 
         Example:
-            >>> rate_limiter = OpenAIRateLimiter(100, 200)
-            >>> payload = {'prompt': 'Translate the following text:', 'max_tokens': 50}
-            >>> rate_limiter.calculate_num_token(payload, 'completions')
-            # Expected token calculation for the given payload and endpoint.
+                >>> rate_limiter = OpenAIRateLimiter(100, 200)
+                >>> payload = {'prompt': 'Translate the following text:', 'max_tokens': 50}
+                >>> rate_limiter.calculate_num_token(payload, 'completions')
+                # Expected token calculation for the given payload and endpoint.
         """
         import tiktoken
 
@@ -371,21 +371,19 @@ class APIUtil:
                         num_tokens += len(encoding.encode(value))
                         if key == "name":  # if there's a name, the role is omitted
                             num_tokens -= (
-                                1  # role is always required and always 1 token
+                                1
+                                # role is always required and always 1 token
                             )
                 num_tokens += 2  # every reply is primed with <im_start>assistant
                 return num_tokens + completion_tokens
-            # normal completions
             else:
                 prompt = payload["prompt"]
                 if isinstance(prompt, str):  # single prompt
                     prompt_tokens = len(encoding.encode(prompt))
-                    num_tokens = prompt_tokens + completion_tokens
-                    return num_tokens
+                    return prompt_tokens + completion_tokens
                 elif isinstance(prompt, list):  # multiple prompts
-                    prompt_tokens = sum([len(encoding.encode(p)) for p in prompt])
-                    num_tokens = prompt_tokens + completion_tokens * len(prompt)
-                    return num_tokens
+                    prompt_tokens = sum(len(encoding.encode(p)) for p in prompt)
+                    return prompt_tokens + completion_tokens * len(prompt)
                 else:
                     raise TypeError(
                         'Expecting either string or list of strings for "prompt" field in completion request'
@@ -393,11 +391,9 @@ class APIUtil:
         elif api_endpoint == "embeddings":
             input = payload["input"]
             if isinstance(input, str):  # single input
-                num_tokens = len(encoding.encode(input))
-                return num_tokens
+                return len(encoding.encode(input))
             elif isinstance(input, list):  # multiple inputs
-                num_tokens = sum([len(encoding.encode(i)) for i in input])
-                return num_tokens
+                return sum(len(encoding.encode(i)) for i in input)
             else:
                 raise TypeError(
                     'Expecting either string or list of strings for "inputs" field in embedding request'
@@ -413,11 +409,11 @@ class APIUtil:
         payload = {input_key: input_}
 
         for key in required_:
-            payload.update({key: config[key]})
+            payload[key] = config[key]
 
         for key in optional_:
-            if bool(config[key]) is True and convert.strip_lower(config[key]) != "none":
-                payload.update({key: config[key]})
+            if bool(config[key]) and convert.strip_lower(config[key]) != "none":
+                payload[key] = config[key]
 
         return payload
 
@@ -428,18 +424,18 @@ class StatusTracker:
     Keeps track of various task statuses within a system.
 
     Attributes:
-        num_tasks_started (int): The number of tasks that have been initiated.
-        num_tasks_in_progress (int): The number of tasks currently being processed.
-        num_tasks_succeeded (int): The number of tasks that have completed successfully.
-        num_tasks_failed (int): The number of tasks that have failed.
-        num_rate_limit_errors (int): The number of tasks that failed due to rate limiting.
-        num_api_errors (int): The number of tasks that failed due to API errors.
-        num_other_errors (int): The number of tasks that failed due to other errors.
+            num_tasks_started (int): The number of tasks that have been initiated.
+            num_tasks_in_progress (int): The number of tasks currently being processed.
+            num_tasks_succeeded (int): The number of tasks that have completed successfully.
+            num_tasks_failed (int): The number of tasks that have failed.
+            num_rate_limit_errors (int): The number of tasks that failed due to rate limiting.
+            num_api_errors (int): The number of tasks that failed due to API errors.
+            num_other_errors (int): The number of tasks that failed due to other errors.
 
     Examples:
-        >>> tracker = StatusTracker()
-        >>> tracker.num_tasks_started += 1
-        >>> tracker.num_tasks_succeeded += 1
+            >>> tracker = StatusTracker()
+            >>> tracker.num_tasks_started += 1
+            >>> tracker.num_tasks_succeeded += 1
     """
 
     num_tasks_started: int = 0
@@ -459,12 +455,12 @@ class BaseRateLimiter(ABC):
     the replenishment of request and token capacities at regular intervals.
 
     Attributes:
-        interval: The time interval in seconds for replenishing capacities.
-        max_requests: The maximum number of requests allowed per interval.
-        max_tokens: The maximum number of tokens allowed per interval.
-        available_request_capacity: The current available request capacity.
-        available_token_capacity: The current available token capacity.
-        rate_limit_replenisher_task: The asyncio task for replenishing capacities.
+            interval: The time interval in seconds for replenishing capacities.
+            max_requests: The maximum number of requests allowed per interval.
+            max_tokens: The maximum number of tokens allowed per interval.
+            available_request_capacity: The current available request capacity.
+            available_token_capacity: The current available token capacity.
+            rate_limit_replenisher_task: The asyncio task for replenishing capacities.
     """
 
     def __init__(
@@ -516,7 +512,8 @@ class BaseRateLimiter(ABC):
             ):
                 self.available_request_capacity -= 1
                 self.available_token_capacity -= (
-                    required_tokens  # Assuming 1 token per request for simplicity
+                    required_tokens
+                    # Assuming 1 token per request for simplicity
                 )
                 return True
             return False
@@ -536,16 +533,16 @@ class BaseRateLimiter(ABC):
         Makes an API call to the specified endpoint using the provided HTTP session.
 
         Args:
-            http_session: The aiohttp client session to use for the API call.
-            endpoint: The API endpoint to call.
-            base_url: The base URL of the API.
-            api_key: The API key for authentication.
-            max_attempts: The maximum number of attempts for the API call.
-            method: The HTTP method to use for the API call.
-            payload: The payload to send with the API call.
+                http_session: The aiohttp client session to use for the API call.
+                endpoint: The API endpoint to call.
+                base_url: The base URL of the API.
+                api_key: The API key for authentication.
+                max_attempts: The maximum number of attempts for the API call.
+                method: The HTTP method to use for the API call.
+                payload: The payload to send with the API call.
 
         Returns:
-            The JSON assistant_response from the API call if successful, otherwise None.
+                The JSON assistant_response from the API call if successful, otherwise None.
         """
         endpoint = APIUtil.api_endpoint_from_url(base_url + endpoint)
         while True:
@@ -573,18 +570,17 @@ class BaseRateLimiter(ABC):
                         ) as response:
                             response_json = await response.json()
 
-                            if "error" in response_json:
-                                logging.warning(
-                                    f"API call failed with error: {response_json['error']}"
-                                )
-                                attempts_left -= 1
-
-                                if "Rate limit" in response_json["error"].get(
-                                    "message", ""
-                                ):
-                                    await AsyncUtil.sleep(15)
-                            else:
+                            if "error" not in response_json:
                                 return response_json
+                            logging.warning(
+                                f"API call failed with error: {response_json['error']}"
+                            )
+                            attempts_left -= 1
+
+                            if "Rate limit" in response_json["error"].get(
+                                "message", ""
+                            ):
+                                await AsyncUtil.sleep(15)
                     except Exception as e:
                         logging.warning(f"API call failed with exception: {e}")
                         attempts_left -= 1
@@ -606,13 +602,13 @@ class BaseRateLimiter(ABC):
         Creates an instance of BaseRateLimiter and starts the replenisher task.
 
         Args:
-            max_requests: The maximum number of requests allowed per interval.
-            max_tokens: The maximum number of tokens allowed per interval.
-            interval: The time interval in seconds for replenishing capacities.
-            token_encoding_name: The name of the token encoding to use.
+                max_requests: The maximum number of requests allowed per interval.
+                max_tokens: The maximum number of tokens allowed per interval.
+                interval: The time interval in seconds for replenishing capacities.
+                token_encoding_name: The name of the token encoding to use.
 
         Returns:
-            An instance of BaseRateLimiter with the replenisher task started.
+                An instance of BaseRateLimiter with the replenisher task started.
         """
         instance = cls(max_requests, max_tokens, interval, token_encoding_name)
         instance.rate_limit_replenisher_task = AsyncUtil.create_task(
@@ -646,25 +642,25 @@ class EndPoint:
     This class encapsulates the details of an API endpoint, including its rate limiter.
 
     Attributes:
-        endpoint (str): The API endpoint path.
-        rate_limiter_class (Type[li.BaseRateLimiter]): The class used for rate limiting requests to the endpoint.
-        max_requests (int): The maximum number of requests allowed per interval.
-        max_tokens (int): The maximum number of tokens allowed per interval.
-        interval (int): The time interval in seconds for replenishing rate limit capacities.
-        config (Mapping): Configuration parameters for the endpoint.
-        rate_limiter (Optional[li.BaseRateLimiter]): The rate limiter instance for this endpoint.
+            endpoint (str): The API endpoint path.
+            rate_limiter_class (Type[li.BaseRateLimiter]): The class used for rate limiting requests to the endpoint.
+            max_requests (int): The maximum number of requests allowed per interval.
+            max_tokens (int): The maximum number of tokens allowed per interval.
+            interval (int): The time interval in seconds for replenishing rate limit capacities.
+            config (Mapping): Configuration parameters for the endpoint.
+            rate_limiter (Optional[li.BaseRateLimiter]): The rate limiter instance for this endpoint.
 
     Examples:
-        # Example usage of EndPoint with SimpleRateLimiter
-        endpoint = EndPoint(
-            max_requests=100,
-            max_tokens=1000,
-            interval=60,
-            endpoint_='chat/completions',
-            rate_limiter_class=li.SimpleRateLimiter,
-            config={'param1': 'value1'}
-        )
-        asyncio.run(endpoint.init_rate_limiter())
+            # Example usage of EndPoint with SimpleRateLimiter
+            endpoint = EndPoint(
+                    max_requests=100,
+                    max_tokens=1000,
+                    interval=60,
+                    endpoint_='chat/completions',
+                    rate_limiter_class=li.SimpleRateLimiter,
+                    config={'param1': 'value1'}
+            )
+            asyncio.run(endpoint.init_rate_limiter())
     """
 
     def __init__(
@@ -702,10 +698,10 @@ class BaseService:
     This class provides a foundation for services that need to make API calls with rate limiting.
 
     Attributes:
-        api_key (Optional[str]): The API key used for authentication.
-        schema (Mapping[str, Any]): The schema defining the service's endpoints.
-        status_tracker (StatusTracker): The object tracking the status of API calls.
-        endpoints (Mapping[str, EndPoint]): A dictionary of endpoint objects.
+            api_key (Optional[str]): The API key used for authentication.
+            schema (Mapping[str, Any]): The schema defining the service's endpoints.
+            status_tracker (StatusTracker): The object tracking the status of API calls.
+            endpoints (Mapping[str, EndPoint]): A dictionary of endpoint objects.
     """
 
     base_url: str = ""
@@ -739,7 +735,7 @@ class BaseService:
         Initializes the specified endpoint or all endpoints if none is specified.
 
         Args:
-            endpoint_: The endpoint(s) to initialize. Can be a string, an EndPoint, a list of strings, or a list of EndPoints.
+                endpoint_: The endpoint(s) to initialize. Can be a string, an EndPoint, a list of strings, or a list of EndPoints.
         """
 
         if endpoint_:
@@ -756,45 +752,40 @@ class BaseService:
                     self.schema.get(ep, {})
                     if isinstance(ep, EndPoint):
                         self.endpoints[ep.endpoint] = ep
+                    elif ep == "chat/completions":
+                        self.endpoints[ep] = EndPoint(
+                            max_requests=self.chat_config_rate_limit.get(
+                                "max_requests", 1000
+                            ),
+                            max_tokens=self.chat_config_rate_limit.get(
+                                "max_tokens", 100000
+                            ),
+                            interval=self.chat_config_rate_limit.get("interval", 60),
+                            endpoint_=ep,
+                            token_encoding_name=self.token_encoding_name,
+                            config=endpoint_config,
+                        )
                     else:
-                        if ep == "chat/completions":
-                            self.endpoints[ep] = EndPoint(
-                                max_requests=self.chat_config_rate_limit.get(
-                                    "max_requests", 1000
-                                ),
-                                max_tokens=self.chat_config_rate_limit.get(
-                                    "max_tokens", 100000
-                                ),
-                                interval=self.chat_config_rate_limit.get(
-                                    "interval", 60
-                                ),
-                                endpoint_=ep,
-                                token_encoding_name=self.token_encoding_name,
-                                config=endpoint_config,
-                            )
-                        else:
-                            self.endpoints[ep] = EndPoint(
-                                max_requests=(
-                                    endpoint_config.get("max_requests", 1000)
-                                    if endpoint_config.get("max_requests", 1000)
-                                    is not None
-                                    else 1000
-                                ),
-                                max_tokens=(
-                                    endpoint_config.get("max_tokens", 100000)
-                                    if endpoint_config.get("max_tokens", 100000)
-                                    is not None
-                                    else 100000
-                                ),
-                                interval=(
-                                    endpoint_config.get("interval", 60)
-                                    if endpoint_config.get("interval", 60) is not None
-                                    else 60
-                                ),
-                                endpoint_=ep,
-                                token_encoding_name=self.token_encoding_name,
-                                config=endpoint_config,
-                            )
+                        self.endpoints[ep] = EndPoint(
+                            max_requests=(
+                                endpoint_config.get("max_requests", 1000)
+                                if endpoint_config.get("max_requests", 1000) is not None
+                                else 1000
+                            ),
+                            max_tokens=(
+                                endpoint_config.get("max_tokens", 100000)
+                                if endpoint_config.get("max_tokens", 100000) is not None
+                                else 100000
+                            ),
+                            interval=(
+                                endpoint_config.get("interval", 60)
+                                if endpoint_config.get("interval", 60) is not None
+                                else 60
+                            ),
+                            endpoint_=ep,
+                            token_encoding_name=self.token_encoding_name,
+                            config=endpoint_config,
+                        )
 
                 if not self.endpoints[ep]._has_initialized:
                     await self.endpoints[ep].init_rate_limiter()
@@ -820,20 +811,20 @@ class BaseService:
         Calls the specified API endpoint with the given payload and method.
 
         Args:
-            payload: The payload to send with the API call.
-            endpoint: The endpoint to call.
-            method: The HTTP method to use for the call.
+                payload: The payload to send with the API call.
+                endpoint: The endpoint to call.
+                method: The HTTP method to use for the call.
 
         Returns:
-            The assistant_response from the API call.
+                The assistant_response from the API call.
 
         Raises:
-            ValueError: If the endpoint has not been initialized.
+                ValueError: If the endpoint has not been initialized.
         """
         if endpoint not in self.endpoints.keys():
             raise ValueError(f"The endpoint {endpoint} has not initialized.")
         async with aiohttp.ClientSession() as http_session:
-            completion = await self.endpoints[endpoint].rate_limiter._call_api(
+            return await self.endpoints[endpoint].rate_limiter._call_api(
                 http_session=http_session,
                 endpoint=endpoint,
                 base_url=self.base_url,
@@ -842,7 +833,6 @@ class BaseService:
                 payload=payload,
                 **kwargs,
             )
-            return completion
 
 
 class PayloadPackage:
@@ -853,13 +843,13 @@ class PayloadPackage:
         Creates a payload for the chat completion operation.
 
         Args:
-            messages: The messages to include in the chat completion.
-            llmconfig: Configuration for the language model.
-            schema: The schema describing required and optional fields.
-            **kwargs: Additional keyword arguments.
+                messages: The messages to include in the chat completion.
+                llmconfig: Configuration for the language model.
+                schema: The schema describing required and optional fields.
+                **kwargs: Additional keyword arguments.
 
         Returns:
-            The constructed payload.
+                The constructed payload.
         """
         return APIUtil.create_payload(
             input_=messages,
@@ -876,13 +866,13 @@ class PayloadPackage:
         Creates a payload for the fine-tuning operation.
 
         Args:
-            training_file: The file containing training data.
-            llmconfig: Configuration for the language model.
-            schema: The schema describing required and optional fields.
-            **kwargs: Additional keyword arguments.
+                training_file: The file containing training data.
+                llmconfig: Configuration for the language model.
+                schema: The schema describing required and optional fields.
+                **kwargs: Additional keyword arguments.
 
         Returns:
-            The constructed payload.
+                The constructed payload.
         """
         return APIUtil._create_payload(
             input_=training_file,