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

pygeai/tests/auth/test_clients.py

@@ -3,7 +3,7 @@ from unittest.mock import patch, MagicMock
 from json import JSONDecodeError
 
 from pygeai.auth.clients import AuthClient
-from pygeai.core.common.exceptions import InvalidAPIResponseException
+from pygeai.core.common.exceptions import InvalidAPIResponseException, APIResponseError
 
 
 class TestAuthClient(unittest.TestCase):
@@ -14,6 +14,7 @@ class TestAuthClient(unittest.TestCase):
     def setUp(self):
         self.client = AuthClient()
         self.mock_response = MagicMock()
+        self.mock_response.status_code = 200  # Default to success status
 
     @patch('pygeai.core.services.rest.ApiService.get')
     def test_get_oauth2_access_token_success(self, mock_get):
@@ -50,19 +51,18 @@ class TestAuthClient(unittest.TestCase):
         self.assertEqual(call_args[1]['params']['scope'], "custom_scope")
 
     @patch('pygeai.core.services.rest.ApiService.get')
-    def test_get_oauth2_access_token_json_decode_error(self, mock_get):
-        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+    def test_get_oauth2_access_token_error_status(self, mock_get):
         self.mock_response.status_code = 401
         self.mock_response.text = "Invalid credentials"
         mock_get.return_value = self.mock_response
         
-        with self.assertRaises(InvalidAPIResponseException) as context:
+        with self.assertRaises(APIResponseError) as context:
             self.client.get_oauth2_access_token(
                 client_id="client-123",
                 username="user@example.com",
                 password="wrong"
             )
-        self.assertIn("Unable to  obtain Oauth2 access token", str(context.exception))
+        self.assertIn("API returned an error", str(context.exception))
 
     @patch.object(AuthClient, 'api_service', create=True)
     def test_get_user_profile_information_success(self, mock_api_service):
@@ -96,9 +96,185 @@ class TestAuthClient(unittest.TestCase):
         client = AuthClient()
         client.api_service = mock_api_service
         
-        with self.assertRaises(InvalidAPIResponseException) as context:
+        with self.assertRaises(APIResponseError) as context:
             client.get_user_profile_information("invalid-token")
-        self.assertIn("Unable to retrieve user profile information", str(context.exception))
+        self.assertIn("API returned an error", str(context.exception))
+
+    @patch('pygeai.core.services.rest.ApiService.post')
+    def test_create_project_api_token_success(self, mock_post):
+        self.mock_response.json.return_value = {
+            "id": "test_token_id",
+            "name": "TestToken",
+            "description": "Test Token",
+            "status": "Active",
+            "scope": "Pia.Data.Organization",
+            "organization": "org-123",
+            "project": "project-123",
+            "messages": [
+                {
+                    "id": 0,
+                    "description": "Token created successfully",
+                    "type": "Success"
+                }
+            ],
+            "errors": []
+        }
+        mock_post.return_value = self.mock_response
+        
+        result = self.client.create_project_api_token(
+            project_id="project-123",
+            name="TestToken",
+            description="Test Token"
+        )
+        
+        mock_post.assert_called_once()
+        call_args = mock_post.call_args
+        self.assertEqual(call_args[1]['data']['name'], "TestToken")
+        self.assertEqual(call_args[1]['data']['description'], "Test Token")
+        self.assertEqual(call_args[1]['headers']['project-id'], "project-123")
+        self.assertEqual(result['name'], "TestToken")
+        self.assertEqual(result['id'], "test_token_id")
+
+    @patch('pygeai.core.services.rest.ApiService.post')
+    def test_create_project_api_token_without_description(self, mock_post):
+        self.mock_response.json.return_value = {
+            "id": "test_token_id",
+            "name": "TestToken",
+            "status": "Active"
+        }
+        mock_post.return_value = self.mock_response
+        
+        result = self.client.create_project_api_token(
+            project_id="project-123",
+            name="TestToken"
+        )
+        
+        call_args = mock_post.call_args
+        self.assertNotIn('description', call_args[1]['data'])
+
+    @patch('pygeai.core.services.rest.ApiService.post')
+    def test_create_project_api_token_json_decode_error(self, mock_post):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 400
+        self.mock_response.text = "Bad request"
+        mock_post.return_value = self.mock_response
+        
+        with self.assertRaises(APIResponseError) as context:
+            self.client.create_project_api_token(
+                project_id="project-123",
+                name="TestToken"
+            )
+        self.assertIn("API returned an error", str(context.exception))
+
+    @patch('pygeai.core.services.rest.ApiService.delete')
+    def test_delete_project_api_token_success(self, mock_delete):
+        self.mock_response.json.return_value = {}
+        mock_delete.return_value = self.mock_response
+        
+        result = self.client.delete_project_api_token(api_token_id="token-123")
+        
+        mock_delete.assert_called_once()
+        call_args = mock_delete.call_args
+        self.assertIn("token-123", call_args[1]['endpoint'])
+        self.assertEqual(result, {})
+
+    @patch('pygeai.core.services.rest.ApiService.delete')
+    def test_delete_project_api_token_json_decode_error(self, mock_delete):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 404
+        self.mock_response.text = "Not found"
+        mock_delete.return_value = self.mock_response
+        
+        with self.assertRaises(APIResponseError) as context:
+            self.client.delete_project_api_token(api_token_id="invalid-token")
+        self.assertIn("API returned an error", str(context.exception))
+
+    @patch('pygeai.core.services.rest.ApiService.put')
+    def test_update_project_api_token_success(self, mock_put):
+        self.mock_response.json.return_value = [
+            {
+                "description": "Token updated successfully",
+                "type": "Success"
+            }
+        ]
+        mock_put.return_value = self.mock_response
+        
+        result = self.client.update_project_api_token(
+            api_token_id="token-123",
+            description="Updated description",
+            status="blocked"
+        )
+        
+        mock_put.assert_called_once()
+        call_args = mock_put.call_args
+        self.assertEqual(call_args[1]['data']['description'], "Updated description")
+        self.assertEqual(call_args[1]['data']['status'], "blocked")
+        self.assertIsInstance(result, list)
+        self.assertEqual(result[0]['type'], "Success")
+
+    @patch('pygeai.core.services.rest.ApiService.put')
+    def test_update_project_api_token_only_description(self, mock_put):
+        self.mock_response.json.return_value = [
+            {
+                "description": "Token updated successfully",
+                "type": "Success"
+            }
+        ]
+        mock_put.return_value = self.mock_response
+        
+        result = self.client.update_project_api_token(
+            api_token_id="token-123",
+            description="New description"
+        )
+        
+        call_args = mock_put.call_args
+        self.assertEqual(call_args[1]['data']['description'], "New description")
+        self.assertNotIn('status', call_args[1]['data'])
+
+    @patch('pygeai.core.services.rest.ApiService.put')
+    def test_update_project_api_token_json_decode_error(self, mock_put):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 400
+        self.mock_response.text = "Bad request"
+        mock_put.return_value = self.mock_response
+        
+        with self.assertRaises(APIResponseError) as context:
+            self.client.update_project_api_token(
+                api_token_id="token-123",
+                description="New description"
+            )
+        self.assertIn("API returned an error", str(context.exception))
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_project_api_token_success(self, mock_get):
+        self.mock_response.json.return_value = {
+            "id": "token-123",
+            "name": "Default",
+            "description": "Default token",
+            "status": "Active",
+            "scope": "Pia.Data.Organization",
+            "timestamp": "2024-07-22T18:37:32.341"
+        }
+        mock_get.return_value = self.mock_response
+        
+        result = self.client.get_project_api_token(api_token_id="token-123")
+        
+        mock_get.assert_called_once()
+        call_args = mock_get.call_args
+        self.assertIn("token-123", call_args[1]['endpoint'])
+        self.assertEqual(result['id'], "token-123")
+        self.assertEqual(result['status'], "Active")
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_project_api_token_json_decode_error(self, mock_get):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 404
+        self.mock_response.text = "Not found"
+        mock_get.return_value = self.mock_response
+        
+        with self.assertRaises(APIResponseError) as context:
+            self.client.get_project_api_token(api_token_id="invalid-token")
+        self.assertIn("API returned an error", str(context.exception))
 
 
 if __name__ == '__main__':

pygeai/tests/organization/test_clients.py

@@ -5,7 +5,8 @@ from unittest.mock import patch
 from pygeai.organization.clients import OrganizationClient
 from pygeai.core.common.exceptions import InvalidAPIResponseException
 from pygeai.organization.endpoints import GET_ASSISTANT_LIST_V1, GET_PROJECT_LIST_V1, GET_PROJECT_V1, CREATE_PROJECT_V1, \
-    UPDATE_PROJECT_V1, DELETE_PROJECT_V1, GET_PROJECT_TOKENS_V1, GET_REQUEST_DATA_V1
+    UPDATE_PROJECT_V1, DELETE_PROJECT_V1, GET_PROJECT_TOKENS_V1, GET_REQUEST_DATA_V1, GET_MEMBERSHIPS_V2, \
+    GET_PROJECT_MEMBERSHIPS_V2, GET_PROJECT_ROLES_V2, GET_PROJECT_MEMBERS_V2, GET_ORGANIZATION_MEMBERS_V2
 
 
 class TestOrganizationClient(unittest.TestCase):
@@ -293,3 +294,185 @@ class TestOrganizationClient(unittest.TestCase):
         )
         self.assertEqual(str(context.exception), "Unable to export request data: Invalid JSON response")
 
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_memberships_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+            "count": 1,
+            "pages": 1,
+            "organizationsMemberships": [
+                {
+                    "organizationId": "org-123",
+                    "organizationName": "Test Org",
+                    "projectsMemberships": []
+                }
+            ]
+        }
+
+        result = self.client.get_memberships()
+
+        mock_get.assert_called_once_with(
+            endpoint=GET_MEMBERSHIPS_V2,
+            params={"startPage": 1, "pageSize": 20, "orderDirection": "desc"}
+        )
+        self.assertIsNotNone(result)
+        self.assertEqual(result['count'], 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_memberships_with_params(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {"count": 0, "pages": 0, "organizationsMemberships": []}
+
+        result = self.client.get_memberships(
+            email="test@example.com",
+            start_page=2,
+            page_size=10,
+            order_key="organizationName",
+            order_direction="asc",
+            role_types="backend,frontend"
+        )
+
+        mock_get.assert_called_once_with(
+            endpoint=GET_MEMBERSHIPS_V2,
+            params={
+                "email": "test@example.com",
+                "startPage": 2,
+                "pageSize": 10,
+                "orderKey": "organizationName",
+                "orderDirection": "asc",
+                "roleTypes": "backend,frontend"
+            }
+        )
+        self.assertIsNotNone(result)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_memberships_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_memberships()
+
+        self.assertEqual(str(context.exception), "Unable to get memberships: Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_memberships_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+            "count": 1,
+            "pages": 1,
+            "projectsMemberships": [
+                {
+                    "organizationId": "org-123",
+                    "organizationName": "Test Org",
+                    "projectId": "proj-456",
+                    "projectName": "Test Project",
+                    "roles": []
+                }
+            ]
+        }
+
+        result = self.client.get_project_memberships()
+
+        mock_get.assert_called_once_with(
+            endpoint=GET_PROJECT_MEMBERSHIPS_V2,
+            params={"startPage": 1, "pageSize": 20, "orderDirection": "desc"}
+        )
+        self.assertIsNotNone(result)
+        self.assertEqual(result['count'], 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_memberships_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_project_memberships()
+
+        self.assertEqual(str(context.exception), "Unable to get project memberships: Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_roles_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+            "roles": [
+                {"id": "role-1", "name": "Admin", "externalId": "admin-ext", "type": "backend", "origin": "system"}
+            ]
+        }
+
+        result = self.client.get_project_roles(project_id="proj-123")
+
+        mock_get.assert_called_once_with(endpoint=GET_PROJECT_ROLES_V2, params={"projectId": "proj-123"})
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result['roles']), 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_roles_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_project_roles(project_id="proj-123")
+
+        self.assertEqual(str(context.exception), "Unable to get project roles for project 'proj-123': Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_members_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+            "members": [
+                {"email": "user@example.com", "roles": []}
+            ]
+        }
+
+        result = self.client.get_project_members(project_id="proj-123")
+
+        mock_get.assert_called_once_with(endpoint=GET_PROJECT_MEMBERS_V2, params={"projectId": "proj-123"})
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result['members']), 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_members_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_project_members(project_id="proj-123")
+
+        self.assertEqual(str(context.exception), "Unable to get project members for project 'proj-123': Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_organization_members_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+            "members": [
+                {"email": "user@example.com", "roles": []}
+            ]
+        }
+
+        result = self.client.get_organization_members(organization_id="org-123")
+
+        mock_get.assert_called_once_with(endpoint=GET_ORGANIZATION_MEMBERS_V2, params={"organizationId": "org-123"})
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result['members']), 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_organization_members_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_organization_members(organization_id="org-123")
+
+        self.assertEqual(str(context.exception), "Unable to get organization members for organization 'org-123': Invalid JSON response")
+

pygeai/tests/organization/test_managers.py

@@ -9,7 +9,8 @@ from pygeai.core.base.responses import EmptyResponse
 from pygeai.organization.managers import OrganizationManager
 from pygeai.organization.mappers import OrganizationResponseMapper
 from pygeai.organization.responses import AssistantListResponse, ProjectListResponse, ProjectDataResponse, \
-    ProjectTokensResponse, ProjectItemListResponse
+    ProjectTokensResponse, ProjectItemListResponse, MembershipsResponse, ProjectMembershipsResponse, \
+    ProjectRolesResponse, ProjectMembersResponse, OrganizationMembersResponse
 
 
 class TestOrganizationManager(unittest.TestCase):
@@ -261,3 +262,123 @@ class TestOrganizationManager(unittest.TestCase):
             skip=0,
             count=0
         )
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_memberships")
+    def test_get_memberships(self, mock_get_memberships):
+        mock_response = MembershipsResponse(count=0, pages=0, organizations=[])
+        mock_get_memberships.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_memberships_response', return_value=mock_response):
+            response = self.manager.get_memberships()
+
+        self.assertIsInstance(response, MembershipsResponse)
+        self.assertEqual(response.count, 0)
+        mock_get_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_memberships")
+    def test_get_memberships_error(self, mock_get_memberships):
+        mock_get_memberships.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Access denied"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_memberships()
+
+        self.assertIn("Error received while retrieving memberships", str(context.exception))
+        mock_get_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_memberships")
+    def test_get_project_memberships(self, mock_get_project_memberships):
+        mock_response = ProjectMembershipsResponse(count=0, pages=0, projects=[])
+        mock_get_project_memberships.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_memberships_response', return_value=mock_response):
+            response = self.manager.get_project_memberships()
+
+        self.assertIsInstance(response, ProjectMembershipsResponse)
+        self.assertEqual(response.count, 0)
+        mock_get_project_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_memberships")
+    def test_get_project_memberships_error(self, mock_get_project_memberships):
+        mock_get_project_memberships.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Access denied"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_memberships()
+
+        self.assertIn("Error received while retrieving project memberships", str(context.exception))
+        mock_get_project_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_roles")
+    def test_get_project_roles(self, mock_get_project_roles):
+        mock_response = ProjectRolesResponse(roles=[])
+        mock_get_project_roles.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_roles_response', return_value=mock_response):
+            response = self.manager.get_project_roles("proj-123")
+
+        self.assertIsInstance(response, ProjectRolesResponse)
+        self.assertEqual(response.roles, [])
+        mock_get_project_roles.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_roles")
+    def test_get_project_roles_error(self, mock_get_project_roles):
+        mock_get_project_roles.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_roles("proj-123")
+
+        self.assertIn("Error received while retrieving project roles", str(context.exception))
+        mock_get_project_roles.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_members")
+    def test_get_project_members(self, mock_get_project_members):
+        mock_response = ProjectMembersResponse(members=[])
+        mock_get_project_members.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_members_response', return_value=mock_response):
+            response = self.manager.get_project_members("proj-123")
+
+        self.assertIsInstance(response, ProjectMembersResponse)
+        self.assertEqual(response.members, [])
+        mock_get_project_members.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_members")
+    def test_get_project_members_error(self, mock_get_project_members):
+        mock_get_project_members.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_members("proj-123")
+
+        self.assertIn("Error received while retrieving project members", str(context.exception))
+        mock_get_project_members.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_organization_members")
+    def test_get_organization_members(self, mock_get_organization_members):
+        mock_response = OrganizationMembersResponse(members=[])
+        mock_get_organization_members.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_organization_members_response', return_value=mock_response):
+            response = self.manager.get_organization_members("org-123")
+
+        self.assertIsInstance(response, OrganizationMembersResponse)
+        self.assertEqual(response.members, [])
+        mock_get_organization_members.assert_called_once_with(organization_id="org-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_organization_members")
+    def test_get_organization_members_error(self, mock_get_organization_members):
+        mock_get_organization_members.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Organization not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_organization_members("org-123")
+
+        self.assertIn("Error received while retrieving organization members", str(context.exception))
+        mock_get_organization_members.assert_called_once_with(organization_id="org-123")

pygeai/tests/snippets/organization/get_memberships.py

@@ -0,0 +1,12 @@
+from pygeai.organization.managers import OrganizationManager
+
+manager = OrganizationManager(alias="sdkorg")
+
+response = manager.get_memberships(
+    email="alejandro.trinidad@globant.com",
+    start_page=1,
+    page_size=10,
+    #order_key="organizationName",
+    #order_direction="asc"
+)
+print(f"response: {response}")

pygeai/tests/snippets/organization/get_organization_members.py

@@ -0,0 +1,6 @@
+from pygeai.organization.managers import OrganizationManager
+
+manager = OrganizationManager()
+
+response = manager.get_organization_members(organization_id="4aa15b61-d3c7-4a5c-99b8-052d18a04ff2")
+print(f"response: {response}")

pygeai/tests/snippets/organization/get_project_members.py

@@ -0,0 +1,6 @@
+from pygeai.organization.managers import OrganizationManager
+
+manager = OrganizationManager()
+
+response = manager.get_project_members(project_id="1956c032-3c66-4435-acb8-6a06e52f819f")
+print(f"response: {response}")

pygeai/tests/snippets/organization/get_project_memberships.py

@@ -0,0 +1,12 @@
+from pygeai.organization.managers import OrganizationManager
+
+manager = OrganizationManager()
+
+response = manager.get_project_memberships(
+    email="user@example.com",
+    start_page=1,
+    page_size=10,
+    order_key="projectName",
+    order_direction="desc"
+)
+print(f"response: {response}")

pygeai/tests/snippets/organization/get_project_roles.py

@@ -0,0 +1,6 @@
+from pygeai.organization.managers import OrganizationManager
+
+manager = OrganizationManager(alias="sdkorg")
+
+response = manager.get_project_roles(project_id="2ca6883f-6778-40bb-bcc1-85451fb11107")
+print(f"response: {response}")

{pygeai-0.6.0b6.dist-info → pygeai-0.6.0b7.dist-info}/METADATA

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