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

msfabricpysdkcore/adminapi.py

@@ -658,4 +658,52 @@ class FabricClientAdmin(FabricClient):
             break
 
         response = json.loads(response.text)
-        return response
+        return response
+    
+    def list_external_data_shares(self, continuationToken = None):
+        # GET https://api.fabric.microsoft.com/v1/admin/items/externalDataShares
+        """List external data shares
+        
+        Returns:
+            list: The list of external data shares
+        """
+        url = "https://api.fabric.microsoft.com/v1/admin/items/externalDataShares"
+
+        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):
+                raise Exception(f"Error listing external data shares: {response.status_code}, {response.text}")
+            break
+
+        response = json.loads(response.text)
+        list_data_shares = response["value"]
+
+        if "continuationToken" in response and response["continuationToken"] is not None:
+            list_data_shares_next = self.list_external_data_shares(continuationToken=response["continuationToken"])
+            list_data_shares.extend(list_data_shares_next)
+        return list_data_shares
+    
+    def revoke_external_data_share(self, external_data_share_id, item_id, workspace_id):
+        # POST https://api.fabric.microsoft.com/v1/admin/workspaces/{workspaceId}/items/{itemId}/externalDataShares/{externalDataShareId}/revoke
+        """Revoke an external data share"""
+        url = f"https://api.fabric.microsoft.com/v1/admin/workspaces/{workspace_id}/items/{item_id}/externalDataShares/{external_data_share_id}/revoke"
+
+        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):
+                raise Exception(f"Error revoking external data share: {response.status_code}, {response.text}")
+            break
+
+        return response.status_code
+

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):
@@ -991,4 +1011,49 @@ class FabricClientCore(FabricClient):
         return ws.update_spark_settings(automatic_log=automatic_log, 
                                         environment=environment, 
                                         high_concurrency=high_concurrency, 
-                                        pool=pool)
+                                        pool=pool)
+    
+
+    # External Data Shares
+
+    # create
+
+    def create_external_data_share(self, workspace_id, item_id, paths, recipient):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_external_data_share(item_id=item_id, paths = paths, recipient = recipient)
+
+    # get
+
+    def get_external_data_share(self, workspace_id, item_id, external_data_share_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_external_data_share(item_id=item_id, external_data_share_id=external_data_share_id)
+
+    # list
+
+    def list_external_data_shares_in_item(self, workspace_id, item_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_external_data_shares_in_item(item_id=item_id)
+
+    # revoke
+
+    def revoke_external_data_share(self, workspace_id, item_id, external_data_share_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.revoke_external_data_share(item_id=item_id, external_data_share_id=external_data_share_id)
+    
+
+    # One Lake Data Access Security
+
+    # create and update
+
+    def create_or_update_data_access_roles(self, workspace_id, item_id, data_access_roles, dryrun = False, etag_match = None):
+        ws = self.get_workspace_by_id(workspace_id)
+        item =  ws.get_item(item_id=item_id).create_or_update_data_access_roles(data_access_roles = data_access_roles,
+                                                                                  dryrun = dryrun, etag_match = etag_match)
+        return item
+    
+    # list 
+
+    def list_data_access_roles(self, workspace_id, item_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        item = ws.get_item(item_id=item_id)
+        return item.list_data_access_roles()

msfabricpysdkcore/environment.py

@@ -135,16 +135,17 @@ class Environment(Item):
         # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries
         raise NotImplementedError("Not implemented yet")
         # url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/libraries"
-
-        # for _ in range(10):
-        #     response = requests.post(url=url, files={'file': file_path}, 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 uploading staging libraries: {response.status_code}, {response.text}")
-        #     break
+        # with open(file_path, 'rb') as f:
+        #     files = {"upload_file.whl": f}
+        #     for _ in range(10):
+        #         response = requests.post(url=url, files=files, 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 uploading staging libraries: {response.status_code}, {response.text}")
+        #         break
 
         # return json.loads(response.text)
     

msfabricpysdkcore/item.py

@@ -6,7 +6,6 @@ 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"""
 
@@ -247,10 +246,7 @@ class Item:
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-
-                raise Exception(f"Error getting job instance: {response.text}")
+                raise Exception(f"Error getting job instance: {response.status_code}, {response.text}")
             break
 
         job_dict = json.loads(response.text)
@@ -268,4 +264,149 @@ class Item:
     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")
+        raise NotImplementedError("Load table only works on Lakehouse Items")
+    
+    def create_external_data_share(self, paths, recipient):
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/externalDataShares
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/externalDataShares"
+
+        body = {
+            'paths': paths,
+            'recipient': recipient
+        }
+
+        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 (201, 429):
+                raise Exception(f"Error creating external data share: {response.status_code}, {response.text}")
+            break
+        return json.loads(response.text)
+    
+    def get_external_data_share(self, external_data_share_id):
+        # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/externalDataShares/{externalDataShareId}
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/externalDataShares/{external_data_share_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 external data share: {response.status_code}, {response.text}")
+            break
+        return json.loads(response.text)
+    
+    def list_external_data_shares_in_item(self, continuationToken = None):
+        # GET GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/externalDataShares?continuationToken={continuationToken}
+
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/externalDataShares"
+
+        if continuationToken:
+            url += f"?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):
+                raise Exception(f"Error listing external data shares: {response.status_code}, {response.text}")
+            break
+        
+        resp = json.loads(response.text)
+        external_data_shares = resp['value']
+
+        if 'continuationToken' in resp:
+            external_data_shares_new = self.list_external_data_shares_in_item(continuationToken=resp['continuationToken'])
+            external_data_shares.extend(external_data_shares_new)
+
+        return external_data_shares
+    
+    def revoke_external_data_share(self, external_data_share_id):
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/externalDataShares/{externalDataShareId}/revoke
+
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/externalDataShares/{external_data_share_id}/revoke"
+
+        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):
+                raise Exception(f"Error revoking external data share: {response.status_code}, {response.text}")
+            break
+
+        return response.status_code
+
+
+    # One Lake data access security
+
+    def list_data_access_roles(self, continuationToken = None):
+        # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/dataAccessRoles
+
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/dataAccessRoles"
+
+        if continuationToken:
+            url += f"?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):
+                raise Exception(f"Error revoking external data share: {response.status_code}, {response.text}")
+            break
+
+        resp_dict = json.loads(response.text)
+        data_access_roles = resp_dict['value']
+        etag = response.headers.get('ETag', None)
+
+        if 'continuationToken' in resp_dict and resp_dict['continuationToken']:
+            data_access_roles_new, etag = self.list_data_access_roles(continuationToken=resp_dict['continuationToken'])
+            data_access_roles.extend(data_access_roles_new)
+
+        return data_access_roles, etag
+    
+    def create_or_update_data_access_roles(self, data_access_roles, dryrun = False, etag_match = None):
+        # PUT https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/dataAccessRoles
+
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/dataAccessRoles"
+
+        if dryrun:
+            url += "?dryrun=true"
+
+        if etag_match:
+            if 'If-Match' in etag_match:
+                headers = self.auth.get_headers()
+                headers['If-Match'] = etag_match['If-Match']
+            elif 'If-None-Match' in etag_match:
+                headers = self.auth.get_headers()
+                headers['If-None-Match'] = etag_match['If-None-Match']
+            else:
+                raise Exception("Etag match should include If-Match or If-None-Match")
+        else:
+            headers = self.auth.get_headers()
+
+        body = {"value" : data_access_roles}
+        
+        for _ in range(10):
+            response = requests.put(url=url, headers=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):
+                raise Exception(f"Error creating or updating data access roles: {response.status_code}, {response.text}")
+            break
+
+        return response

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_admin_apis.py

@@ -77,3 +77,23 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertEqual(resp["itemsChangeLabelStatus"][0]["status"], "Succeeded")
         resp = fca.bulk_remove_labels(items=items)
         self.assertEqual(resp["itemsChangeLabelStatus"][0]["status"], "Succeeded")
+
+    def test_admin_external_data_shares(self):
+
+        fca = self.fca
+
+        data_shares = fca.list_external_data_shares()
+        ws = fca.list_workspaces(name="testworkspace")[0]
+
+        data_shares = [d for d in data_shares if d['workspaceId'] == ws.id]
+
+        self.assertGreater(len(data_shares), 0)
+        fca.revoke_external_data_share(external_data_share_id = data_shares[0]['id'], 
+                                       item_id = data_shares[0]['itemId'], 
+                                       workspace_id = data_shares[0]['workspaceId'])
+        data_shares = fca.list_external_data_shares()
+        ws = fca.list_workspaces(name="testworkspace")[0]
+
+        data_shares = [d for d in data_shares if d['workspaceId'] == ws.id]
+
+        self.assertEqual(data_shares[0]['status'], 'Revoked')

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_external_data_shares.py

@@ -0,0 +1,51 @@
+import unittest
+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_external_data_shares(self):
+        
+        fc = self.fc
+
+        workspace_id = 'c3352d34-0b54-40f0-b204-cc964b1beb8d'
+        item_id = 'e2c09c89-bf97-4f71-bdeb-36338795ec36'
+
+        recipient = {
+            "userPrincipalName": "lisa4@fabrikam.com"
+        }
+        paths=["Files/external"]
+
+        resp = fc.create_external_data_share(workspace_id, item_id, paths, recipient)
+        self.assertIsNotNone(resp)
+        self.assertIn('id', resp)
+
+
+        get = fc.get_external_data_share(workspace_id, item_id, resp['id'])
+        self.assertIsNotNone(get)
+        self.assertEqual(get['id'], resp['id'])
+
+
+        resp = fc.list_external_data_shares_in_item(workspace_id, item_id)
+        self.assertGreater(len(resp), 0)
+
+        data_share_ids = [ds['id'] for ds in resp]
+        self.assertIn(get['id'], data_share_ids)
+
+
+        resp = fc.revoke_external_data_share(workspace_id, item_id, get['id'])
+        self.assertEqual(resp, 200)
+
+        get2 = fc.get_external_data_share(workspace_id, item_id, get['id'])
+        self.assertIsNotNone(get2)
+        
+        self.assertEqual(get['id'], get2['id'])
+        self.assertEqual(get2['status'], 'Revoked')
+
+

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