pygeai 0.2.7b37__tar.gz → 0.2.7b38__tar.gz

{pygeai-0.2.7b37/pygeai.egg-info → pygeai-0.2.7b38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeai
-Version: 0.2.7b37
+Version: 0.2.7b38
 Summary: Software Development Kit to interact with Globant Enterprise AI.
 Author-email: Globant <geai-sdk@globant.com>
 License-Expression: MIT

{pygeai-0.2.7b37 → pygeai-0.2.7b38}/pygeai/core/base/mappers.py

@@ -351,13 +351,22 @@ class ModelMapper:
     @classmethod
     def map_to_item(cls, data: dict) -> RequestItem:
         return RequestItem(
+            api_token=data.get('apiToken'),
             assistant=data.get('assistant'),
+            cost=data.get('cost'),
+            elapsed_time_ms=data.get('elapsedTimeMs'),
+            end_timestamp=data.get('endTimestamp'),
+            feedback=data.get('feedback'),
             intent=data.get('intent'),
-            timestamp=data.get('timestamp'),
+            module=data.get('module'),
             prompt=data.get('prompt'),
             output=data.get('output'),
             input_text=data.get('inputText'),
-            status=data.get('status')
+            rag_sources_consulted=data.get('ragSourcesConsulted'),
+            session_id=data.get('sessionId'),
+            start_timestamp=data.get('startTimestamp'),
+            status=data.get('status'),
+            timestamp=data.get('timestamp')
         )
 
     @classmethod

{pygeai-0.2.7b37 → pygeai-0.2.7b38}/pygeai/core/models.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 
-from pydantic import Field, field_validator
+from pydantic import Field, field_validator, model_validator
 from typing import Optional, Literal, Any, List, Union, Iterator
 
 from pygeai.core import CustomBaseModel
@@ -247,23 +247,32 @@ class Project(CustomBaseModel):
 
 class RequestItem(CustomBaseModel):
     """
-    {
-      "assistant": "string",
-      "intent": "string",
-      "timestamp": "string",
-      "prompt": "string",
-      "output": "string",
-      "inputText": "string",
-      "status": "string"
-    }
+    Represents a request item with metadata about an API interaction.
+    Follows a JSON schema with camelCase aliases for external compatibility.
     """
+    api_token: str = Field(..., alias="apiToken")
     assistant: str = Field(..., alias="assistant")
+    cost: float = Field(..., alias="cost")
+    elapsed_time_ms: int = Field(..., alias="elapsedTimeMs")
+    end_timestamp: datetime = Field(..., alias="endTimestamp")
+    feedback: Optional[str] = Field(None, alias="feedback")
     intent: Optional[str] = Field(None, alias="intent")
-    timestamp: str = Field(..., alias="timestamp")
+    module: str = Field(..., alias="module")
     prompt: Optional[str] = Field(None, alias="prompt")
     output: Optional[str] = Field(None, alias="output")
     input_text: Optional[str] = Field(None, alias="inputText")
+    rag_sources_consulted: Optional[str] = Field(None, alias="ragSourcesConsulted")
+    session_id: str = Field(..., alias="sessionId")
+    start_timestamp: datetime = Field(..., alias="startTimestamp")
     status: str = Field(..., alias="status")
+    timestamp: datetime = Field(..., alias="timestamp")
+
+    @model_validator(mode="after")
+    def validate_status(self):
+        valid_statuses = {"succeeded", "failed", "pending"}
+        if self.status not in valid_statuses:
+            raise ValueError(f"Status must be one of {valid_statuses}")
+        return self
 
     def to_dict(self):
         return self.model_dump(by_alias=True, exclude_none=True)

{pygeai-0.2.7b37 → pygeai-0.2.7b38}/pygeai/lab/managers.py

@@ -22,12 +22,12 @@ from pygeai.lab.tools.mappers import ToolMapper
 
 class AILabManager:
 
-    def __init__(self, api_key: str = None, base_url: str = None, alias: str = "default"):
+    def __init__(self, api_key: str = None, base_url: str = None, alias: str = "default", project_id: str = None):
         self.__agent_client = AgentClient(api_key=api_key, base_url=base_url, alias=alias)
         self.__tool_client = ToolClient(api_key=api_key, base_url=base_url, alias=alias)
         self.__reasoning_strategy_client = ReasoningStrategyClient(api_key=api_key, base_url=base_url, alias=alias)
         self.__process_client = AgenticProcessClient(api_key=api_key, base_url=base_url, alias=alias)
-        self.project_id = self.__get_project_id()
+        self.project_id = self.__get_project_id() if not project_id else project_id
 
     def __get_project_id(self):
         response = None

pygeai-0.2.7b38/pygeai/organization/responses.py

@@ -0,0 +1,47 @@
+from pydantic.main import BaseModel
+
+from pygeai.core.models import Assistant, Project, ProjectToken, \
+    RequestItem
+
+
+class AssistantListResponse(BaseModel):
+    assistants: list[Assistant]
+
+
+class ProjectListResponse(BaseModel):
+    projects: list[Project]
+
+
+class ProjectDataResponse(BaseModel):
+    project: Project
+
+
+class ProjectTokensResponse(BaseModel):
+    tokens: list[ProjectToken]
+
+
+class ProjectItemListResponse(BaseModel):
+    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)

{pygeai-0.2.7b37 → pygeai-0.2.7b38}/pygeai/tests/lab/test_managers.py

@@ -13,9 +13,9 @@ class TestAILabManager(unittest.TestCase):
     """
     python -m unittest pygeai.tests.lab.test_managers.TestAILabManager
     """
+
     def setUp(self):
-        self.manager = AILabManager(api_key="test_key", base_url="test_url", alias="test_alias")
-        self.project_id = "test_project"
+        self.manager = AILabManager(api_key="test_key", base_url="test_url", alias="test_alias", project_id="test_project")
         self.agent_id = "test_agent"
         self.tool_id = "test_tool"
         self.process_id = "test_process"
@@ -31,7 +31,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_agents.return_value = {"data": "test_data"}
         mock_map_to_agent_list.return_value = AgentList(agents=[])
 
-        result = self.manager.get_agent_list(self.project_id, self.filter_settings)
+        result = self.manager.get_agent_list(self.filter_settings)
 
         mock_list_agents.assert_called_once()
         mock_map_to_agent_list.assert_called_once_with({"data": "test_data"})
@@ -42,7 +42,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_agents.return_value = {"error": {"id": 1, "message": "API error"}}
 
         with self.assertRaises(APIError):
-            self.manager.get_agent_list(self.project_id, self.filter_settings)
+            self.manager.get_agent_list(self.filter_settings)
 
     @patch('pygeai.lab.agents.clients.AgentClient.create_agent')
     @patch('pygeai.lab.agents.mappers.AgentMapper.map_to_agent')
@@ -51,7 +51,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_agent.return_value = Agent(id=self.agent_id, name="test_agent")
         agent = Agent(name="test_agent")
 
-        result = self.manager.create_agent(self.project_id, agent, automatic_publish=False)
+        result = self.manager.create_agent(agent, automatic_publish=False)
 
         mock_create_agent.assert_called_once()
         mock_map_to_agent.assert_called_once_with({"data": "test_data"})
@@ -64,7 +64,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_agent.return_value = Agent(id=self.agent_id, name="test_agent")
         agent = Agent(id=self.agent_id, name="test_agent")
 
-        result = self.manager.update_agent(self.project_id, agent, automatic_publish=False, upsert=False)
+        result = self.manager.update_agent(agent, automatic_publish=False, upsert=False)
 
         mock_update_agent.assert_called_once()
         mock_map_to_agent.assert_called_once_with({"data": "test_data"})
@@ -76,7 +76,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_agent.return_value = {"data": "test_data"}
         mock_map_to_agent.return_value = Agent(id=self.agent_id, name="test_agent")
 
-        result = self.manager.get_agent(self.project_id, self.agent_id, self.filter_settings)
+        result = self.manager.get_agent(self.agent_id, self.filter_settings)
 
         mock_get_agent.assert_called_once()
         mock_map_to_agent.assert_called_once_with({"data": "test_data"})
@@ -88,7 +88,7 @@ class TestAILabManager(unittest.TestCase):
         mock_create_sharing_link.return_value = {"data": "test_data"}
         mock_map_to_sharing_link.return_value = SharingLink(agent_id="test_agent", api_token="test_token", shared_link="test_link")
 
-        result = self.manager.create_sharing_link(self.project_id, self.agent_id)
+        result = self.manager.create_sharing_link(self.agent_id)
 
         mock_create_sharing_link.assert_called_once()
         mock_map_to_sharing_link.assert_called_once_with({"data": "test_data"})
@@ -100,7 +100,7 @@ class TestAILabManager(unittest.TestCase):
         mock_publish_agent_revision.return_value = {"data": "test_data"}
         mock_map_to_agent.return_value = Agent(id=self.agent_id, name="test_agent")
 
-        result = self.manager.publish_agent_revision(self.project_id, self.agent_id, self.revision)
+        result = self.manager.publish_agent_revision(self.agent_id, self.revision)
 
         mock_publish_agent_revision.assert_called_once()
         mock_map_to_agent.assert_called_once_with({"data": "test_data"})
@@ -112,7 +112,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_agent.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_agent(self.project_id, self.agent_id)
+        result = self.manager.delete_agent(self.agent_id)
 
         mock_delete_agent.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -125,7 +125,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
         tool = Tool(name="test_tool", description="test_desc")
 
-        result = self.manager.create_tool(self.project_id, tool, automatic_publish=False)
+        result = self.manager.create_tool(tool, automatic_publish=False)
 
         mock_create_tool.assert_called_once()
         mock_map_to_tool.assert_called_once_with({"data": "test_data"})
@@ -138,7 +138,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
         tool = Tool(id=self.tool_id, name="test_tool", description="test_desc")
 
-        result = self.manager.update_tool(self.project_id, tool, automatic_publish=False, upsert=False)
+        result = self.manager.update_tool(tool, automatic_publish=False, upsert=False)
 
         mock_update_tool.assert_called_once()
         mock_map_to_tool.assert_called_once_with({"data": "test_data"})
@@ -150,7 +150,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_tool.return_value = {"data": "test_data"}
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
 
-        result = self.manager.get_tool(self.project_id, self.tool_id, self.filter_settings)
+        result = self.manager.get_tool(self.tool_id, self.filter_settings)
 
         mock_get_tool.assert_called_once()
         mock_map_to_tool.assert_called_once_with({"data": "test_data"})
@@ -162,7 +162,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_tool.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_tool(self.project_id, tool_id=self.tool_id)
+        result = self.manager.delete_tool(tool_id=self.tool_id)
 
         mock_delete_tool.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -174,7 +174,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_tools.return_value = {"data": "test_data"}
         mock_map_to_tool_list.return_value = ToolList(tools=[])
 
-        result = self.manager.list_tools(self.project_id, self.filter_settings)
+        result = self.manager.list_tools(self.filter_settings)
 
         mock_list_tools.assert_called_once()
         mock_map_to_tool_list.assert_called_once_with({"data": "test_data"})
@@ -186,7 +186,7 @@ class TestAILabManager(unittest.TestCase):
         mock_publish_tool_revision.return_value = {"data": "test_data"}
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
 
-        result = self.manager.publish_tool_revision(self.project_id, self.tool_id, self.revision)
+        result = self.manager.publish_tool_revision(self.tool_id, self.revision)
 
         mock_publish_tool_revision.assert_called_once()
         mock_map_to_tool.assert_called_once_with({"data": "test_data"})
@@ -198,7 +198,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_parameter.return_value = {"data": "test_data"}
         mock_map_to_parameter_list.return_value = [ToolParameter(key="test_key", data_type="String", description="test_desc", is_required=True)]
 
-        result = self.manager.get_parameter(self.project_id, tool_id=self.tool_id, filter_settings=self.filter_settings)
+        result = self.manager.get_parameter(tool_id=self.tool_id, filter_settings=self.filter_settings)
 
         mock_get_parameter.assert_called_once()
         mock_map_to_parameter_list.assert_called_once_with({"data": "test_data"})
@@ -211,7 +211,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
         parameters = [ToolParameter(key="test_key", data_type="String", description="test_desc", is_required=True)]
 
-        result = self.manager.set_parameter(self.project_id, tool_id=self.tool_id, parameters=parameters)
+        result = self.manager.set_parameter(tool_id=self.tool_id, parameters=parameters)
 
         mock_set_parameter.assert_called_once()
         mock_map_to_tool.assert_called_once_with({"data": "test_data"})
@@ -236,7 +236,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_strategy.return_value = ReasoningStrategy(id="test_strategy", name="test_strategy", access_scope="private", type="addendum")
         strategy = ReasoningStrategy(name="test_strategy", access_scope="private", type="addendum", localized_descriptions=[])
 
-        result = self.manager.create_reasoning_strategy(self.project_id, strategy, automatic_publish=False)
+        result = self.manager.create_reasoning_strategy(strategy, automatic_publish=False)
 
         mock_create_strategy.assert_called_once()
         mock_map_to_strategy.assert_called_once_with({"data": "test_data"})
@@ -249,7 +249,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_strategy.return_value = ReasoningStrategy(id="test_strategy", name="test_strategy", access_scope="private", type="addendum")
         strategy = ReasoningStrategy(id="test_strategy", name="test_strategy", access_scope="private", type="addendum", localized_descriptions=[])
 
-        result = self.manager.update_reasoning_strategy(self.project_id, strategy, automatic_publish=False, upsert=False)
+        result = self.manager.update_reasoning_strategy(strategy, automatic_publish=False, upsert=False)
 
         mock_update_strategy.assert_called_once()
         mock_map_to_strategy.assert_called_once_with({"data": "test_data"})
@@ -261,7 +261,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_strategy.return_value = {"data": "test_data"}
         mock_map_to_strategy.return_value = ReasoningStrategy(id="test_strategy", name="test_strategy", access_scope="private", type="addendum")
 
-        result = self.manager.get_reasoning_strategy(self.project_id, reasoning_strategy_id="test_strategy")
+        result = self.manager.get_reasoning_strategy(reasoning_strategy_id="test_strategy")
 
         mock_get_strategy.assert_called_once()
         mock_map_to_strategy.assert_called_once_with({"data": "test_data"})
@@ -274,7 +274,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_process.return_value = AgenticProcess(id=self.process_id, name="test_process")
         process = AgenticProcess(name="test_process", key="test_key")
 
-        result = self.manager.create_process(self.project_id, process, automatic_publish=False)
+        result = self.manager.create_process(process, automatic_publish=False)
 
         mock_create_process.assert_called_once()
         mock_map_to_process.assert_called_once_with({"data": "test_data"})
@@ -287,7 +287,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_process.return_value = AgenticProcess(id=self.process_id, name="test_process")
         process = AgenticProcess(id=self.process_id, name="test_process", key="test_key")
 
-        result = self.manager.update_process(self.project_id, process, automatic_publish=False, upsert=False)
+        result = self.manager.update_process(process, automatic_publish=False, upsert=False)
 
         mock_update_process.assert_called_once()
         mock_map_to_process.assert_called_once_with({"data": "test_data"})
@@ -299,7 +299,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_process.return_value = {"data": "test_data"}
         mock_map_to_process.return_value = AgenticProcess(id=self.process_id, name="test_process")
 
-        result = self.manager.get_process(self.project_id, process_id=self.process_id, filter_settings=self.filter_settings)
+        result = self.manager.get_process(process_id=self.process_id, filter_settings=self.filter_settings)
 
         mock_get_process.assert_called_once()
         mock_map_to_process.assert_called_once_with({"data": "test_data"})
@@ -311,7 +311,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_processes.return_value = {"data": "test_data"}
         mock_map_to_process_list.return_value = AgenticProcessList(processes=[])
 
-        result = self.manager.list_processes(self.project_id, self.filter_settings)
+        result = self.manager.list_processes(self.filter_settings)
 
         mock_list_processes.assert_called_once()
         mock_map_to_process_list.assert_called_once_with({"data": "test_data"})
@@ -323,7 +323,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_instances.return_value = {"data": "test_data"}
         mock_map_to_instance_list.return_value = ProcessInstanceList(instances=[])
 
-        result = self.manager.list_process_instances(self.project_id, self.process_id, self.filter_settings)
+        result = self.manager.list_process_instances(self.process_id, self.filter_settings)
 
         mock_list_instances.assert_called_once()
         mock_map_to_instance_list.assert_called_once_with({"data": "test_data"})
@@ -335,7 +335,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_process.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_process(self.project_id, process_id=self.process_id)
+        result = self.manager.delete_process(process_id=self.process_id)
 
         mock_delete_process.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -347,7 +347,7 @@ class TestAILabManager(unittest.TestCase):
         mock_publish_process_revision.return_value = {"data": "test_data"}
         mock_map_to_process.return_value = AgenticProcess(id=self.process_id, name="test_process")
 
-        result = self.manager.publish_process_revision(self.project_id, process_id=self.process_id, revision=self.revision)
+        result = self.manager.publish_process_revision(process_id=self.process_id, revision=self.revision)
 
         mock_publish_process_revision.assert_called_once()
         mock_map_to_process.assert_called_once_with({"data": "test_data"})
@@ -360,7 +360,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_task.return_value = Task(id=self.task_id, name="test_task")
         task = Task(name="test_task")
 
-        result = self.manager.create_task(self.project_id, task, automatic_publish=False)
+        result = self.manager.create_task(task, automatic_publish=False)
 
         mock_create_task.assert_called_once()
         mock_map_to_task.assert_called_once_with({"data": "test_data"})
@@ -372,7 +372,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_task.return_value = {"data": "test_data"}
         mock_map_to_task.return_value = Task(id=self.task_id, name="test_task")
 
-        result = self.manager.get_task(self.project_id, task_id=self.task_id)
+        result = self.manager.get_task(task_id=self.task_id)
 
         mock_get_task.assert_called_once()
         mock_map_to_task.assert_called_once_with({"data": "test_data"})
@@ -384,7 +384,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_tasks.return_value = {"data": "test_data"}
         mock_map_to_task_list.return_value = TaskList(tasks=[])
 
-        result = self.manager.list_tasks(self.project_id, self.filter_settings)
+        result = self.manager.list_tasks(self.filter_settings)
 
         mock_list_tasks.assert_called_once()
         mock_map_to_task_list.assert_called_once_with({"data": "test_data"})
@@ -397,7 +397,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_task.return_value = Task(id=self.task_id, name="test_task")
         task = Task(id=self.task_id, name="test_task")
 
-        result = self.manager.update_task(self.project_id, task, automatic_publish=False, upsert=False)
+        result = self.manager.update_task(task, automatic_publish=False, upsert=False)
 
         mock_update_task.assert_called_once()
         mock_map_to_task.assert_called_once_with({"data": "test_data"})
@@ -409,7 +409,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_task.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_task(self.project_id, task_id=self.task_id)
+        result = self.manager.delete_task(task_id=self.task_id)
 
         mock_delete_task.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -421,7 +421,7 @@ class TestAILabManager(unittest.TestCase):
         mock_publish_task_revision.return_value = {"data": "test_data"}
         mock_map_to_task.return_value = Task(id=self.task_id, name="test_task")
 
-        result = self.manager.publish_task_revision(self.project_id, task_id=self.task_id, revision=self.revision)
+        result = self.manager.publish_task_revision(task_id=self.task_id, revision=self.revision)
 
         mock_publish_task_revision.assert_called_once()
         mock_map_to_task.assert_called_once_with({"data": "test_data"})
@@ -433,7 +433,7 @@ class TestAILabManager(unittest.TestCase):
         mock_start_instance.return_value = {"data": "test_data"}
         mock_map_to_instance.return_value = ProcessInstance(id=self.instance_id, subject="test_subject", process=AgenticProcess(name="test_process"))
 
-        result = self.manager.start_instance(self.project_id, "test_process", subject="test_subject", variables=VariableList())
+        result = self.manager.start_instance("test_process", subject="test_subject", variables=VariableList())
 
         mock_start_instance.assert_called_once()
         mock_map_to_instance.assert_called_once_with({"data": "test_data"})
@@ -445,7 +445,7 @@ class TestAILabManager(unittest.TestCase):
         mock_abort_instance.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.abort_instance(self.project_id, self.instance_id)
+        result = self.manager.abort_instance(self.instance_id)
 
         mock_abort_instance.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -457,7 +457,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_instance.return_value = {"data": "test_data"}
         mock_map_to_instance.return_value = ProcessInstance(id=self.instance_id, subject="test_subject", process=AgenticProcess(name="test_process"))
 
-        result = self.manager.get_instance(self.project_id, self.instance_id)
+        result = self.manager.get_instance(self.instance_id)
 
         mock_get_instance.assert_called_once()
         mock_map_to_instance.assert_called_once_with({"data": "test_data"})
@@ -467,7 +467,7 @@ class TestAILabManager(unittest.TestCase):
     def test_get_instance_history_success(self, mock_get_instance_history):
         mock_get_instance_history.return_value = {"history": "test_history"}
 
-        result = self.manager.get_instance_history(self.project_id, self.instance_id)
+        result = self.manager.get_instance_history(self.instance_id)
 
         mock_get_instance_history.assert_called_once()
         self.assertIsInstance(result, dict)
@@ -476,7 +476,7 @@ class TestAILabManager(unittest.TestCase):
     def test_get_thread_information_success(self, mock_get_thread_information):
         mock_get_thread_information.return_value = {"info": "test_info"}
 
-        result = self.manager.get_thread_information(self.project_id, "test_thread")
+        result = self.manager.get_thread_information("test_thread")
 
         mock_get_thread_information.assert_called_once()
         self.assertIsInstance(result, dict)
@@ -487,7 +487,7 @@ class TestAILabManager(unittest.TestCase):
         mock_send_user_signal.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.send_user_signal(self.project_id, self.instance_id, "test_signal")
+        result = self.manager.send_user_signal(self.instance_id, "test_signal")
 
         mock_send_user_signal.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -500,7 +500,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_kb.return_value = KnowledgeBase(id=self.kb_id, name="test_kb")
         kb = KnowledgeBase(name="test_kb")
 
-        result = self.manager.create_knowledge_base(self.project_id, kb)
+        result = self.manager.create_knowledge_base(kb)
 
         mock_create_kb.assert_called_once()
         mock_map_to_kb.assert_called_once_with({"data": "test_data"})
@@ -512,7 +512,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_kbs.return_value = {"data": "test_data"}
         mock_map_to_kb_list.return_value = KnowledgeBaseList(knowledge_bases=[])
 
-        result = self.manager.list_knowledge_bases(self.project_id, start=0, count=10)
+        result = self.manager.list_knowledge_bases(start=0, count=10)
 
         mock_list_kbs.assert_called_once()
         mock_map_to_kb_list.assert_called_once_with({"data": "test_data"})
@@ -524,7 +524,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_kb.return_value = {"data": "test_data"}
         mock_map_to_kb.return_value = KnowledgeBase(id=self.kb_id, name="test_kb")
 
-        result = self.manager.get_knowledge_base(self.project_id, kb_id=self.kb_id)
+        result = self.manager.get_knowledge_base(kb_id=self.kb_id)
 
         mock_get_kb.assert_called_once()
         mock_map_to_kb.assert_called_once_with({"data": "test_data"})
@@ -536,7 +536,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_kb.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_knowledge_base(self.project_id, kb_id=self.kb_id)
+        result = self.manager.delete_knowledge_base(kb_id=self.kb_id)
 
         mock_delete_kb.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -548,7 +548,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_jobs.return_value = {"data": "test_data"}
         mock_map_to_job_list.return_value = JobList(jobs=[])
 
-        result = self.manager.list_jobs(self.project_id, self.filter_settings)
+        result = self.manager.list_jobs(self.filter_settings)
 
         mock_list_jobs.assert_called_once()
         mock_map_to_job_list.assert_called_once_with({"data": "test_data"})

{pygeai-0.2.7b37 → pygeai-0.2.7b38/pygeai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeai
-Version: 0.2.7b37
+Version: 0.2.7b38
 Summary: Software Development Kit to interact with Globant Enterprise AI.
 Author-email: Globant <geai-sdk@globant.com>
 License-Expression: MIT

{pygeai-0.2.7b37 → pygeai-0.2.7b38}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygeai"
-version = "0.2.7b37"
+version = "0.2.7b38"
 description = "Software Development Kit to interact with Globant Enterprise AI."
 license = "MIT"
 requires-python = ">=3.10"

pygeai-0.2.7b37/pygeai/organization/responses.py

@@ -1,24 +0,0 @@
-from pydantic.main import BaseModel
-
-from pygeai.core.models import Assistant, Project, ProjectToken, \
-    RequestItem
-
-
-class AssistantListResponse(BaseModel):
-    assistants: list[Assistant]
-
-
-class ProjectListResponse(BaseModel):
-    projects: list[Project]
-
-
-class ProjectDataResponse(BaseModel):
-    project: Project
-
-
-class ProjectTokensResponse(BaseModel):
-    tokens: list[ProjectToken]
-
-
-class ProjectItemListResponse(BaseModel):
-    items: list[RequestItem]