msfabricpysdkcore 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

msfabricpysdkcore/coreapi.py

@@ -81,10 +81,10 @@ class FabricClientCore(FabricClient):
             return self.get_workspace_by_name(name)
         raise ValueError("Either id or name must be provided")
         
-    def get_workspace_role_assignments(self, workspace_id):
+    def list_workspace_role_assignments(self, workspace_id):
         """Get role assignments for a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
-        return ws.get_role_assignments()
+        return ws.list_role_assignments()
     
     def create_workspace(self, display_name, capacity_id = None, description = None, exists_ok = True):
         """Create a workspace"""
@@ -129,20 +129,25 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.add_role_assignment(role, principal)
     
-    def delete_workspace_role_assignment(self, workspace_id, principal_id):
+    def delete_workspace_role_assignment(self, workspace_id, workspace_role_assignment_id):
         """Delete a role assignment from a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
-        return ws.delete_role_assignment(principal_id)
+        return ws.delete_role_assignment(workspace_role_assignment_id)
     
     def update_workspace(self, workspace_id, display_name = None, description = None):
         """Update a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
         return ws.update(display_name, description)
+
+    def get_workspace_role_assignment(self, workspace_id, workspace_role_assignment_id):
+        """Get a role assignment for a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_role_assignment(workspace_role_assignment_id)
     
-    def update_workspace_role_assignment(self, workspace_id, role, principal_id):
+    def update_workspace_role_assignment(self, workspace_id, role, workspace_role_assignment_id):
         """Update a role assignment for a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
-        return ws.update_role_assignment(role, principal_id)
+        return ws.update_role_assignment(role, workspace_role_assignment_id)
 
     def assign_to_capacity(self, workspace_id, capacity_id):
         """Assign a workspace to a capacity"""
@@ -153,6 +158,16 @@ class FabricClientCore(FabricClient):
         """Unassign a workspace from a capacity"""
         ws = self.get_workspace_by_id(workspace_id)
         return ws.unassign_from_capacity()
+    
+    def provision_identity(self, workspace_id):
+        """Provision an identity for a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.provision_identity()
+    
+    def deprovision_identity(self, workspace_id):
+        """Deprovision an identity for a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.deprovision_identity()
  
     def list_capacities(self, continuationToken = None):
         """List all capacities in the tenant"""
@@ -809,6 +824,11 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.update_spark_job_definition_definition(spark_job_definition_id, definition)
     
+    def run_on_demand_spark_job_definition(self, workspace_id, spark_job_definition_id, job_type = "sparkjob"):
+        """Run an on demand spark job definition"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.run_on_demand_spark_job_definition(spark_job_definition_id, job_type)
+    
     # warehouses
 
     def list_warehouses(self, workspace_id, with_properties = False):

msfabricpysdkcore/long_running_operation.py

@@ -1,6 +1,6 @@
 import json 
 import requests
-from time import sleep
+from time import sleep, time
 
 class LongRunningOperation:
     """Class to represent a workspace in Microsoft Fabric"""
@@ -49,12 +49,17 @@ class LongRunningOperation:
     def wait_for_completion(self):
         """Wait for the operation to complete"""
         max_iter = 20
+        start_time = time()
         while self.state not in ('Succeeded', 'Failed'):
             self.state = self.get_operation_state()["status"]
+            duration = int(time() - start_time)
+            if duration > 60:
+                
+                if self.state == "Running":
+                    print(f"Operation did not complete after {duration} seconds")
+                    return "Running"
+                raise Exception(f"Operation did not complete after {duration} seconds")
             sleep(3)
-            if max_iter == 0:
-                raise Exception("Operation did not complete after 60 seconds")
-            max_iter -= 1
         return self.state
     
 

msfabricpysdkcore/otheritems.py

@@ -2,6 +2,7 @@ import json
 from time import sleep
 import requests
 from msfabricpysdkcore.item import Item
+from msfabricpysdkcore.long_running_operation import check_long_running_operation
 
 
 class Eventhouse(Item):
@@ -52,6 +53,34 @@ class SparkJobDefinition(Item):
     def update_definition(self, definition):
         return super().update_definition(definition=definition, type="sparkJobDefinitions")
     
+    def run_on_demand_spark_job_definition(self, job_type = "sparkjob"):
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/sparkJobDefinitions/{sparkJobDefinitionId}/jobs/instances?jobType={jobType}
+        """Method to run a spark job definition on demand"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/sparkJobDefinitions/{self.id}/jobs/instances?jobType={job_type}"
+
+        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 == 202:
+                location = response.headers['Location']
+                job_instance_id = location.split('/')[-1]
+                
+                from msfabricpysdkcore import FabricClientCore
+                fc = FabricClientCore(silent=True)
+                fc.auth = self.auth
+                return fc.get_item_job_instance(workspace_id = self.workspace_id,
+                                                item_id = self.id,
+                                                job_instance_id = job_instance_id)
+            if response.status_code not in (200, 201, 202, 429):
+                raise Exception(f"Error running on demand spark job definition: {response.status_code}, {response.text}")
+            break
+        
+        return response
+
+
 class Warehouse(Item):
     """Class to represent a warehouse in Microsoft Fabric"""
      

msfabricpysdkcore/tests/test_deployment_pipeline.py

@@ -53,8 +53,7 @@ class TestFabricClientCore(unittest.TestCase):
                 "itemType": item["itemType"]}
         items = [item]
 
-        
-        response = pipe.deploy(source_stage_id=dev_stage.id,target_stage_id=prod_stage.id, items=items)
+        response = fc.deploy_stage_content(deployment_pipeline_id=pipe_id, source_stage_id=dev_stage.id,target_stage_id=prod_stage.id, items=items)
 
         self.assertEqual(response["status"], "Succeeded")
 

msfabricpysdkcore/tests/test_git.py

@@ -30,7 +30,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         status_code = self.fc.git_connect(workspace_id=ws2.id, git_provider_details=git_provider_details)
 
-        self.assertEqual(status_code, 204)
+        self.assertEqual(status_code, 200)
 
         initialization_strategy = "PreferWorkspace"
 
@@ -56,7 +56,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         status_code = self.fc.git_disconnect(workspace_id=ws2.id)
 
-        self.assertEqual(status_code, 204)
+        self.assertEqual(status_code, 200)
 
         ws2.delete()
 

msfabricpysdkcore/tests/test_items_incl_lakehouse.py

@@ -173,23 +173,24 @@ class TestFabricClientCore(unittest.TestCase):
             
         fc = self.fc
         workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
-
-        eventhouse1 = fc.create_eventhouse(workspace_id, display_name="eventhouse1")
-        self.assertEqual(eventhouse1.display_name, "eventhouse1")
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        eventhouse_name = "evh" + datetime_str
+        eventhouse1 = fc.create_eventhouse(workspace_id, display_name=eventhouse_name)
+        self.assertEqual(eventhouse1.display_name, eventhouse_name)
         
         eventhouses = fc.list_eventhouses(workspace_id)
         eventhouse_names = [eh.display_name for eh in eventhouses]
         self.assertGreater(len(eventhouses), 0)
-        self.assertIn("eventhouse1", eventhouse_names)
+        self.assertIn(eventhouse_name, eventhouse_names)
 
-        eh = fc.get_eventhouse(workspace_id, eventhouse_name="eventhouse1")
+        eh = fc.get_eventhouse(workspace_id, eventhouse_name=eventhouse_name)
         self.assertIsNotNone(eh.id)
-        self.assertEqual(eh.display_name, "eventhouse1")
-
-        eh2 = fc.update_eventhouse(workspace_id, eh.id, display_name="eventhouse2")
+        self.assertEqual(eh.display_name, eventhouse_name)
+        new_display_name = eventhouse_name + "2"
+        eh2 = fc.update_eventhouse(workspace_id, eh.id, display_name=new_display_name)
 
         eh = fc.get_eventhouse(workspace_id, eventhouse_id=eh.id)
-        self.assertEqual(eh.display_name, "eventhouse2")
+        self.assertEqual(eh.display_name, new_display_name)
         self.assertEqual(eh.id, eh2.id)
 
         status_code = fc.delete_eventhouse(workspace_id, eh.id)
@@ -273,11 +274,11 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertIsNotNone(mlm.id)
         self.assertEqual(mlm.display_name, model_name)
 
-        # mlm2 = fc.update_ml_model(workspace_id=workspace_id,ml_model_id= mlm.id,  description=model_name)
+        mlm2 = fc.update_ml_model(workspace_id=workspace_id,ml_model_id= mlm.id,  description=model_name)
 
-        # mlm = fc.get_ml_model(workspace_id, ml_model_id=mlm.id)
-        # self.assertEqual(mlm.description, model_name)
-        # self.assertEqual(mlm.id, mlm2.id)
+        mlm = fc.get_ml_model(workspace_id, ml_model_id=mlm.id)
+        self.assertEqual(mlm.description, model_name)
+        self.assertEqual(mlm.id, mlm2.id)
 
         status_code = fc.delete_ml_model(workspace_id, mlm.id)
         self.assertEqual(status_code, 200)
@@ -385,45 +386,6 @@ class TestFabricClientCore(unittest.TestCase):
         status_code = fc.delete_semantic_model(workspace_id, sm.id)
         self.assertEqual(status_code, 200)
 
-
-    def test_spark_job_definitions(self):
-        
-        fc = self.fc
-        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
-
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        spark_job_definition_name = f"sjd{datetime_str}"
-
-        spark_job_definition_w_content = fc.get_spark_job_definition(workspace_id, spark_job_definition_name="helloworld")
-
-        definition = fc.get_spark_job_definition_definition(workspace_id, spark_job_definition_w_content.id)
-        
-        self.assertIsNotNone(definition)
-        self.assertIn("definition", definition)
-        definition = definition["definition"]
-
-        spark_job_definition = fc.create_spark_job_definition(workspace_id, display_name=spark_job_definition_name)
-        fc.update_spark_job_definition_definition(workspace_id, spark_job_definition.id, definition=definition)
-        spark_job_definition = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=spark_job_definition.id)
-        self.assertEqual(spark_job_definition.display_name, spark_job_definition_name)
-        self.assertIsNotNone(spark_job_definition.definition)
-
-        spark_job_definitions = fc.list_spark_job_definitions(workspace_id)
-        spark_job_definition_names = [sjd.display_name for sjd in spark_job_definitions]
-        self.assertGreater(len(spark_job_definitions), 0)
-        self.assertIn(spark_job_definition_name, spark_job_definition_names)
-
-        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_name=spark_job_definition_name)
-        self.assertIsNotNone(sjd.id)
-        self.assertEqual(sjd.display_name, spark_job_definition_name)
-
-        sjd = fc.update_spark_job_definition(workspace_id, sjd.id, display_name=f"{spark_job_definition_name}2")
-        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=sjd.id)
-        self.assertEqual(sjd.display_name, f"{spark_job_definition_name}2")
-
-        status_code = fc.delete_spark_job_definition(workspace_id, sjd.id)
-        self.assertEqual(status_code, 200)
-
     def test_warehouses(self):
 
         fc = self.fc

msfabricpysdkcore/tests/test_sparkjobdefinition.py

@@ -0,0 +1,55 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fc = FabricClientCore()
+        
+    def test_spark_job_definitions(self):
+        
+        fc = self.fc
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        spark_job_definition_name = f"sjd{datetime_str}"
+
+        spark_job_definition_w_content = fc.get_spark_job_definition(workspace_id, spark_job_definition_name="helloworld")
+
+        result = fc.run_on_demand_spark_job_definition(workspace_id=workspace_id, 
+                                                        spark_job_definition_id=spark_job_definition_w_content.id,
+                                                        job_type="sparkjob")
+        self.assertIsNotNone(result)
+        self.assertEqual(result.job_type, "sparkjob")
+        definition = fc.get_spark_job_definition_definition(workspace_id, spark_job_definition_w_content.id)
+        
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+
+        spark_job_definition = fc.create_spark_job_definition(workspace_id, display_name=spark_job_definition_name)
+        fc.update_spark_job_definition_definition(workspace_id, spark_job_definition.id, definition=definition)
+        spark_job_definition = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=spark_job_definition.id)
+        self.assertEqual(spark_job_definition.display_name, spark_job_definition_name)
+        self.assertIsNotNone(spark_job_definition.definition)
+
+        spark_job_definitions = fc.list_spark_job_definitions(workspace_id)
+        spark_job_definition_names = [sjd.display_name for sjd in spark_job_definitions]
+        self.assertGreater(len(spark_job_definitions), 0)
+        self.assertIn(spark_job_definition_name, spark_job_definition_names)
+
+        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_name=spark_job_definition_name)
+        self.assertIsNotNone(sjd.id)
+        self.assertEqual(sjd.display_name, spark_job_definition_name)
+
+        sjd = fc.update_spark_job_definition(workspace_id, sjd.id, display_name=f"{spark_job_definition_name}2")
+        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=sjd.id)
+        self.assertEqual(sjd.display_name, f"{spark_job_definition_name}2")
+
+        status_code = fc.delete_spark_job_definition(workspace_id, sjd.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_workspaces_capacities.py

@@ -10,118 +10,128 @@ class TestFabricClientCore(unittest.TestCase):
     def __init__(self, *args, **kwargs):
         super(TestFabricClientCore, self).__init__(*args, **kwargs)
         self.fc = FabricClientCore()
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        self.display_name = "testws" + datetime_str
-        self.workspace_id = None
+        
     
     def test_end_to_end_workspace(self):
-
-        ws_created = self.fc.create_workspace(display_name=self.display_name,
+        fc = self.fc
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        display_name = "testws" + datetime_str
+        ws_created = fc.create_workspace(display_name=display_name,
                                               description="test workspace", 
                                               exists_ok=False)
         # Add assertions here to verify the result
-        self.assertEqual(ws_created.display_name, self.display_name)
-        self.workspace_id = ws_created.id
-        ws = self.fc.get_workspace_by_id(id = self.workspace_id)
-        self.assertEqual(ws.display_name, self.display_name)
+        self.assertEqual(ws_created.display_name, display_name)
+        workspace_id = ws_created.id
+        ws = fc.get_workspace_by_id(id = workspace_id)
+        self.assertEqual(ws.display_name, display_name)
         self.assertEqual(ws.description, "test workspace")
 
 #   def test_assign_to_capacity(self):
         
-        result_status_code = self.fc.assign_to_capacity(workspace_id=ws.id, 
+        result_status_code = fc.assign_to_capacity(workspace_id=ws.id, 
                                                         capacity_id="41cb829c-c231-4e9f-b4fc-f9042a6f9840")
         self.assertEqual(result_status_code, 202)
       
 
 #    def test_list_workspaces(self):
         
-        result = self.fc.list_workspaces()
+        result = fc.list_workspaces()
         display_names = [ws.display_name for ws in result]
-        self.assertIn(self.display_name, display_names)
+        self.assertIn(display_name, display_names)
 
         for ws in result:
-            if ws.display_name == self.display_name:
+            if ws.display_name == display_name:
                 self.assertEqual(ws.capacity_id, "41cb829c-c231-4e9f-b4fc-f9042a6f9840")
 
 
   #  def test_get_workspace_by_name(self):
 
-        workspace_name = self.display_name
-        ws = self.fc.get_workspace_by_name(name = workspace_name)
-        self.assertEqual(ws.display_name, self.display_name)
+        workspace_name = display_name
+        ws = fc.get_workspace_by_name(name = workspace_name)
+        self.assertEqual(ws.display_name, display_name)
 
  #   def test_get_workspace_by_id(self):
-        ws = self.fc.get_workspace_by_id(id = self.workspace_id)
-        self.assertEqual(self.display_name, ws.display_name)
+        ws = fc.get_workspace_by_id(id = workspace_id)
+        self.assertEqual(display_name, ws.display_name)
 
 
 #    def test_get_workspace(self):
-        result = self.fc.get_workspace_by_id(id = self.workspace_id)
-        self.assertEqual(result.display_name, self.display_name)
+        result = fc.get_workspace_by_id(id = workspace_id)
+        self.assertEqual(result.display_name, display_name)
     
  #   def test_add_role_assignment(self):
-        result_status = self.fc.add_workspace_role_assignment(workspace_id = ws.id,
-                                                              principal = {"id" : "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69",
-                                                                           "type" : "ServicePrincipal"},
-                                                              role = 'Member')
+        result_status = fc.add_workspace_role_assignment(workspace_id = ws.id,
+                                                         principal = {"id" : "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69",
+                                                                        "type" : "ServicePrincipal"},
+                                                         role = 'Member')
         
-        self.assertEqual(result_status, 200)
+        self.assertEqual(result_status, 201)
 
  #   def test_get_workspace_role_assignments(self):
-        result = self.fc.get_workspace_role_assignments(workspace_id = ws.id)
-        self.assertTrue("value" in result)
-        self.assertTrue(len(result["value"]) == 2)
-        for user in result["value"]:
+        result = fc.list_workspace_role_assignments(workspace_id = ws.id)
+        self.assertTrue(len(result) == 2)
+        for user in result:
             if user["principal"]["displayName"] == "fabrictestuser":
-                self.assertTrue(user["role"] == "Member")
+                self.assertEqual(user["role"], "Member")
+
+        # Get get_workspace_role_assignment
+
+        result = fc.get_workspace_role_assignment(workspace_id = ws.id, 
+                                                  workspace_role_assignment_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
+        
+        self.assertEqual(result["role"], "Member")
 
 #    def test_update_workspace_role_assignment(self):
 
-        result_status_code = self.fc.update_workspace_role_assignment(workspace_id = ws.id, 
+        result_status_code = fc.update_workspace_role_assignment(workspace_id = ws.id, 
                                                                       role = "Contributor", 
-                                                                      principal_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
+                                                                      workspace_role_assignment_id= "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
         
         self.assertEqual(result_status_code, 200)
 
-        result = self.fc.get_workspace_role_assignments(workspace_id = ws.id)
-        self.assertTrue("value" in result)
-        self.assertTrue(len(result["value"]) == 2)
-        for user in result["value"]:
+        result = fc.list_workspace_role_assignments(workspace_id = ws.id)
+        self.assertTrue(len(result) == 2)
+        for user in result:
             if user["principal"]["displayName"] == "fabrictestuser":
                 self.assertTrue(user["role"] == "Contributor")
 
 #   def test_delete_role_assignment(self):
-        result_status_code = self.fc.delete_workspace_role_assignment(workspace_id = ws.id,
-                                                                      principal_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
+        result_status_code = fc.delete_workspace_role_assignment(workspace_id = ws.id,
+                                                                 workspace_role_assignment_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
         self.assertEqual(result_status_code, 200)
 
  #   def test_get_workspace_role_assignments(self):
-        result = self.fc.get_workspace_role_assignments(workspace_id = ws.id)
-        self.assertTrue("value" in result)
-        self.assertTrue(len(result["value"]) == 1)
-        user = result["value"][0]
+        result = fc.list_workspace_role_assignments(workspace_id = ws.id)
+        self.assertTrue(len(result) == 1)
+        user = result[0]
 #        self.assertTrue(user["principal"]["displayName"] == "fabricapi")
         self.assertTrue(user["role"] == "Admin")
 
 #    def test_update_workspace(self):
-        ws_updated = self.fc.update_workspace(workspace_id=ws.id, 
+        ws_updated = fc.update_workspace(workspace_id=ws.id, 
                                               display_name="newn912389u8293", 
                                               description="new description")
         self.assertEqual(ws_updated.display_name, "newn912389u8293")
         self.assertEqual(ws_updated.description, "new description")
-        ws = self.fc.get_workspace_by_id(id = ws.id)
+        ws = fc.get_workspace_by_id(id = ws.id)
         self.assertEqual(ws.display_name, "newn912389u8293")
         self.assertEqual(ws.description, "new description")
 
 #    def test_unassign_from_capacity(self):
 
-        result_status_code = self.fc.unassign_from_capacity(workspace_id=ws.id)
+        result_status_code = fc.unassign_from_capacity(workspace_id=ws.id)
         self.assertEqual(result_status_code, 202)
-        ws = self.fc.get_workspace_by_id(ws.id)
+        ws = fc.get_workspace_by_id(ws.id)
         self.assertEqual(ws.capacity_id, None)
 
+        # result = fc.provision_identity(workspace_id=ws.id)
+        # self.assertIsNotNone(result["applicationId"])
+        # fc.deprovision_identity(workspace_id=ws.id)
+
+
+
 #    def test_delete_workspace(self):
-        result_status = self.fc.delete_workspace(display_name="newn912389u8293")
+        result_status = fc.delete_workspace(display_name="newn912389u8293")
         self.assertEqual(result_status, 200)
 
     def test_list_capacities(self):

msfabricpysdkcore/workspace.py

@@ -42,10 +42,13 @@ class Workspace:
     def __repr__(self) -> str:
         return self.__str__()
     
-    def get_role_assignments(self):
-        """Get role assignments for the workspace"""
+    def list_role_assignments(self, continuationToken = None):
+        """List role assignments for the workspace"""
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments"
 
+        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:
@@ -58,7 +61,14 @@ class Workspace:
                 raise Exception(f"Error getting role assignments: {response.text}")
             break
 
-        return json.loads(response.text)
+        resp_dict = json.loads(response.text)
+        role_assignments = resp_dict["value"]
+
+        if "continuationToken" in resp_dict:
+            role_assignments_next = self.list_role_assignments(continuationToken=resp_dict["continuationToken"])
+            role_assignments.extend(role_assignments_next)
+
+        return role_assignments
     
     def delete(self):
         """Delete the workspace"""
@@ -94,7 +104,7 @@ class Workspace:
                 print("Too many requests, waiting 10 seconds")
                 sleep(10)
                 continue
-            if response.status_code not in (200, 429):
+            if response.status_code not in (201, 429):
                 print(response.status_code)
                 print(response.text)
                 raise Exception(f"Error adding role assignments: {response.text}")
@@ -103,9 +113,9 @@ class Workspace:
         return response.status_code
     
 
-    def delete_role_assignment(self, principal_id):
+    def delete_role_assignment(self, workspace_role_assignment_id):
         """Delete a role assignment from the workspace"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{principal_id}"
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{workspace_role_assignment_id}"
 
         for _ in range(10):
             response = requests.delete(url=url, headers=self.auth.get_headers())
@@ -150,10 +160,29 @@ class Workspace:
             self.description = description
 
         return self
+    
+    def get_role_assignment(self, workspace_role_assignment_id):
+        # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/roleAssignments/{workspaceRoleAssignmentId}
+
+        """Get a role assignment from the workspace"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{workspace_role_assignment_id}"
+
+        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):
+                raise Exception(f"Error getting role assignments: {response.status_code}, {response.text}")
+            break
 
-    def update_role_assignment(self, role, principal_id):
+        return json.loads(response.text)
+
+    def update_role_assignment(self, role, workspace_role_assignment_id):
         """Update a role assignment in the workspace"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{principal_id}"
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{workspace_role_assignment_id}"
         body = {
             'role': role
         }
@@ -222,6 +251,45 @@ class Workspace:
         self.capacity_id = None
         return response.status_code
     
+    def provision_identity(self):
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/provisionIdentity
+        """Provision identity for the workspace"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/provisionIdentity"
+
+        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 == 202:
+                return check_long_running_operation( response.headers, self.auth)
+            if response.status_code not in (200, 201, 202, 429):
+                raise Exception(f"Error provisioning identity: {response.status_code}, {response.text}")
+            break
+
+        return response
+    
+    def deprovision_identity(self):
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/deprovisionIdentity
+        """Deprovision identity for the workspace"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/deprovisionIdentity"
+
+        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 == 202:
+                return check_long_running_operation( response.headers, self.auth)
+            if response.status_code not in (200, 201, 202, 429):
+                raise Exception(f"Error deprovisioning identity: {response.status_code}, {response.text}")
+            break
+
+        return response
+
+    
     def get_item_specific(self, item_dict):
         if item_dict["type"] == "DataPipeline":
             return self.get_data_pipeline(item_dict["id"])
@@ -1218,6 +1286,11 @@ class Workspace:
         """Update the definition of a spark job definition in a workspace"""
         return self.get_spark_job_definition(spark_job_definition_id=spark_job_definition_id).update_definition(definition=definition)
 
+    def run_on_demand_spark_job_definition(self, spark_job_definition_id, job_type = "sparkjob"):
+        """Run on demand spark job definition"""
+        sjd = self.get_spark_job_definition(spark_job_definition_id=spark_job_definition_id)
+        return sjd.run_on_demand_spark_job_definition(job_type=job_type)
+
     # warehouses
 
     def list_warehouses(self, with_properties = False):

{msfabricpysdkcore-0.0.11.dist-info → msfabricpysdkcore-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: msfabricpysdkcore
-Version: 0.0.11
+Version: 0.0.12
 Summary: A Python SDK for Microsoft Fabric
 Author: Andreas Rederer
 Project-URL: Homepage, https://github.com/DaSenf1860/ms-fabric-sdk-core
@@ -148,26 +148,40 @@ ws.add_role_assignment(principal = {"id" : "abadfbafb",
                        role = 'Member')
 
  
- # Get workspace role assignments
-fc.get_workspace_role_assignments(workspace_id = ws.id)
+ # List workspace role assignments
+fc.list_workspace_role_assignments(workspace_id = ws.id)
 # or
-ws.get_role_assignments()
+ws.list_role_assignments()
 
 
+# Get workspace role assignment
+fc.get_workspace_role_assignment(workspace_id = ws.id, 
+                                 workspace_role_assignment_id = "dagdasf")  
+# or
+ws.get_role_assignment(workspace_role_assignment_id = "fsgdg")
+
 # Update workspace role assignment
 fc.update_workspace_role_assignment(workspace_id = ws.id, 
                                     role = "Contributor", 
-                                    principal_id = "abadfbafb")
+                                    workspace_role_assignment_id = "abadfbafb")
 # or
 ws.update_role_assignment(role = "Contributor", 
-                          principal_id = "abadfbafb")
+                          workspace_role_assignment_id = "abadfbafb")
 
 
 # Delete workspace role assignment
 fc.delete_workspace_role_assignment(workspace_id = ws.id,
-                                    principal_id = "abadfbafb")
+                                    workspace_role_assignment_id = "abadfbafb")
 # or
-ws.delete_role_assignment(principal_id = "abadfbafb")
+ws.delete_role_assignment(workspace_role_assignment_id = "abadfbafb")
+
+
+# Provision Identity
+result = fc.provision_identity(workspace_id=ws.id)
+print(result["applicationId"]))
+
+# Deprovision Identity
+fc.deprovision_identity(workspace_id=ws.id)
 
 ```
 

{msfabricpysdkcore-0.0.11.dist-info → msfabricpysdkcore-0.0.12.dist-info}/RECORD

@@ -5,34 +5,35 @@ msfabricpysdkcore/adminapi.py,sha256=uithaYq_HWDU-9Et_EFBNQfrjcjnI-NW6OCmWoAsZxk
 msfabricpysdkcore/auth.py,sha256=v5YkI4jA6T7lv5rjqTK-GEPx2ATDPKQ1LVcaCg98oLM,2562
 msfabricpysdkcore/capacity.py,sha256=Q_2-XrZtdf9F67fY0qU3D0ocEOGQq4KtIXAv9dXjQhI,1761
 msfabricpysdkcore/client.py,sha256=yOZ1CW2ilL8a7J_SRNa-EQbG8xNlJKW3ygniIrsADsw,1300
-msfabricpysdkcore/coreapi.py,sha256=Mjs_YoCISmQXhG7mO4KDWd-4GKZJ7M4hsgis3cee-no,48590
+msfabricpysdkcore/coreapi.py,sha256=IUutbCz_Dag2rFWbmbSVt8AkFnj4CJdP-v-jXOrFrBA,49645
 msfabricpysdkcore/deployment_pipeline.py,sha256=RFI86rtG-eTpV-_tVl3cXtcTl9ekRvOI5fLsXo9CMVA,9739
 msfabricpysdkcore/domain.py,sha256=i8jMJEutDRL5XuQ69woCVQEzLS_lm9uUxl4Kp3xtxHc,14722
 msfabricpysdkcore/environment.py,sha256=ENgy7URz_gJ4E5-OH355QF6vqawBoHjHMbjnoEJfGwM,10072
 msfabricpysdkcore/item.py,sha256=HIr32drqNtlIKKXkXCcWI2H_TZMDalCxvikTyDHNprA,11428
 msfabricpysdkcore/job_instance.py,sha256=C9kKsV-BIJSeU6DfoTnLlg4DLp-8RYpovs0A-mKwi4o,2745
 msfabricpysdkcore/lakehouse.py,sha256=nv95SBz_jsssT5dEw622WqtDHUyh5bFFsVTwiqo8s-c,6055
-msfabricpysdkcore/long_running_operation.py,sha256=gcGVTgA0NToPItrl42Zy1M2eVZtx-vx-SdUryNAm53E,2731
+msfabricpysdkcore/long_running_operation.py,sha256=Itm8ohr9fPIdP7UO9_xehQ6wb6t4hsCuvDbcOSzAgVA,2981
 msfabricpysdkcore/onelakeshortcut.py,sha256=EYZfP-rl60HdCqJD1O1NXrQTgrYTIw-EWisF4hs4bTU,2102
-msfabricpysdkcore/otheritems.py,sha256=TsRZHcqYHw1t6tqKMa3yC0LF9uBj3a1Uzc_lLKZ6LVY,10967
+msfabricpysdkcore/otheritems.py,sha256=D-sGriO9ck4pqzsLY6bZLJUDXIBkyNyqCPoJmgextbk,12571
 msfabricpysdkcore/spark_custom_pool.py,sha256=2H-GkGcDsiKxSpXFSf8Zi7xJI5_krb_8sGdF5vDjEy8,4635
-msfabricpysdkcore/workspace.py,sha256=IeT0W0vitc_jH6d9OhRd-SjgDsKYFayQ_g8m9DD0pts,65050
+msfabricpysdkcore/workspace.py,sha256=IdP0qDXD-0JVZnK_cn9VILNQ5-FQGFzGXq-MoCkLyWs,68563
 msfabricpysdkcore/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 msfabricpysdkcore/tests/test_admin_apis.py,sha256=HTXt72p9FiEf3q9SXyq9aImR6zZo_xIREfB0xPaYazU,2586
 msfabricpysdkcore/tests/test_datapipelines.py,sha256=rIeZfv-MGewYYscb36jmjL8DLZ3Z1dJWv09foR9z_y8,1812
-msfabricpysdkcore/tests/test_deployment_pipeline.py,sha256=XmqKZXbwBY3P-4O_ce9Wupz9qXHaKxWERwS-RZt38Bs,2024
+msfabricpysdkcore/tests/test_deployment_pipeline.py,sha256=7bXqSpnU8Hb7KyKldhA7hVM8QqKHj0WoT9_kC27hsxM,2058
 msfabricpysdkcore/tests/test_domains.py,sha256=KFGQyl0G2v4JjX_xYHY-vPSjYxeLEx3AcXMdiRZzClc,4620
 msfabricpysdkcore/tests/test_environments.py,sha256=zSIMhkQscMB7doJEQRBRMvAEBxO1Kl1N85MKXP3yeYI,3120
 msfabricpysdkcore/tests/test_evenstreams.py,sha256=i6hhsOnDJ-BN7kStg7gQhZVPMVaB73K7KJez6pEKlv0,1628
-msfabricpysdkcore/tests/test_git.py,sha256=IZfWggCyZtHpUbYyacNTyIRfy6rofz-fBEmco_8gMZ4,2415
-msfabricpysdkcore/tests/test_items_incl_lakehouse.py,sha256=6to6S9ZcRT6Ain7U3LxCpjkKmL7-Uk3VvJ4xfSkrnKg,19910
+msfabricpysdkcore/tests/test_git.py,sha256=pmhVYZGDMEFtgy51hKrDWqtea-MryyeyvPKVCaTsIEA,2415
+msfabricpysdkcore/tests/test_items_incl_lakehouse.py,sha256=zWNmOI_Ysh96d8P-Sm4IOCzMqXTCEBg63lxCDZZ_9b8,17987
 msfabricpysdkcore/tests/test_jobs.py,sha256=DC1nQTav_Re7uunRA07wD_56giLqe9KOsgm56Il8Zr4,1632
 msfabricpysdkcore/tests/test_kqldatabases.py,sha256=Oc2ZzpQAVbiJeZ5ytwlP2Jb-tKe-2e9-1oA-upwRKBQ,1921
 msfabricpysdkcore/tests/test_shortcuts.py,sha256=TqGLzEWsDyiQ0Gf6JpT_qBHUCgcvYXfVwpXxOay7Qz4,2407
 msfabricpysdkcore/tests/test_spark.py,sha256=5BCAgHRiuXjIRnGrbvNNh9emq0VyZXlvIWgWAEir5ZQ,3437
-msfabricpysdkcore/tests/test_workspaces_capacities.py,sha256=X00zIuADhY_7jORIzXrWiXfPBJUhbXUckF-gZJ3m1bQ,6547
-msfabricpysdkcore-0.0.11.dist-info/LICENSE,sha256=1NrGuF-zOmzbwzk3iI6lsP9koyDeKO1B0-8OD_tTvOQ,1156
-msfabricpysdkcore-0.0.11.dist-info/METADATA,sha256=56ie3TOUCJjsXDapUag0-i5-YmcluBQqgRFIgJODj2A,17455
-msfabricpysdkcore-0.0.11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-msfabricpysdkcore-0.0.11.dist-info/top_level.txt,sha256=3iRonu6ptDGQN4Yl6G76XGM7xbFNsskiEHW-P2gMQGY,18
-msfabricpysdkcore-0.0.11.dist-info/RECORD,,
+msfabricpysdkcore/tests/test_sparkjobdefinition.py,sha256=whADi8l4opMaoB4b1W5EbuddyB5tC5OEqGRFKVUYMH4,2820
+msfabricpysdkcore/tests/test_workspaces_capacities.py,sha256=52FqGZRVvHDegLgu71kGX_Tx4cRh9lO_wuK8BG_czkQ,6699
+msfabricpysdkcore-0.0.12.dist-info/LICENSE,sha256=1NrGuF-zOmzbwzk3iI6lsP9koyDeKO1B0-8OD_tTvOQ,1156
+msfabricpysdkcore-0.0.12.dist-info/METADATA,sha256=bK4vYEgjRLyzNJhBUnSSI6I9GlWnZcXIYDoo5z6__TY,17944
+msfabricpysdkcore-0.0.12.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+msfabricpysdkcore-0.0.12.dist-info/top_level.txt,sha256=3iRonu6ptDGQN4Yl6G76XGM7xbFNsskiEHW-P2gMQGY,18
+msfabricpysdkcore-0.0.12.dist-info/RECORD,,

{msfabricpysdkcore-0.0.11.dist-info → msfabricpysdkcore-0.0.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any