msfabricpysdkcore 0.0.2__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

@@ -6,6 +6,7 @@ from msfabricpysdkcore.onelakeshortcut import OneLakeShortcut
 from msfabricpysdkcore.job_instance import JobInstance
 from msfabricpysdkcore.long_running_operation import check_long_running_operation
 
+
 class Item:
     """Class to represent a item in Microsoft Fabric"""
 
@@ -34,8 +35,17 @@ 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"""
+        
+        if item_dict['type'] == "Lakehouse":
+            from msfabricpysdkcore.lakehouse import Lakehouse
+            return Lakehouse(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+                    properties=item_dict.get('properties', None),
+                    definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
         return Item(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
                     properties=item_dict.get('properties', None),
                     definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
@@ -52,6 +62,7 @@ class Item:
             if response.status_code not in (200, 429):
                 print(response.status_code)
                 print(response.text)
+                print(self)
                 raise Exception(f"Error deleting item: {response.text}")
             break
 
@@ -243,4 +254,11 @@ class Item:
     def cancel_item_job_instance(self, job_instance_id):
         """Cancel a job instance ofjob the item"""
         return self.get_item_job_instance(job_instance_id=job_instance_id).cancel()
-        
+        
+    def list_tables(self):
+        raise NotImplementedError("List tables only works on Lakehouse Items")
+    
+    def load_table(self, table_name, path_type, relative_path,
+                    file_extension = None, format_options = None,
+                    mode = None, recursive = None, wait_for_completion = True):
+        raise NotImplementedError("Load table only works on Lakehouse Items")

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/lakehouse.py

@@ -0,0 +1,96 @@
+import json 
+import requests
+from time import sleep
+
+from msfabricpysdkcore.long_running_operation import check_long_running_operation
+from msfabricpysdkcore.item import Item
+
+class Lakehouse(Item):
+    """Class to represent a item in Microsoft Fabric"""
+
+    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+
+
+    def list_tables(self, continuationToken = None):
+        """List all tables in the lakehouse"""
+        # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/lakehouses/{lakehouseId}/tables
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/lakehouses/{self.id}/tables"
+
+        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 tables: {response.status_code},  {response.text}")
+            break
+        resp_dict = json.loads(response.text)
+
+        table_list = resp_dict["data"]
+
+        if "continuationToken" in resp_dict and resp_dict["continuationToken"] is not None:
+            table_list_next = self.list_tables(continuationToken=resp_dict["continuationToken"])
+            table_list.extend(table_list_next)
+
+        return table_list
+    
+    def load_table(self, table_name, path_type, relative_path,
+                    file_extension = None, format_options = None,
+                    mode = None, recursive = None, wait_for_completion = True):
+        """Load a table in the lakehouse"""
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/lakehouses/{lakehouseId}/tables/{tableName}/load
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/lakehouses/{self.id}/tables/{table_name}/load"
+
+        body = {
+                "relativePath": relative_path,
+                "pathType": path_type,
+              }
+
+        if file_extension:
+            body["fileExtension"] = file_extension
+        if format_options:
+            body["formatOptions"] = format_options
+        if mode:
+            body["mode"] = mode
+        if recursive:
+            body["recursive"] = recursive
+
+        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:
+                if wait_for_completion:
+                    success = self.check_if_table_is_created(table_name)
+                    
+                if not success:
+                    print("Warning: Table not created after 3 minutes")
+                else:
+                    print("Table created")
+            if response.status_code not in (202, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error loading table: {response.status_code},  {response.text}")
+            break
+
+        return response.status_code
+    
+    def check_if_table_is_created(self, table_name):
+        """Check if the table is created"""
+        for _ in range(60):
+            table_names = [table["name"] for table in self.list_tables()]
+            if table_name in table_names:
+                return True
+            
+            sleep(3)
+        return False
+    

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)
+
+