msfabricpysdkcore 0.0.3__py3-none-any.whl → 0.0.4__py3-none-any.whl

msfabricpysdkcore/domain.py

@@ -0,0 +1,378 @@
+import json
+from time import sleep
+
+import requests
+from msfabricpysdkcore.long_running_operation import check_long_running_operation
+
+class Domain:
+    """Class to represent a domain in Microsoft Fabric"""
+
+    def __init__(self, id, display_name, description, parent_domain_id, contributors_scope, auth):
+        """Constructor for the Domain class
+        
+        Args:
+            id (str): The ID of the domain
+            display_name (str): The display name of the domain
+            description (str): The description of the domain
+            parent_domain_id (str): The parent domain ID of the domain
+            contributors_scope (str): The contributors scope of the domain
+        Returns:
+            Domain: The Domain object created"""
+
+        self.id = id
+        self.display_name = display_name
+        self.description = description
+        self.parent_domain_id = parent_domain_id
+        self.contributors_scope = contributors_scope
+
+        self.auth = auth
+
+    def __str__(self):
+        """Method to return a string representation of the Domain object
+        
+        Returns:
+            str: The string representation of the Domain object
+        """
+        dic = {
+            'id': self.id,
+            'display_name': self.display_name,
+            'description': self.description,
+            'parent_domain_id': self.parent_domain_id,
+            'contributors_scope': self.contributors_scope
+        }
+        return json.dumps(dic, indent=2)
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def from_dict(dic, auth):
+        """Method to create a Domain object from a dictionary
+        
+        Args:
+            dic (dict): The dictionary containing the domain information
+        Returns:
+            Domain: The Domain object created from the dictionary
+        
+        """
+        if "display_name" not in dic:
+            dic["display_name"] = dic["displayName"]
+        if "parent_domain_id" not in dic:
+            dic["parent_domain_id"] = dic["parentDomainId"]
+        if "contributors_scope" not in dic:
+            dic["contributors_scope"] = dic["contributorsScope"]
+        return Domain(id=dic['id'], display_name=dic['display_name'],
+                      description=dic['description'], parent_domain_id=dic['parent_domain_id'], 
+                      contributors_scope=dic['contributors_scope'], auth=auth)
+
+    def list_domain_workspaces(self, workspace_objects = False, continuationToken = None):
+        """Method to list the workspaces in the domain
+        
+        Args:
+            continuationToken (str): The continuation token to use for pagination
+        Returns:
+            list: The list of workspaces in the domain
+        """
+        if workspace_objects:
+            from msfabricpysdkcore import FabricClientCore
+            fc = FabricClientCore()
+                    
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}/workspaces"
+        if continuationToken:
+            url = f"{url}?continuationToken={continuationToken}"
+
+        for _ in range(10):
+            response = requests.get(url=url, headers=self.auth.get_headers())
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error listing workspaces: {response.text}")
+            break
+
+        resp_dict = json.loads(response.text)
+        workspaces = resp_dict["value"]
+
+        if workspace_objects:
+            workspaces = [fc.get_workspace_by_id(workspace["id"]) for workspace in workspaces]
+
+        if "continuationToken" in resp_dict:
+            workspaces_next = self.list_domain_workspaces(continuationToken=resp_dict["continuationToken"])
+            workspaces.extend(workspaces_next)
+
+        return workspaces
+    
+    def delete(self):
+        """Method to delete the domain
+
+        Returns:
+            int: The status code of the response
+        """
+        # DELETE https://api.fabric.microsoft.com/v1/admin/domains/{domainId}
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}"
+        for _ in range(10):
+            response = requests.delete(url=url, headers=self.auth.get_headers())
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error deleting domain: {response.text}")
+            break
+
+        return response.status_code
+    
+
+    # PATCH https://api.fabric.microsoft.com/v1/admin/domains/{domainId}
+
+    def update(self, description = None, display_name = None, contributors_scope = None):
+        """Method to update the domain
+        
+        Args:
+            description (str): The description of the domain
+            display_name (str): The display name of the domain
+            contributors_scope (str): The contributors scope of the domain
+        Returns:
+             Domain: The Domain object created from the dictionary
+        """
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}"
+        body = {}
+        if description:
+            body["description"] = description
+        else:
+            body["description"] = self.description
+
+        if display_name:
+            body["displayName"] = display_name
+        else:
+            body["displayName"] = self.display_name
+
+        if contributors_scope:
+            body["contributorsScope"] = contributors_scope
+        else:
+            body["contributorsScope"] = self.contributors_scope
+
+        for _ in range(10):
+            response = requests.patch(url=url, headers=self.auth.get_headers(), json=body)
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error updating domain: {response.text}")
+            break
+
+        self.description = body["description"]
+        self.display_name = body["displayName"]
+        self.contributors_scope = body["contributorsScope"]
+
+        return self
+    
+    def assign_workspaces_by_capacities(self, capacities_ids, wait_for_completion=True):
+        """Method to assign workspaces to the domain based on capacities_ids
+        
+        Args:
+            capacities_ids (list): The list of capacitiy ids to assign workspaces
+        Returns:
+            int: The status code of the response
+        """
+        # POST https://api.fabric.microsoft.com/v1/admin/domains/{domainId}/assignWorkspacesByCapacities
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}/assignWorkspacesByCapacities"
+
+        body = {
+            "capacitiesIds": capacities_ids
+        }
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code == 202 and wait_for_completion:
+                check_long_running_operation(response.headers, self.auth)
+            if response.status_code not in (202, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error assigning workspaces by capacities: {response.text}")
+            break
+
+        return response.status_code
+
+
+    def assign_workspaces_by_ids(self, workspaces_ids):
+
+        """Method to assign workspaces to the domain based on workspaces_ids
+        
+        Args:
+            workspaces_ids (list): The list of workspace ids to assign workspaces
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}/assignWorkspaces"
+        body = {
+            "workspacesIds": workspaces_ids
+        }
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error assigning workspaces by ids: {response.text}")
+            break
+
+        return response.status_code
+    
+
+    def assign_workspaces_by_principals(self, principals, wait_for_completion=True):
+        """Method to assign workspaces to the domain based on principals
+        
+        Args:
+            principals (list): The list of principals to assign workspaces
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}/assignWorkspacesByPrincipals"
+        body = {
+            "principals": principals
+        }
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code == 202 and wait_for_completion:
+                check_long_running_operation(response.headers, self.auth)
+            if response.status_code not in (202, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error assigning workspaces by principals: {response.text}")
+            break
+
+        return response.status_code
+    
+    # POST https://api.fabric.microsoft.com/v1/admin/domains/{domainId}/roleAssignments/bulkAssign
+
+    def role_assignments_bulk_assign(self, type, principals):
+        """Method to bulk assign role assignments
+        
+        Args:
+            type (str): The type of the role assignment
+            principals (list): The list of principals to assign the role
+        Returns:
+            int: The status code of the response
+        """
+        
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}/roleAssignments/bulkAssign"
+        body = {
+            "type": type,
+            "principals": principals
+        }
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error bulk assigning role assignments: {response.text}")
+            break
+
+        return response.status_code
+    
+
+    def role_assignments_bulk_unassign(self, type, principals):
+        """Method to bulk unassign role assignments
+        
+        Args:
+            type (str): The type of the role assignment
+            principals (list): The list of principals to unassign the role
+        Returns:
+            int: The status code of the response
+        """
+        
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}/roleAssignments/bulkUnassign"
+        body = {
+            "type": type,
+            "principals": principals
+        }
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error bulk unassigning role assignments: {response.text}")
+            break
+
+        return response.status_code
+    
+
+    def unassign_all_workspaces(self):
+        """Method to unassign all workspaces from the domain
+        
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}/unassignAllWorkspaces"
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers())
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error unassigning all workspaces: {response.text}")
+            break
+
+        return response.status_code
+    
+    def unassign_workspaces_by_ids(self, workspace_ids):
+        """Method to unassign workspaces from the domain
+        
+        Args:
+            workspace_ids (list): The list of workspace ids to unassign
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/admin/domains/{self.id}/unassignWorkspaces"
+        body = {
+            "workspacesIds": workspace_ids
+        }
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error unassigning workspaces by ids: {response.text}")
+            break
+
+        return response.status_code

msfabricpysdkcore/item.py

@@ -35,6 +35,9 @@ class Item:
         }
         return json.dumps(dict_, indent=2)
     
+    def __repr__(self) -> str:
+        return self.__str__()
+    
     def from_dict(item_dict, auth):
         """Create Item object from dictionary"""
         

msfabricpysdkcore/job_instance.py

@@ -39,6 +39,9 @@ class JobInstance:
         }
         return json.dumps(dict_, indent=2)
     
+    def __repr__(self) -> str:
+        return self.__str__()
+    
     def from_dict(job_dict, auth):
         """Create JobInstance object from dictionary"""
         return JobInstance(id=job_dict['id'], item_id=job_dict['itemId'], workspace_id=job_dict['workspaceId'],

msfabricpysdkcore/onelakeshortcut.py

@@ -27,6 +27,9 @@ class OneLakeShortcut:
         }
         return json.dumps(dict_, indent=2)
     
+    def __repr__(self) -> str:
+        return self.__str__()
+    
     def from_dict(short_dict, auth):
         """Create OneLakeShortCut object from dictionary"""
         return OneLakeShortcut(name=short_dict['name'],

msfabricpysdkcore/tests/test_admin_apis.py

@@ -0,0 +1,69 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientAdmin
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+
+                  
+    def test_domains(self):
+        fca = FabricClientAdmin()
+
+        user_id = 'b4f4e299-e6e1-4667-886c-57e4a8dde1c2'
+
+        # List workspaces
+        ws = fca.list_workspaces(name="testworkspace")[0]
+
+        self.assertEqual(ws.name, "testworkspace")
+
+        # Get workspace
+        ws_clone = fca.get_workspace(workspace_id=ws.id)
+
+        self.assertEqual(ws.id, ws_clone.id)
+
+        # Get workspace access details
+
+        ws_access = fca.get_workspace_access_details(ws.id)
+        principials = ws_access["accessDetails"]
+        principials_ids = [p["principal"]["id"] for p in principials]
+        self.assertIn(user_id, principials_ids)
+
+        # Get access entities
+
+        access_entities = fca.get_access_entities(user_id, type="Notebook")
+        self.assertGreater(len(access_entities), 0)
+
+        # Get tenant settings
+
+        tenant_settings = fca.get_tenant_settings()
+        self.assertGreater(len(tenant_settings["tenantSettings"]), 0)
+
+        # Get capacity tenant settings overrides
+
+        overrides = fca.get_capacities_tenant_settings_overrides()
+        self.assertGreater(len(overrides), -1)
+
+        # List items
+
+        item_list = fca.list_items(workspace_id=ws.id)
+        self.assertGreater(len(item_list), 0)
+
+        # Get item
+
+        item = fca.get_item(workspace_id=ws.id, item_id=item_list[0].id)
+        self.assertEqual(item.id, item_list[0].id)
+
+        # Get item access details
+
+        item_access = fca.get_item_access_details(workspace_id=ws.id, item_id=item_list[0].id)
+        principials = item_access["accessDetails"]
+
+        principials_ids = [p["principal"]["id"] for p in principials]
+
+        self.assertIn(user_id, principials_ids)
+
+

msfabricpysdkcore/tests/test_domains.py

@@ -0,0 +1,125 @@
+import unittest
+from dotenv import load_dotenv
+from datetime import datetime
+from msfabricpysdkcore import FabricClientCore, FabricClientAdmin
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+
+                  
+    def test_domains(self):
+        fcc = FabricClientCore()
+        fca = FabricClientAdmin()
+
+        ws = fcc.get_workspace_by_name("sdktestdomains")
+        cap = fcc.get_capacity(capacity_id=ws.capacity_id)
+        principal = {'id': 'b4f4e299-e6e1-4667-886c-57e4a8dde1c2',  'type': 'User'}
+
+        # Delete if exists
+        try:
+            domain = fca.get_domain_by_name("sdktestdomains")
+            domain.delete()
+        except:
+            pass
+        try:
+            domain = fca.get_domain_by_name("sdktestdomains2")
+            domain.delete()
+        except:
+            pass
+
+        # Create domain
+        domain_name = "sdktestdomains"
+        domain = fca.create_domain(display_name=domain_name)
+        self.assertIsNotNone(domain.id)
+        self.assertEqual(domain.display_name, domain_name)
+
+        # Get domain by name
+        domain_clone = fca.get_domain_by_name(domain_name)
+        self.assertIsNotNone(domain_clone.id)
+        self.assertEqual(domain_clone.display_name, domain_name)
+
+        # Get domain by id
+        domain_clone = fca.get_domain_by_id(domain.id)
+        self.assertIsNotNone(domain_clone.id)
+        self.assertEqual(domain_clone.display_name, domain_name)
+
+        # List domains
+        domains = fca.list_domains()
+        self.assertGreater(len(domains), 0)
+        domains_ids = [d.id for d in domains]
+        self.assertIn(domain.id, domains_ids)
+
+        # Update domain
+        domain_new_name = "sdktestdomains2"
+        domain_clone = fca.update_domain(domain.id, display_name=domain_new_name)
+        self.assertEqual(domain_clone.display_name, domain_new_name)
+
+        # Assign domain workspaces by Ids
+        status_code = fca.assign_domain_workspaces_by_ids(domain.id, [ws.id])
+        self.assertEqual(status_code, 200)
+
+        # List domain workspaces
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w.id for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Unassign domain workspaces by ids
+        status_code = fca.unassign_domain_workspaces_by_ids(domain.id, [ws.id])
+        self.assertEqual(status_code, 200)
+
+        workspaces = fca.list_domain_workspaces(domain.id)
+        self.assertEqual(len(workspaces), 0)
+
+        # Assign domain workspaces by capacities
+        status_code = fca.assign_domain_workspaces_by_capacities(domain.id, [cap.id])
+        self.assertEqual(status_code, 202)
+
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w.id for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Unassign all domain workspaces
+        status_code = fca.unassign_all_domain_workspaces(domain.id)
+        self.assertEqual(status_code, 200)
+
+        workspaces = fca.list_domain_workspaces(domain.id)
+        self.assertEqual(len(workspaces), 0)
+
+        # Assign domain workspaces by principals
+        status_code = fca.assign_domains_workspaces_by_principals(domain.id, [principal], wait_for_completion=True)
+
+        self.assertEqual(status_code, 202)
+
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w.id for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Role assignments bulk assign
+        
+        principal_2 = {'id': '6edbc444-16cd-43f4-ae48-cbe734b89657', 'type': 'User'}
+        principals = [principal, principal_2]
+
+        status_code = fca.role_assignments_bulk_assign(domain.id, "Contributors", principals)
+
+        self.assertEqual(status_code, 200)
+
+        # Role assignments bulk unassign
+        status_code = fca.role_assignments_bulk_unassign(domain.id, "Contributors", [principal_2])
+
+        self.assertEqual(status_code, 200)
+
+        # Delete domain
+        status_code = fca.delete_domain(domain.id)
+
+        self.assertEqual(status_code, 200)
+
+        domains = fca.list_domains()
+        domains_ids = [d.id for d in domains]
+        self.assertNotIn(domain.id, domains_ids)

msfabricpysdkcore/tests/test_git.py

@@ -1,5 +1,5 @@
 import unittest
-from msfabricpysdkcore.client import FabricClientCore
+from msfabricpysdkcore.coreapi import FabricClientCore
 from datetime import datetime
 from dotenv import load_dotenv
 

msfabricpysdkcore/tests/test_items_incl_lakehouse.py

@@ -2,7 +2,7 @@ import unittest
 from datetime import datetime
 from dotenv import load_dotenv
 from time import sleep
-from msfabricpysdkcore.client import FabricClientCore
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 class TestFabricClientCore(unittest.TestCase):
 

msfabricpysdkcore/tests/test_jobs.py

@@ -1,7 +1,5 @@
 import unittest
-from msfabricpysdkcore.client import FabricClientCore
-from datetime import datetime
-from dotenv import load_dotenv
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 class TestFabricClientCore(unittest.TestCase):
 

msfabricpysdkcore/tests/test_shortcuts.py

@@ -1,5 +1,5 @@
 import unittest
-from msfabricpysdkcore.client import FabricClientCore
+from msfabricpysdkcore.coreapi import FabricClientCore
 from datetime import datetime
 from dotenv import load_dotenv
 

msfabricpysdkcore/tests/test_workspaces_capacities.py

@@ -1,7 +1,7 @@
 import unittest
 from dotenv import load_dotenv
 from datetime import datetime
-from msfabricpysdkcore.client import FabricClientCore
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 load_dotenv()
 

msfabricpysdkcore/workspace.py

@@ -33,6 +33,9 @@ class Workspace:
         }
         return json.dumps(dict_, indent=2)
     
+    def __repr__(self) -> str:
+        return self.__str__()
+    
     def get_role_assignments(self):
         """Get role assignments for the workspace"""
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments"