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

pygeai/organization/mappers.py

@@ -1,20 +1,27 @@
 from pygeai.core.base.mappers import ModelMapper
-from pygeai.core.base.models import ProjectToken, ProjectSearchProfile, Assistant, Project, ProjectItem
+from pygeai.core.models import Assistant, Project, Role, Member, OrganizationMembership, ProjectMembership, Organization
 from pygeai.organization.responses import AssistantListResponse, ProjectListResponse, ProjectDataResponse, \
-    ProjectTokensResponse, ProjectItemListResponse
+    ProjectTokensResponse, ProjectItemListResponse, MembershipsResponse, ProjectMembershipsResponse, \
+    ProjectRolesResponse, ProjectMembersResponse, OrganizationMembersResponse, OrganizationListResponse, \
+    OrganizationDataResponse
 
 
 class OrganizationResponseMapper:
 
     @classmethod
     def map_to_assistant_list_response(cls, data: dict) -> AssistantListResponse:
-        assistant_list = cls.map_to_assistant_list(data)
+        assistant_list = data.get('assistants')
+        if "projectName" in data and assistant_list:
+            for assistant in assistant_list:
+                assistant.update({
+                    'projectId': data.get('projectId'),
+                    'projectName': data.get('projectName')
+                })
 
-        project = ModelMapper.map_to_project(data)
+        assistant_list = cls.map_to_assistant_list(data)
 
         return AssistantListResponse(
             assistants=assistant_list,
-            project=project
         )
 
     @classmethod
@@ -49,65 +56,123 @@ class OrganizationResponseMapper:
 
     @classmethod
     def map_to_project_data(cls, data: dict) -> ProjectDataResponse:
-        organization = ModelMapper.map_to_organization(data)
         project = ModelMapper.map_to_project(data)
-        search_profile_list = cls.map_to_search_profile_list(data)
-        token_list = cls.map_to_token_list(data)
-        usage_limit = ModelMapper.map_to_usage_limit(data)
 
         return ProjectDataResponse(
-            organization=organization,
             project=project,
-            search_profiles=search_profile_list,
-            tokens=token_list,
-            usage_limit=usage_limit
         )
 
-    @classmethod
-    def map_to_search_profile_list(cls, data: dict) -> list[ProjectSearchProfile]:
-        search_profile_list = list()
-        search_profiles = data.get('search_profiles')
-        if search_profiles is not None and any(search_profiles):
-            for search_profile_data in search_profiles:
-                search_profile = ModelMapper.map_to_search_profile(search_profile_data)
-                search_profile_list.append(search_profile)
-
-        return search_profile_list
-
     @classmethod
     def map_to_token_list_response(cls, data: dict) -> ProjectTokensResponse:
-        token_list = cls.map_to_token_list(data)
+        token_list = ModelMapper.map_to_token_list(data)
 
         return ProjectTokensResponse(
             tokens=token_list
         )
 
-    @classmethod
-    def map_to_token_list(cls, data: dict) -> list[ProjectToken]:
-        token_list = list()
-        tokens = data.get('tokens')
-        if tokens is not None and any(tokens):
-            for token_data in tokens:
-                token = ModelMapper.map_to_token(token_data)
-                token_list.append(token)
-
-        return token_list
-
     @classmethod
     def map_to_item_list_response(cls, data: dict) -> ProjectItemListResponse:
-        item_list = cls.map_to_item_list(data)
+        item_list = ModelMapper.map_to_item_list(data)
 
         return ProjectItemListResponse(
             items=item_list
         )
 
     @classmethod
-    def map_to_item_list(cls, data: dict) -> list[ProjectItem]:
-        item_list = list()
-        items = data.get('items')
-        if items is not None and any(items):
-            for item_data in items:
-                item = ModelMapper.map_to_item(item_data)
-                item_list.append(item)
-
-        return item_list
+    def map_to_memberships_response(cls, data: dict) -> MembershipsResponse:
+        count = data.get("count", 0)
+        pages = data.get("pages", 0)
+        organizations_data = data.get("organizations", [])
+        organizations = []
+        
+        for org_data in organizations_data:
+            org = OrganizationMembership.model_validate(org_data)
+            organizations.append(org)
+
+        return MembershipsResponse(
+            count=count,
+            pages=pages,
+            organizations=organizations
+        )
+
+    @classmethod
+    def map_to_project_memberships_response(cls, data: dict) -> ProjectMembershipsResponse:
+        count = data.get("count", 0)
+        pages = data.get("pages", 0)
+        projects_data = data.get("projects", [])
+        projects = []
+        
+        for project_data in projects_data:
+            project = ProjectMembership.model_validate(project_data)
+            projects.append(project)
+
+        return ProjectMembershipsResponse(
+            count=count,
+            pages=pages,
+            projects=projects
+        )
+
+    @classmethod
+    def map_to_project_roles_response(cls, data: dict) -> ProjectRolesResponse:
+        roles_data = data.get("roles", [])
+        roles = []
+        
+        for role_data in roles_data:
+            role = Role.model_validate(role_data)
+            roles.append(role)
+
+        return ProjectRolesResponse(
+            roles=roles
+        )
+
+    @classmethod
+    def map_to_project_members_response(cls, data: dict) -> ProjectMembersResponse:
+        members_data = data.get("members", [])
+        members = []
+        
+        for member_data in members_data:
+            member = Member.model_validate(member_data)
+            members.append(member)
+
+        return ProjectMembersResponse(
+            members=members
+        )
+
+    @classmethod
+    def map_to_organization_members_response(cls, data: dict) -> OrganizationMembersResponse:
+        members_data = data.get("members", [])
+        members = []
+        
+        for member_data in members_data:
+            member = Member.model_validate(member_data)
+            members.append(member)
+
+        return OrganizationMembersResponse(
+            members=members
+        )
+
+    @classmethod
+    def map_to_organization_list_response(cls, data: dict) -> OrganizationListResponse:
+        count = data.get("count", 0)
+        pages = data.get("pages", 0)
+        organizations_data = data.get("organizations", [])
+        organizations = []
+        
+        for org_data in organizations_data:
+            organization = Organization.model_validate(org_data)
+            organizations.append(organization)
+
+        return OrganizationListResponse(
+            count=count,
+            pages=pages,
+            organizations=organizations
+        )
+
+    @classmethod
+    def map_to_organization_data_response(cls, data: dict) -> OrganizationDataResponse:
+        organization = Organization.model_validate(data)
+
+        return OrganizationDataResponse(
+            organization=organization
+        )
+

pygeai/organization/responses.py

@@ -1,26 +1,19 @@
-from typing import Optional
-
 from pydantic.main import BaseModel
 
-from pygeai.core.base.models import Assistant, Project, Organization, ProjectSearchProfile, ProjectToken, \
-    ProjectUsageLimit, ProjectItem
+from pygeai.core.models import Assistant, Project, ProjectToken, \
+    RequestItem, Role, Member, OrganizationMembership, ProjectMembership, Organization
 
 
 class AssistantListResponse(BaseModel):
     assistants: list[Assistant]
-    project: Project
 
 
 class ProjectListResponse(BaseModel):
-    projects : list[Project]
+    projects: list[Project]
 
 
 class ProjectDataResponse(BaseModel):
-    organization: Optional[Organization]
     project: Project
-    search_profile: Optional[list[ProjectSearchProfile]]
-    tokens: Optional[list[ProjectToken]]
-    usage_limit: Optional[ProjectUsageLimit]
 
 
 class ProjectTokensResponse(BaseModel):
@@ -28,4 +21,61 @@ class ProjectTokensResponse(BaseModel):
 
 
 class ProjectItemListResponse(BaseModel):
-    items: list[ProjectItem]
+    items: list[RequestItem]
+
+    def to_list(self):
+        return [item.to_dict() for item in self.items] if self.items else []
+
+    def __getitem__(self, index: int) -> RequestItem:
+        if self.items is None:
+            raise IndexError("ProjectItemListResponse is empty")
+        return self.items[index]
+
+    def __len__(self) -> int:
+        return len(self.items) if self.items else 0
+
+    def __iter__(self):
+        """Make ProjectItemListResponse iterable over its items."""
+        if self.items is None:
+            return iter([])
+        return iter(self.items)
+
+    def append(self, item: RequestItem) -> None:
+        """Append an Agent instance to the items list."""
+        if self.items is None:
+            self.items = []
+        self.items.append(item)
+
+
+class MembershipsResponse(BaseModel):
+    count: int
+    pages: int
+    organizations: list[OrganizationMembership]
+
+
+class ProjectMembershipsResponse(BaseModel):
+    count: int
+    pages: int
+    projects: list[ProjectMembership]
+
+
+class ProjectRolesResponse(BaseModel):
+    roles: list[Role]
+
+
+class ProjectMembersResponse(BaseModel):
+    members: list[Member]
+
+
+class OrganizationMembersResponse(BaseModel):
+    members: list[Member]
+
+
+class OrganizationListResponse(BaseModel):
+    count: int
+    pages: int
+    organizations: list[Organization]
+
+
+class OrganizationDataResponse(BaseModel):
+    organization: Organization

pygeai/proxy/clients.py

@@ -0,0 +1,216 @@
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, List
+import uuid
+import requests
+from urllib3.exceptions import MaxRetryError
+from pygeai.proxy.tool import ProxiedTool
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
+
+
+@dataclass
+class ToolProxyData:
+    """
+    Data class representing a tool proxy registration.
+
+    :param id: Optional[uuid.UUID] - Unique identifier for the proxy. Defaults to None.
+    :param name: Optional[str] - Name of the proxy. Defaults to None.
+    :param description: Optional[str] - Description of the proxy. Defaults to None.
+    :param affinity: Optional[uuid.UUID] - Affinity UUID. Defaults to None.
+    :param tools: Optional[List[Tool]] - List of tools. Defaults to None.
+    """
+    id: Optional[uuid.UUID] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+    affinity: Optional[uuid.UUID] = None
+    tools: Optional[List[ProxiedTool]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the data to a dictionary for API requests.
+
+        :return: Dict[str, Any] - Dictionary containing proxy data
+        """
+        return {
+            "id": str(self.id) if self.id else None,
+            "name": self.name,
+            "description": self.description,
+            "affinity": str(self.affinity) if self.affinity else str(uuid.UUID(int=0)),
+            "tools": [
+                {
+                    "name": tool.get_full_name(),
+                    **({"publicName": tool.get_public_name()} if tool.is_public() else {}),
+                    "server": tool.server_name,
+                    "description": tool.description,
+                    "inputSchema": tool.format_for_llm()
+                } for tool in self.tools
+            ] if self.tools else []
+        }
+
+@dataclass
+class ToolProxyJob:
+    """
+    Represents a Tool Proxy Job.
+
+    :param id: uuid.UUID - Unique identifier for the job
+    :param proxy_id: uuid.UUID - ID of the proxy handling the job
+    :param proxy_status: str - Status of the proxy
+    :param job_status: str - Status of the job
+    :param input: Optional[str] - Input data for the job. Defaults to None.
+    :param output: Optional[str] - Output data from the job. Defaults to None.
+    :param server: Optional[str] - Server handling the job. Defaults to None.
+    """
+    id: uuid.UUID
+    proxy_id: uuid.UUID
+    proxy_status: str
+    job_status: str
+    input: Optional[str] = None
+    output: Optional[str] = None
+    server: Optional[str] = None
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'ToolProxyJob':
+        """
+        Create a ToolProxyJob from a dictionary.
+
+        :param data: Dict[str, Any] - Dictionary containing job data
+        :return: ToolProxyJob - New ToolProxyJob instance
+        """
+        return ToolProxyJob(
+            id=uuid.UUID(data['id']),
+            proxy_id=uuid.UUID(data['proxyId']),
+            proxy_status=data['proxyStatus'],
+            job_status=data['jobStatus'],
+            input=data.get('input'),
+            output=data.get('output'),
+            server=data.get('server')
+        )
+
+@dataclass
+class ToolProxyJobResult:
+    """
+    Represents the result of a Tool Proxy Job.
+
+    :param success: bool - Whether the job was successful
+    :param job: ToolProxyJob - The job that was executed
+    """
+    success: bool
+    job: ToolProxyJob
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the result to a dictionary for API requests.
+
+        :return: Dict[str, Any] - Dictionary containing job result
+        """
+        return {
+            "success": self.success,
+            "job": {
+                "id": str(self.job.id),
+                "jobStatus": self.job.job_status,
+                "output": self.job.output
+            }
+        }
+
+
+class ProxyClient:
+    """
+    Client for interacting with the GEAI API proxy.
+
+    :param base_url: str - Base URL of the GEAI API
+    :param api_key: str - API key for authentication
+    :param proxy_id: uuid.UUID - ID of the proxy
+    """
+
+    def __init__(self, api_key: str, base_url: str, proxy_id: uuid.UUID ):
+        """
+        Initialize a new proxy client.
+
+        :param base_url: str - Base URL of the GEAI API
+        :param api_key: str - API key for authentication
+        :param proxy_id: uuid.UUID - ID of the proxy
+        """
+        self.proxy_id = proxy_id
+        self.base_url =  base_url.rstrip('/') + '/v2/tool-proxy'
+        self.session = requests.Session()
+        self.session.headers.update({'Authorization': f'Bearer {api_key}'})
+        # Configurar el timeout
+        self.session.timeout = (5, 30)  # (connect timeout, read timeout)
+
+    def _make_request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
+        """
+        Make a request to the proxy service.
+        
+        :param method: str - HTTP method (GET, POST, etc.)
+        :param endpoint: str - API endpoint
+        :param **kwargs: Additional arguments for requests
+        :return: Dict[str, Any] - Response data as dictionary
+        :raises: RequestException - For any request-related error
+        """
+        url = self.base_url + endpoint
+        try:
+            response = self.session.request(method, url, **kwargs)
+            response.raise_for_status()
+            try:
+                validate_status_code(response)
+                return parse_json_response(response, "unknown operation")
+            except ValueError:
+                return response.text
+        except requests.exceptions.Timeout:
+            raise TimeoutError(f"Request timed out for {url}")
+        except requests.exceptions.HTTPError as e:
+            raise requests.exceptions.HTTPError(f"HTTP error for {url}: {e}") from e
+        except requests.exceptions.SSLError as e:
+            raise requests.exceptions.SSLError(f"SSL error for {url}: {e}") from e
+        except requests.exceptions.ProxyError as e:
+            raise requests.exceptions.ProxyError(f"Proxy error for {url}: {e}") from e
+        except requests.exceptions.ConnectionError as e:
+            raise ConnectionError(f"Failed to connect to {url}") from e
+        except MaxRetryError:
+            raise
+        except requests.exceptions.RequestException as e:
+            raise requests.exceptions.RequestException(f"Request failed for {url}: {e}") from e
+        except ValueError:
+            return {"response": response.text}
+
+    def register(self, proxy_data: ToolProxyData) -> Dict[str, Any]:
+        """
+        Register a new tool proxy.
+        
+        :param proxy_data: ToolProxyData - Object containing the proxy configuration and metadata
+        :return: Dict[str, Any] - Dictionary with the registration response
+        :raises: ConnectionError - If connection fails
+        :raises: MaxRetryError - If max retries are exceeded
+        :raises: requests.exceptions.RequestException - For other request errors
+        """
+        proxy_data.id = self.proxy_id
+        data = {
+            "server": proxy_data.to_dict()
+        }
+        return self._make_request('POST', '/register', json=data)
+    
+    def dequeue(self) -> List[ToolProxyJob]:
+        """
+        Dequeue a job from the proxy.
+
+        :return: List[ToolProxyJob] - List of ToolProxyJob instances
+        :raises: RequestException - For any request-related error
+        """
+        endpoint = f'/dequeue/{self.proxy_id}'
+        response_data = self._make_request('GET', endpoint)
+        return [ToolProxyJob.from_dict(job) for job in response_data]
+
+    
+    def send_result(self, result: ToolProxyJobResult):
+        """
+        Send the result of a tool proxy job.
+
+        :param result: ToolProxyJobResult - Result object containing the job outcome
+        :return: None
+        :raises: RequestException - For any request-related error
+        """
+        endpoint = f'/result/{self.proxy_id}'
+        data = {
+            "jobResult": result.to_dict()
+        }
+        self._make_request('POST', endpoint, json=data)

pygeai/proxy/config.py

@@ -0,0 +1,128 @@
+from pygeai.core.common.config import SettingsManager
+from typing import Optional
+import uuid
+import os
+
+class ProxySettingsManager(SettingsManager):
+    """
+    Settings manager for the GEAI proxy.
+    Extends the base SettingsManager with proxy-specific settings.
+
+    :param DEFAULT_ALIAS: str - Default alias for proxy settings
+    """
+    
+    DEFAULT_ALIAS = "default"
+   
+    def __init__(self):
+        super().__init__()
+        self._current_alias = self.DEFAULT_ALIAS
+
+    def get_current_alias(self) -> str:
+        return self._current_alias
+
+    def set_current_alias(self, alias: str):
+        self._current_alias = alias
+
+    def get_proxy_id(self, alias: str = DEFAULT_ALIAS) -> Optional[uuid.UUID]:
+        """
+        Get the proxy ID for a specific alias.
+
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        :return: Optional[uuid.UUID] - Proxy ID if set, None otherwise
+        """
+        id_str = self.get_setting_value("PROXY_ID", alias)
+        return uuid.UUID(id_str) if id_str else None
+
+    def set_proxy_id(self, proxy_id: uuid.UUID, alias: str = DEFAULT_ALIAS):
+        """
+        Set the proxy ID for a specific alias.
+
+        :param proxy_id: uuid.UUID - Proxy ID to set
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        """
+        self.set_setting_value("PROXY_ID", str(proxy_id), alias)
+
+    def get_proxy_name(self, alias: str = DEFAULT_ALIAS) -> Optional[str]:
+        """
+        Get the proxy name for a specific alias.
+
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        :return: Optional[str] - Proxy name if set, None otherwise
+        """
+        return self.get_setting_value("PROXY_NAME", alias)
+
+    def set_proxy_name(self, name: str, alias: str = DEFAULT_ALIAS):
+        """
+        Set the proxy name for a specific alias.
+
+        :param name: str - Proxy name to set
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        """
+        self.set_setting_value("PROXY_NAME", name, alias)
+
+    def get_proxy_description(self, alias: str = DEFAULT_ALIAS) -> Optional[str]:
+        """
+        Get the proxy description for a specific alias.
+
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        :return: Optional[str] - Proxy description if set, None otherwise
+        """
+        return self.get_setting_value("PROXY_DESCRIPTION", alias)
+
+    def set_proxy_description(self, description: str, alias: str = DEFAULT_ALIAS):
+        """
+        Set the proxy description for a specific alias.
+
+        :param description: str - Proxy description to set
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        """
+        self.set_setting_value("PROXY_DESCRIPTION", description, alias)
+
+    def get_proxy_affinity(self, alias: str = DEFAULT_ALIAS) -> Optional[uuid.UUID]:
+        """
+        Get the proxy affinity for a specific alias.
+
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        :return: Optional[uuid.UUID] - Proxy affinity if set, None otherwise
+        """
+        default_affinity = uuid.UUID(int=0)
+        if not self.has_value("PROXY_AFFINITY", alias):
+            return default_affinity
+        affinity_str = self.get_setting_value("PROXY_AFFINITY", alias)
+        return uuid.UUID(affinity_str) if affinity_str else default_affinity
+
+    def set_proxy_affinity(self, affinity: uuid.UUID, alias: str = DEFAULT_ALIAS):
+        """
+        Set the proxy affinity for a specific alias.
+
+        :param affinity: uuid.UUID - Proxy affinity to set
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        """
+        self.set_setting_value("PROXY_AFFINITY", str(affinity), alias)
+
+    def get_setting_value(self, setting_key: str, alias: str):
+        """
+        Get the value of a specific setting for a specific alias.
+
+        :param setting_key: str - Key of the setting to get
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        """
+        env_var_name = setting_key.upper()
+        if os.getenv(env_var_name) and alias == self.DEFAULT_ALIAS:
+            return os.getenv(env_var_name)
+        else:
+            return super().get_setting_value(setting_key, alias)
+    
+    def get_proxy_config(self, alias: str = DEFAULT_ALIAS) -> dict:
+        """
+        Get the complete proxy configuration for a specific alias.
+
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        :return: dict - Dictionary containing proxy configuration
+        """
+        return {
+            "id": str(self.get_proxy_id(alias)) if self.get_proxy_id(alias) else None,
+            "name": self.get_proxy_name(alias),
+            "description": self.get_proxy_description(alias),
+            "affinity": str(self.get_proxy_affinity(alias)) if self.get_proxy_affinity(alias) else None
+        }