pygeai 0.6.0b6__py3-none-any.whl → 0.6.0b10__py3-none-any.whl

pygeai/auth/clients.py

@@ -1,9 +1,10 @@
-from json import JSONDecodeError
-
 from pygeai import logger
-from pygeai.auth.endpoints import GET_USER_PROFILE_INFO, GET_OAUTH2_ACCESS_TOKEN
+from pygeai.auth.endpoints import GET_USER_PROFILE_INFO, GET_OAUTH2_ACCESS_TOKEN, \
+    CREATE_PROJECT_API_TOKEN_V2, DELETE_PROJECT_API_TOKEN_V2, UPDATE_PROJECT_API_TOKEN_V2, GET_PROJECT_API_TOKEN_V2
 from pygeai.core.base.clients import BaseClient
-from pygeai.core.common.exceptions import InvalidAPIResponseException
+from pygeai.core.common.exceptions import InvalidAPIResponseException, APIResponseError
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
 
 
 class AuthClient(BaseClient):
@@ -33,11 +34,8 @@ class AuthClient(BaseClient):
                 "password": password
             }
         )
-        try:
-            return response.json()
-        except JSONDecodeError as e:
-            logger.error(f"Unable to obtain Oauth2 access token: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to  obtain Oauth2 access token: {response.text}")
+        validate_status_code(response)
+        return parse_json_response(response, "obtain Oauth2 access token")
 
     def get_user_profile_information(self, access_token: str) -> dict:
         """
@@ -48,8 +46,84 @@ class AuthClient(BaseClient):
         """
         self.api_service.token = access_token
         response = self.api_service.get(endpoint=GET_USER_PROFILE_INFO)
-        try:
-            return response.json()
-        except JSONDecodeError as e:
-            logger.error(f"Unable to retrieve user profile information: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to retrieve user profile information: {response.text}")
+        validate_status_code(response)
+        return parse_json_response(response, "retrieve user profile information")
+
+    def create_project_api_token(
+            self,
+            project_id: str,
+            name: str,
+            description: str = None
+    ) -> dict:
+        """
+        Creates a new API token for a project.
+
+        :param project_id: str - The project identifier (required). Will be sent as header.
+        :param name: str - The name of the API token (required).
+        :param description: str - A description of the API token (optional).
+        :return: dict - The API response containing the created API token details in JSON format.
+        """
+        headers = {"project-id": project_id}
+        data = {"name": name}
+        if description:
+            data["description"] = description
+
+        response = self.api_service.post(
+            endpoint=CREATE_PROJECT_API_TOKEN_V2,
+            data=data,
+            headers=headers
+        )
+        validate_status_code(response)
+        return parse_json_response(response, "create project API token")
+
+    def delete_project_api_token(self, api_token_id: str) -> dict:
+        """
+        Revokes an API token by setting its status to "revoked".
+
+        :param api_token_id: str - The unique identifier of the API token to delete (required).
+        :return: dict - The API response confirming the deletion, in JSON format.
+        """
+        endpoint = DELETE_PROJECT_API_TOKEN_V2.format(id=api_token_id)
+        response = self.api_service.delete(endpoint=endpoint)
+        validate_status_code(response)
+        return parse_json_response(response, "delete project API token", api_token_id=api_token_id)
+
+    def update_project_api_token(
+            self,
+            api_token_id: str,
+            description: str = None,
+            status: str = None
+    ) -> dict:
+        """
+        Updates an existing API token's description and/or status.
+
+        :param api_token_id: str - The unique identifier of the API token to update (required).
+        :param description: str - A new description for the API token (optional).
+        :param status: str - The new status for the API token: 'active' or 'blocked' (optional).
+        :return: dict - The API response containing the update result messages in JSON format.
+        """
+        endpoint = UPDATE_PROJECT_API_TOKEN_V2.format(id=api_token_id)
+        data = {}
+        if description is not None:
+            data["description"] = description
+        if status is not None:
+            data["status"] = status
+
+        response = self.api_service.put(
+            endpoint=endpoint,
+            data=data
+        )
+        validate_status_code(response)
+        return parse_json_response(response, "update project API token", api_token_id=api_token_id)
+
+    def get_project_api_token(self, api_token_id: str) -> dict:
+        """
+        Retrieves data for a specific project API token.
+
+        :param api_token_id: str - The unique identifier of the API token (required).
+        :return: dict - The API response containing the API token details in JSON format.
+        """
+        endpoint = GET_PROJECT_API_TOKEN_V2.format(id=api_token_id)
+        response = self.api_service.get(endpoint=endpoint)
+        validate_status_code(response)
+        return parse_json_response(response, "get project API token", api_token_id=api_token_id)

pygeai/auth/endpoints.py

@@ -1,2 +1,6 @@
 GET_OAUTH2_ACCESS_TOKEN = "/oauth/access_token"      # POST -> Obtain an OAuth 2.0 access token
 GET_USER_PROFILE_INFO = "/openid/userinfo"          # GET -> Retrieve user profile information
+CREATE_PROJECT_API_TOKEN_V2 = "v2/projects/tokens"          # POST -> Create a new API token for a project
+DELETE_PROJECT_API_TOKEN_V2 = "v2/projects/tokens/{id}"     # DELETE -> Revoke an API token
+UPDATE_PROJECT_API_TOKEN_V2 = "v2/projects/tokens/{id}"     # PUT -> Update an API token
+GET_PROJECT_API_TOKEN_V2 = "v2/projects/tokens/{id}"        # GET -> Get data of a specific project API token

pygeai/chat/clients.py

@@ -1,11 +1,14 @@
 import json
 from json import JSONDecodeError
+from pathlib import Path
 from typing import List, Dict, Optional, Union, Generator
 
 from pygeai import logger
-from pygeai.chat.endpoints import CHAT_V1, GENERATE_IMAGE_V1
+from pygeai.chat.endpoints import CHAT_V1, GENERATE_IMAGE_V1, RESPONSES_V1
 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
 
 
 class ChatClient(BaseClient):
@@ -14,8 +17,8 @@ class ChatClient(BaseClient):
         response = self.api_service.post(
             endpoint=CHAT_V1
         )
-        result = response.json()
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "chat")
 
     def chat_completion(
             self,
@@ -39,7 +42,8 @@ class ChatClient(BaseClient):
             stream_options: Optional[Dict] = None,
             store: Optional[bool] = None,
             metadata: Optional[Dict] = None,
-            user: Optional[str] = None
+            user: Optional[str] = None,
+            reasoning_effort: Optional[str] = None
     ) -> Union[dict, str, Generator[str, None, None]]:
         """
         Generates a chat completion response using the specified model and parameters.
@@ -49,8 +53,8 @@ class ChatClient(BaseClient):
         :param messages: List[Dict[str, str]] - A list of messages to include in the chat completion. Each message should be a dictionary with
             the following structure:
                 {
-                    "role": "string",  # Possible values: "user", "system", "assistant", or others supported by the model
-                    "content": "string"  # The content of the message
+                    "role": "string",
+                    "content": "string"
                 } (Required)
         :param stream: bool - Whether the response should be streamed. Possible values:
             - False: Returns the complete response as a dictionary or string (default).
@@ -77,6 +81,9 @@ class ChatClient(BaseClient):
         :param store: Optional[bool] - Whether to store the output for model distillation or evals. (Optional)
         :param metadata: Optional[Dict] - Up to 16 key-value pairs to attach to the object. (Optional)
         :param user: Optional[str] - A unique identifier for the end-user to monitor abuse. (Optional)
+        :param reasoning_effort: Optional[str] - Controls the depth of reasoning applied by supported models.
+            Possible values: "low", "medium", "high". Supported by OpenAI models from version 5,
+            Claude models from version 4.1, and Gemini models from version 2.0. (Optional)
         :return: Union[dict, str, Generator[str, None, None]] - For non-streaming (stream=False), returns a dictionary containing the chat completion
             result or a string if JSON decoding fails. For streaming (stream=True), returns a generator yielding content strings extracted from the
             streaming response chunks.
@@ -86,19 +93,16 @@ class ChatClient(BaseClient):
             'messages': messages,
             'stream': stream
         }
-        if temperature:
+        if temperature is not None:
             data['temperature'] = temperature
 
         if max_tokens:
             data['max_completion_tokens'] = max_tokens
 
-        if thread_id:
-            data['threadId'] = thread_id
-
-        if frequency_penalty:
+        if frequency_penalty is not None:
             data['frequency_penalty'] = frequency_penalty
 
-        if presence_penalty:
+        if presence_penalty is not None:
             data['presence_penalty'] = presence_penalty
 
         if variables is not None and any(variables):
@@ -140,6 +144,9 @@ class ChatClient(BaseClient):
         if user is not None:
             data['user'] = user
 
+        if reasoning_effort is not None:
+            data['reasoning_effort'] = reasoning_effort
+
         headers = {}
         if thread_id:
             headers["saia-conversation-id"] = thread_id
@@ -159,12 +166,13 @@ class ChatClient(BaseClient):
                 data=data,
                 headers=headers
             )
-            try:
-                result = response.json()
-                logger.debug(f"Chat completion result: {result}")
-                return result
-            except JSONDecodeError as e:
-                raise InvalidAPIResponseException(f"Unable to process chat request: {response.text}")
+            validate_status_code(response)
+
+            result = parse_json_response(response, "process chat request")
+
+            logger.debug(f"Chat completion result: {result}")
+
+            return result
 
     def stream_chat_generator(self, response) -> Generator[str, None, None]:
         """
@@ -194,6 +202,34 @@ class ChatClient(BaseClient):
         except Exception as e:
             raise InvalidAPIResponseException(f"Unable to process streaming chat response: {e}")
 
+    def stream_response_generator(self, response) -> Generator[str, None, None]:
+        """
+        Processes a streaming response from the Responses API and yields content strings.
+
+        :param response: The streaming response from the API.
+        :return: Generator[str, None, None] - Yields content strings extracted from streaming chunks.
+        """
+        try:
+            for line in response:
+                if line.startswith("data:"):
+                    chunk = line[5:].strip()
+                    if chunk == "[DONE]":
+                        break
+                    try:
+                        json_data = json.loads(chunk)
+                        if (
+                                json_data.get("choices")
+                                and len(json_data["choices"]) > 0
+                                and "delta" in json_data["choices"][0]
+                                and "content" in json_data["choices"][0]["delta"]
+                        ):
+                            content = json_data["choices"][0]["delta"]["content"]
+                            yield content
+                    except JSONDecodeError as e:
+                        continue
+        except Exception as e:
+            raise InvalidAPIResponseException(f"Unable to process streaming response: {e}")
+
     def generate_image(
             self,
             model: str,
@@ -211,7 +247,7 @@ class ChatClient(BaseClient):
         :param n: int - Number of images to generate (1-10, depending on the model). (Required)
         :param quality: str - Rendering quality, e.g., "high". (Required)
         :param size: str - Image dimensions, e.g., "1024x1024". (Required)
-        :param aspect_ratio: Optional[str] - Relationship between image’s width and height, e.g., "1:1", "9:16", "16:9", "3:4", "4:3". (Optional)
+        :param aspect_ratio: Optional[str] - Relationship between image's width and height, e.g., "1:1", "9:16", "16:9", "3:4", "4:3". (Optional)
         :return: dict - The API response containing the generated image data.
         :raises InvalidAPIResponseException: If the API response cannot be processed.
         """
@@ -233,9 +269,140 @@ class ChatClient(BaseClient):
             data=data
         )
 
-        try:
-            result = response.json()
-            logger.debug(f"Image generation result: {result}")
-            return result
-        except JSONDecodeError as e:
-            raise InvalidAPIResponseException(f"Unable to process image generation request: {response.text}")
+        validate_status_code(response)
+
+        result = parse_json_response(response, "generate image")
+        logger.debug(f"Image generation result: {result}")
+        return result
+
+    def get_response(
+            self,
+            model: str,
+            input: str,
+            files: Optional[List[str]] = None,
+            tools: Optional[List[Dict]] = None,
+            tool_choice: Optional[Union[str, Dict]] = None,
+            temperature: Optional[float] = None,
+            max_output_tokens: Optional[int] = None,
+            top_p: Optional[float] = None,
+            metadata: Optional[Dict] = None,
+            user: Optional[str] = None,
+            instructions: Optional[str] = None,
+            reasoning: Optional[Dict] = None,
+            truncation: Optional[str] = None,
+            parallel_tool_calls: Optional[bool] = None,
+            store: Optional[bool] = None,
+            stream: bool = False
+    ) -> Union[dict, str, Generator[str, None, None]]:
+        """
+        Generates a response using the Responses API with support for images and PDF files.
+
+        :param model: str - The model specification, e.g., "openai/o1-pro". (Required)
+        :param input: str - The user input text. (Required)
+        :param files: Optional[List[str]] - List of file paths (images or PDFs) to include in the request. (Optional)
+        :param tools: Optional[List[Dict]] - A list of tools (e.g., functions) the model may call. (Optional)
+        :param tool_choice: Optional[Union[str, Dict]] - Controls which tool is called (e.g., "none", "auto", or specific tool). (Optional)
+        :param temperature: Optional[float] - Controls the randomness of the response. (Optional)
+        :param max_output_tokens: Optional[int] - The maximum number of tokens to generate in the response. (Optional)
+        :param top_p: Optional[float] - Nucleus sampling parameter. (Optional)
+        :param metadata: Optional[Dict] - Up to 16 key-value pairs to attach to the object. (Optional)
+        :param user: Optional[str] - A unique identifier for the end-user. (Optional)
+        :param instructions: Optional[str] - Additional instructions for the model. (Optional)
+        :param reasoning: Optional[Dict] - Reasoning configuration, e.g., {"effort": "medium"}. (Optional)
+        :param truncation: Optional[str] - Truncation strategy, e.g., "disabled". (Optional)
+        :param parallel_tool_calls: Optional[bool] - Whether to enable parallel tool calls. (Optional)
+        :param store: Optional[bool] - Whether to store the output. (Optional)
+        :param stream: bool - Whether the response should be streamed. Possible values:
+            - False: Returns the complete response as a dictionary or string (default).
+            - True: Returns a generator yielding content strings as they are received. (Optional)
+        :return: Union[dict, str, Generator[str, None, None]] - For non-streaming (stream=False), returns a dictionary containing the response
+            result or a string if JSON decoding fails. For streaming (stream=True), returns a generator yielding content strings extracted from the
+            streaming response chunks.
+        :raises InvalidAPIResponseException: If the API response cannot be processed.
+        """
+        data = {
+            'model': model,
+            'input': input,
+            'stream': stream
+        }
+
+        if temperature is not None:
+            data['temperature'] = temperature
+
+        if max_output_tokens is not None:
+            data['max_output_tokens'] = max_output_tokens
+
+        if top_p is not None:
+            data['top_p'] = top_p
+
+        if tools is not None:
+            data['tools'] = tools
+
+        if tool_choice is not None:
+            data['tool_choice'] = tool_choice
+
+        if metadata is not None:
+            data['metadata'] = metadata
+
+        if user is not None:
+            data['user'] = user
+
+        if instructions is not None:
+            data['instructions'] = instructions
+
+        if reasoning is not None:
+            data['reasoning'] = reasoning
+
+        if truncation is not None:
+            data['truncation'] = truncation
+
+        if parallel_tool_calls is not None:
+            data['parallel_tool_calls'] = parallel_tool_calls
+
+        if store is not None:
+            data['store'] = store
+
+        logger.debug(f"Generating response with data: {data}")
+
+        if files:
+            if stream:
+                raise InvalidAPIResponseException("Streaming is not supported when uploading files")
+            
+            file_handles = []
+            try:
+                files_dict = {}
+                for idx, file_path in enumerate(files):
+                    path = Path(file_path)
+                    if not path.is_file():
+                        raise FileNotFoundError(f"File not found: {file_path}")
+                    
+                    file_handle = path.open("rb")
+                    file_handles.append(file_handle)
+                    files_dict[f"file{idx}"] = file_handle
+
+                response = self.api_service.post_files_multipart(
+                    endpoint=RESPONSES_V1,
+                    data=data,
+                    files=files_dict
+                )
+            finally:
+                for fh in file_handles:
+                    fh.close()
+        else:
+            if stream:
+                response = self.api_service.stream_post(
+                    endpoint=RESPONSES_V1,
+                    data=data
+                )
+                return self.stream_response_generator(response)
+            else:
+                response = self.api_service.post(
+                    endpoint=RESPONSES_V1,
+                    data=data
+                )
+
+        validate_status_code(response)
+        result = parse_json_response(response, "get response")
+        logger.debug(f"Response result: {result}")
+
+        return result

pygeai/chat/endpoints.py

@@ -1,3 +1,4 @@
 CHAT_V1 = "/chat"                           # POST Chat endpoint
 CHAT_COMPLETION_V1 = "/chat/completion"     # POST Chat completion endpoint
-GENERATE_IMAGE_V1 = "/images"               # POST Generate image
+GENERATE_IMAGE_V1 = "/images"               # POST Generate image
+RESPONSES_V1 = "/responses"                 # POST Responses API endpoint

pygeai/cli/commands/auth.py

@@ -92,6 +92,146 @@ get_user_profile_information_options = [
 ]
 
 
+def create_project_api_token(option_list: list):
+    project_id = None
+    name = None
+    description = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+        if option_flag.name == "name":
+            name = option_arg
+        if option_flag.name == "description":
+            description = option_arg
+
+    if not (project_id and name):
+        raise MissingRequirementException("Cannot create project API token without project-id and name")
+
+    client = AuthClient()
+    result = client.create_project_api_token(
+        project_id=project_id,
+        name=name,
+        description=description
+    )
+    Console.write_stdout(f"Project API token created: \n{result}")
+
+
+create_project_api_token_options = [
+    Option(
+        "project_id",
+        ["--project-id", "--pid"],
+        "The project identifier (required).",
+        True
+    ),
+    Option(
+        "name",
+        ["--name", "-n"],
+        "The name of the API token (required).",
+        True
+    ),
+    Option(
+        "description",
+        ["--description", "-d"],
+        "A description of the API token (optional).",
+        True
+    ),
+]
+
+
+def delete_project_api_token(option_list: list):
+    api_token_id = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "api_token_id":
+            api_token_id = option_arg
+
+    if not api_token_id:
+        raise MissingRequirementException("Cannot delete project API token without api-token-id")
+
+    client = AuthClient()
+    result = client.delete_project_api_token(api_token_id=api_token_id)
+    Console.write_stdout(f"Project API token deleted: \n{result}")
+
+
+delete_project_api_token_options = [
+    Option(
+        "api_token_id",
+        ["--api-token-id", "--tid"],
+        "The unique identifier of the API token to delete (required).",
+        True
+    ),
+]
+
+
+def update_project_api_token(option_list: list):
+    api_token_id = None
+    description = None
+    status = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "api_token_id":
+            api_token_id = option_arg
+        if option_flag.name == "description":
+            description = option_arg
+        if option_flag.name == "status":
+            status = option_arg
+
+    if not api_token_id:
+        raise MissingRequirementException("Cannot update project API token without api-token-id")
+
+    client = AuthClient()
+    result = client.update_project_api_token(
+        api_token_id=api_token_id,
+        description=description,
+        status=status
+    )
+    Console.write_stdout(f"Project API token updated: \n{result}")
+
+
+update_project_api_token_options = [
+    Option(
+        "api_token_id",
+        ["--api-token-id", "--tid"],
+        "The unique identifier of the API token to update (required).",
+        True
+    ),
+    Option(
+        "description",
+        ["--description", "-d"],
+        "A new description for the API token (optional).",
+        True
+    ),
+    Option(
+        "status",
+        ["--status"],
+        "The new status for the API token: 'active' or 'blocked' (optional).",
+        True
+    ),
+]
+
+
+def get_project_api_token(option_list: list):
+    api_token_id = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "api_token_id":
+            api_token_id = option_arg
+
+    if not api_token_id:
+        raise MissingRequirementException("Cannot get project API token without api-token-id")
+
+    client = AuthClient()
+    result = client.get_project_api_token(api_token_id=api_token_id)
+    Console.write_stdout(f"Project API token details: \n{result}")
+
+
+get_project_api_token_options = [
+    Option(
+        "api_token_id",
+        ["--api-token-id", "--tid"],
+        "The unique identifier of the API token (required).",
+        True
+    ),
+]
+
+
 auth_commands = [
     Command(
         "help",
@@ -112,12 +252,48 @@ auth_commands = [
         get_oauth2_access_token_options
     ),
     Command(
-        "get_user_profile_information_options",
+        "get_user_profile_information",
         ["get-user-information", "get-user-info", "gui"],
         "Retrieve user profile information",
-        get_user_profile_information_options,
+        get_user_profile_information,
         ArgumentsEnum.REQUIRED,
         [],
         get_user_profile_information_options
     ),
+    Command(
+        "create_project_api_token",
+        ["create-project-api-token", "create-api-token", "cat"],
+        "Create a new API token for a project",
+        create_project_api_token,
+        ArgumentsEnum.REQUIRED,
+        [],
+        create_project_api_token_options
+    ),
+    Command(
+        "delete_project_api_token",
+        ["delete-project-api-token", "delete-api-token", "dat"],
+        "Revoke an API token",
+        delete_project_api_token,
+        ArgumentsEnum.REQUIRED,
+        [],
+        delete_project_api_token_options
+    ),
+    Command(
+        "update_project_api_token",
+        ["update-project-api-token", "update-api-token", "uat"],
+        "Update an existing API token",
+        update_project_api_token,
+        ArgumentsEnum.REQUIRED,
+        [],
+        update_project_api_token_options
+    ),
+    Command(
+        "get_project_api_token",
+        ["get-project-api-token", "get-api-token", "gat"],
+        "Get data of a specific project API token",
+        get_project_api_token,
+        ArgumentsEnum.REQUIRED,
+        [],
+        get_project_api_token_options
+    ),
 ]