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

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, 
-                                              display_name="newname8912389u1293", 
+        ws_updated = fc.update_workspace(workspace_id=ws.id, 
+                                              display_name="newn912389u8293", 
                                               description="new description")
-        self.assertEqual(ws_updated.display_name, "newname8912389u1293")
+        self.assertEqual(ws_updated.display_name, "newn912389u8293")
         self.assertEqual(ws_updated.description, "new description")
-        ws = self.fc.get_workspace_by_id(id = ws.id)
-        self.assertEqual(ws.display_name, "newname8912389u1293")
+        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="newname8912389u1293")
+        result_status = fc.delete_workspace(display_name="newn912389u8293")
         self.assertEqual(result_status, 200)
 
     def test_list_capacities(self):

msfabricpysdkcore/workspace.py

@@ -6,7 +6,7 @@ from msfabricpysdkcore.lakehouse import Lakehouse
 from msfabricpysdkcore.environment import Environment
 from msfabricpysdkcore.long_running_operation import check_long_running_operation
 from msfabricpysdkcore.otheritems import DataPipeline, Eventstream, KQLDatabase, KQLQueryset, SparkJobDefinition
-from msfabricpysdkcore.otheritems import MLExperiment, MLModel, Notebook, Report, SemanticModel, Warehouse
+from msfabricpysdkcore.otheritems import Eventhouse, MLExperiment, MLModel, Notebook, Report, SemanticModel, Warehouse
 from msfabricpysdkcore.spark_custom_pool import SparkCustomPool
 
 
@@ -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())
@@ -140,9 +150,7 @@ class Workspace:
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                raise Exception(f"Error updating workspace: {response.text}")
+                raise Exception(f"Error updating workspace: {response.status_code}, {response.text}")
             break
 
         assert response.status_code == 200
@@ -152,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())
 
-    def update_role_assignment(self, role, principal_id):
+            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
+
+        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
         }
@@ -224,11 +251,52 @@ 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"])
         if item_dict["type"] == "Eventstream":
             return self.get_eventstream(item_dict["id"])
+        if item_dict["type"] == "Eventhouse":
+            return self.get_eventhouse(item_dict["id"])
         if item_dict["type"] == "KQLDatabase":
             return self.get_kql_database(item_dict["id"])
         if item_dict["type"] == "KQLQueryset":
@@ -255,7 +323,7 @@ class Workspace:
         item_obj = Item.from_dict(item_dict, auth=self.auth)
         return item_obj
 
-    def create_item(self, display_name, type, definition = None, description = None):
+    def create_item(self, display_name, type, definition = None, description = None, **kwargs):
         """Create an item in a workspace"""
 
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/items"
@@ -271,7 +339,9 @@ class Workspace:
 
         if type in ["dataPipelines",
                     "environments",
-                    "eventstreams", 
+                    "eventhouses",
+                    "eventstreams",
+                    "kqlDatabases",
                     "lakehouses",
                     "mlExperiments", 
                     "mlModels", 
@@ -281,6 +351,11 @@ class Workspace:
                     "sparkJobDefinitions", 
                     "warehouses"]:
             
+            if type == "kqlDatabases":
+                if "creation_payload" not in kwargs:
+                    raise Exception("creation_payload is required for KQLDatabase")
+                body["creationPayload"] = kwargs["creation_payload"]
+            
             url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/{type}"
             body.pop('type')
 
@@ -307,7 +382,9 @@ class Workspace:
 
             type_mapping = {"dataPipelines": "DataPipeline",
                             "environments": "Environment",
+                            "eventhouses": "Eventhouse",
                             "eventstreams": "Eventstream",
+                            "kqlDatabases": "KQLDatabase",
                             "lakehouses": "Lakehouse", 
                             "mlExperiments": "MLExperiment",
                             "mlModels": "MLModel", 
@@ -693,7 +770,7 @@ class Workspace:
 
     def list_data_pipelines(self, with_properties = False):
         """List data pipelines in a workspace"""
-        return self.list_items(with_properties = with_properties, type="dataPipelines")
+        return self.list_items(type="dataPipelines", with_properties=with_properties)
     
     def get_data_pipeline(self, data_pipeline_id = None, data_pipeline_name = None):
         """Get a data pipeline from a workspace"""
@@ -721,7 +798,7 @@ class Workspace:
 
     def list_environments(self, with_properties = False):
         """List environments in a workspace"""
-        return self.list_items(type="environments", with_properties=with_properties)
+        return self.list_items(type="environments", with_properties = with_properties)
     
     def create_environment(self, display_name, description = None):
         """Create an environment in a workspace"""
@@ -741,10 +818,6 @@ class Workspace:
 
         item_dict = self.get_item_internal(url)
         env = Environment.from_dict(item_dict, auth=self.auth)
-        #env.get_staging_settings()
-        #env.get_published_settings()
-        #env.get_staging_libraries()
-        #env.get_published_libraries()
         return env
     
     def delete_environment(self, environment_id):
@@ -765,13 +838,18 @@ class Workspace:
     def get_staging_settings(self, environment_id):
         return self.get_environment(environment_id).get_staging_settings()
     
-    def update_staging_settings(self, environment_id, instance_pool, driver_cores, driver_memory, executor_cores, executor_memory,
-                                dynamic_executor_allocation, spark_properties, runtime_version):
-        return self.get_environment(environment_id).update_staging_settings(instance_pool, driver_cores, 
-                                                                            driver_memory, executor_cores, 
-                                                                            executor_memory, 
-                                                                            dynamic_executor_allocation,
-                                                                            spark_properties, runtime_version)
+    def update_staging_settings(self, environment_id,
+                                driver_cores = None, driver_memory = None, dynamic_executor_allocation = None,
+                                executor_cores = None, executor_memory = None, instance_pool = None,
+                                runtime_version = None, spark_properties = None):
+        return self.get_environment(environment_id).update_staging_settings(driver_cores=driver_cores,
+                                                                            driver_memory=driver_memory,
+                                                                            dynamic_executor_allocation=dynamic_executor_allocation,
+                                                                            executor_cores=executor_cores,
+                                                                            executor_memory=executor_memory,
+                                                                            instance_pool=instance_pool,
+                                                                            runtime_version=runtime_version,
+                                                                            spark_properties=spark_properties)
 
     # environment spark libraries
 
@@ -781,8 +859,8 @@ class Workspace:
     def get_staging_libraries(self, environment_id):
         return self.get_environment(environment_id).get_staging_libraries()
     
-    def update_staging_library(self, environment_id):
-        return self.get_environment(environment_id).update_staging_libraries()
+    def upload_staging_library(self, environment_id, file_path):
+        return self.get_environment(environment_id).upload_staging_library(file_path)
     
     def publish_environment(self, environment_id):
         return self.get_environment(environment_id).publish_environment()
@@ -793,11 +871,45 @@ class Workspace:
     def cancel_publish(self, environment_id):
         return self.get_environment(environment_id).cancel_publish()
     
+    # eventhouses
+    def list_eventhouses(self, with_properties = False):
+        """List eventhouses in a workspace"""
+        return self.list_items(type="eventhouses", with_properties=with_properties)
+    
+    def create_eventhouse(self, display_name, description = None):
+        """Create an eventhouse in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "eventhouses",
+                                definition = None,
+                                description = description)
+    
+    def get_eventhouse(self, eventhouse_id = None, eventhouse_name = None):
+        """Get an eventhouse from a workspace"""
+        if eventhouse_id is None and eventhouse_name is not None:
+            return self.get_item_by_name(eventhouse_name, "Eventhouse")
+        elif eventhouse_id is None:
+            raise Exception("eventhouse_id or the eventhouse_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/eventhouses/{eventhouse_id}"
+
+        item_dict = self.get_item_internal(url)
+        return Eventhouse.from_dict(item_dict, auth=self.auth)
+    
+    def delete_eventhouse(self, eventhouse_id):
+        """Delete an eventhouse from a workspace"""
+        return self.get_item(item_id=eventhouse_id).delete(type="eventhouses")
+    
+    def update_eventhouse(self, eventhouse_id, display_name = None, description = None):
+        """Update an eventhouse in a workspace"""
+        return self.get_item(item_id=eventhouse_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="eventhouses")
+
     # eventstreams
 
-    def list_eventstreams(self):
+    def list_eventstreams(self, with_properties = False):
         """List eventstreams in a workspace"""
-        return self.list_items(type="eventstreams")
+        return self.list_items(type="eventstreams", with_properties=with_properties)
     
     def create_eventstream(self, display_name, description = None):
         """Create an eventstream in a workspace"""
@@ -830,9 +942,16 @@ class Workspace:
     
     # kqlDatabases
 
-    def list_kql_databases(self):
+    def list_kql_databases(self, with_properties = False):
         """List kql databases in a workspace"""
-        return self.list_items(type="kqlDatabases")
+        return self.list_items(type="kqlDatabases", with_properties = with_properties)
+    
+    def create_kql_database(self, creation_payload, display_name, description = None, ):
+        """Create a kql database in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "kqlDatabases",
+                                description = description,
+                                creation_payload = creation_payload)
     
     def get_kql_database(self, kql_database_id = None, kql_database_name = None):
         """Get a kql database from a workspace"""
@@ -859,9 +978,9 @@ class Workspace:
 
     # kqlQuerysets
 
-    def list_kql_querysets(self):
+    def list_kql_querysets(self, with_properties = False):
         """List kql querysets in a workspace"""
-        return self.list_items(type="kqlQuerysets")
+        return self.list_items(type="kqlQuerysets", with_properties = with_properties)
 
     def get_kql_queryset(self, kql_queryset_id = None, kql_queryset_name = None):
         """Get a kql queryset from a workspace"""
@@ -925,9 +1044,9 @@ class Workspace:
     
     # mlExperiments
 
-    def list_ml_experiments(self):
+    def list_ml_experiments(self, with_properties = False):
         """List ml experiments in a workspace"""
-        return self.list_items(type="mlExperiments")
+        return self.list_items(type="mlExperiments", with_properties = with_properties)
     
     def create_ml_experiment(self, display_name, description = None):
         """Create an ml experiment in a workspace"""
@@ -960,9 +1079,9 @@ class Workspace:
     
     # mlModels
 
-    def list_ml_models(self):
+    def list_ml_models(self, with_properties = False):
         """List ml models in a workspace"""
-        return self.list_items(type="mlModels")
+        return self.list_items(type="mlModels", with_properties = with_properties)
 
     def create_ml_model(self, display_name, description = None):
         """Create an ml model in a workspace"""
@@ -1167,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.10.dist-info → msfabricpysdkcore-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: msfabricpysdkcore
-Version: 0.0.10
+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.12.dist-info/RECORD

@@ -0,0 +1,39 @@
+msfabricpysdkcore/__init__.py,sha256=nh8-lxdMBWYSbQpbRxWkn3ZRpGipmQplTudjskN2l88,78
+msfabricpysdkcore/admin_item.py,sha256=OGVfMMqAKy80Ukp8TJnpXoRq8WbWX7Qq1hz7tmfiUBU,4020
+msfabricpysdkcore/admin_workspace.py,sha256=RctVsXZ57ppiybua69BW_yVpUbrGic6fYOjFPZFPAzA,4862
+msfabricpysdkcore/adminapi.py,sha256=uithaYq_HWDU-9Et_EFBNQfrjcjnI-NW6OCmWoAsZxk,25649
+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=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=Itm8ohr9fPIdP7UO9_xehQ6wb6t4hsCuvDbcOSzAgVA,2981
+msfabricpysdkcore/onelakeshortcut.py,sha256=EYZfP-rl60HdCqJD1O1NXrQTgrYTIw-EWisF4hs4bTU,2102
+msfabricpysdkcore/otheritems.py,sha256=D-sGriO9ck4pqzsLY6bZLJUDXIBkyNyqCPoJmgextbk,12571
+msfabricpysdkcore/spark_custom_pool.py,sha256=2H-GkGcDsiKxSpXFSf8Zi7xJI5_krb_8sGdF5vDjEy8,4635
+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=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=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_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.10.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