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

msfabricpysdkcore/environment.py

@@ -1,9 +1,4 @@
-import json 
-import requests
-from time import sleep
-
 from msfabricpysdkcore.item import Item
-from msfabricpysdkcore.long_running_operation import check_long_running_operation
 
 class Environment(Item):
     """Class to represent a item in Microsoft Fabric"""
@@ -11,48 +6,19 @@ class Environment(Item):
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return Environment(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""),
-            auth=auth)
+            auth=core_client)
 
-    # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/sparkcompute
     def get_published_settings(self):
         """Get the published settings of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/sparkcompute"
-
-        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 published settings: {response.status_code}, {response.text}")
-            break
-
-        resp_json = json.loads(response.text)        
-        return resp_json
+        return self.core_client.get_published_settings(self.workspace_id, self.id)
     
-    # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/sparkcompute
-
     def get_staging_settings(self):
         """Get the staging settings of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/sparkcompute"
-
-        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 staging settings: {response.status_code}, {response.text}")
-            break
-
-        resp_json = json.loads(response.text)        
-        return resp_json
+        return self.core_client.get_staging_settings(self.workspace_id, self.id)
 
 
     def update_staging_settings(self,
@@ -60,150 +26,26 @@ class Environment(Item):
                                 executor_cores = None, executor_memory = None, instance_pool = None,
                                 runtime_version = None, spark_properties = None):
         """Update the staging settings of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/sparkcompute"
-        body = {}
-        if driver_cores is not None:
-            body['driverCores'] = driver_cores
-        if driver_memory is not None:
-            body['driverMemory'] = driver_memory
-        if dynamic_executor_allocation is not None:
-            body['dynamicExecutorAllocation'] = dynamic_executor_allocation
-        if executor_cores is not None:
-            body['executorCores'] = executor_cores
-        if executor_memory is not None:
-            body['executorMemory'] = executor_memory
-        if instance_pool is not None:
-            body['instancePool'] = instance_pool
-        if runtime_version is not None:
-            body['runtimeVersion'] = runtime_version
-        if spark_properties is not None:
-            body['sparkProperties'] = spark_properties
-
-        
-        for _ in range(10):
-            response = requests.patch(url=url, headers=self.auth.get_headers(), json=body)
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error updating staging settings: {response.status_code}, {response.text}")
-            break
-
-        return json.loads(response.text)
-
-#  GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/libraries
+        return self.core_client.update_staging_settings(self.workspace_id, self.id, driver_cores, driver_memory,
+                                                        dynamic_executor_allocation, executor_cores, executor_memory,
+                                                        instance_pool, runtime_version, spark_properties)
 
     def get_published_libraries(self):
         """Get the published libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/libraries"
-
-        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 published libraries: {response.status_code}, {response.text}")
-            break
-
-        resp_json = json.loads(response.text)
-        return resp_json
+        return self.core_client.get_published_libraries(self.workspace_id, self.id)
     
-# GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries
-
     def get_staging_libraries(self):
         """Get the staging libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/libraries"
-
-        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 staging libraries: {response.status_code}, {response.text}")
-            break
-
-        resp_json = json.loads(response.text)
-        return resp_json
+        return self.core_client.get_staging_libraries(self.workspace_id, self.id)
     
-
     def upload_staging_library(self, file_path):
-        # 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
-
-        # return json.loads(response.text)
+        return self.core_client.upload_staging_library(self.workspace_id, self.id, file_path)
     
-# DELETE https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries?libraryToDelete={libraryToDelete}
-
     def delete_staging_library(self, library_to_delete):
-        """Delete a library from the staging libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/libraries?libraryToDelete={library_to_delete}"
-
-        for _ in range(10):
-            response = requests.delete(url=url, headers=self.auth.get_headers())
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error deleting staging libraries: {response.status_code}, {response.text}")
-            break
-
-        return response.text
+        return self.core_client.delete_staging_library(self.workspace_id, self.id, library_to_delete)
     
-# POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/publish
-
     def publish_environment(self):
-        """Publish the staging settings and libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/publish"
-
-        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:
-                publish_info = check_long_running_operation(response.headers, self.auth)
-                return publish_info
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error publishing staging: {response.status_code}, {response.text}")
-            break
-
-        resp_dict = json.loads(response.text)
-        return resp_dict
-
-
-# POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/cancelPublish
+        return self.core_client.publish_environment(self.workspace_id, self.id) 
 
     def cancel_publish(self):
-        """Cancel the publishing of the staging settings and libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/cancelPublish"
-
-        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 canceling publishing: {response.status_code}, {response.text}")
-            break
-
-        resp_dict = json.loads(response.text)
-        return resp_dict
+        return self.core_client.cancel_publish(self.workspace_id, self.id)

msfabricpysdkcore/item.py

@@ -1,16 +1,11 @@
 import json 
-import requests
-from time import sleep
-
-from msfabricpysdkcore.onelakeshortcut import OneLakeShortcut
-from msfabricpysdkcore.job_instance import JobInstance
-from msfabricpysdkcore.long_running_operation import check_long_running_operation
 
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 class Item:
     """Class to represent a item in Microsoft Fabric"""
 
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description="") -> None:
+    def __init__(self, id, display_name, type, workspace_id, core_client: FabricClientCore, properties = None, definition=None, description="") -> None:
         
         self.id = id
         self.display_name = display_name
@@ -20,7 +15,7 @@ class Item:
         self.properties = properties
         self.workspace_id = workspace_id
         
-        self.auth = auth
+        self.core_client = core_client
 
     def __str__(self) -> str:
         """Return a string representation of the workspace object"""
@@ -38,234 +33,104 @@ class Item:
     def __repr__(self) -> str:
         return self.__str__()
     
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         """Create Item object from dictionary"""
         
         return Item(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
                     properties=item_dict.get('properties', None),
-                    definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+                    definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
     def delete(self, type = None):
         """Delete the workspace item"""
 
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}"
-        if type:
-            url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/{type}/{self.id}"
-        for _ in range(10):
-            response = requests.delete(url=url, headers=self.auth.get_headers())
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error deleting item: {response.status_code}, {response.text}")
-            break
-
-        return response.status_code
+        return self.core_client.delete_item(self.workspace_id, self.id, type=type)
     
     def get_definition(self, type = None, format = None):
         """Get the definition of the item"""
-        
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/getDefinition"
-        if type:
-            url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/{type}/{self.id}/getDefinition"
+        resp_dict = self.core_client.get_item_definition(self.workspace_id, self.id, type=type, format=format)
 
-        if format:
-            url += f"?format={format}"
-
-        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:
-                operation_result = check_long_running_operation( response.headers, self.auth)
-                self.definition = operation_result['definition']
-                return operation_result
-                
-            if response.status_code not in (200, 202, 429):
-                print(response.status_code)
-                print(response.text)
-                raise Exception(f"Error getting item definition: {response.text}")
-            break
-        
-        resp_dict = json.loads(response.text)
         self.definition = resp_dict['definition']
         return resp_dict
-    
-    def update(self, display_name = None, description = None, type = None):
-        """Update the item"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}"
-        if type:
-            url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/{type}/{self.id}"
 
-        payload = dict()
-        if display_name:
-            payload['displayName'] = display_name
-        if description:
-            payload['description'] = description
-        for _ in range(10):
-            response = requests.patch(url=url, headers=self.auth.get_headers(), json=payload)
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
 
-                raise Exception(f"Error updating item: {response.text}")
-            break
+    def update(self, display_name = None, description = None, type = None, return_item="Default"):
+        """Update the item"""
+
+        resp_dict = self.core_client.update_item(workspace_id=self.workspace_id, item_id=self.id,
+                                                 display_name=display_name, description=description, type=type,
+                                                 return_item=return_item)
         if display_name:
-            self.display_name = payload['displayName']
+            self.display_name = display_name
         if description:
-            self.description = payload['description']
+            self.description = description
 
-        return self
+        return resp_dict
 
     def update_definition(self, definition, type = None):
         """Update the item definition"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/updateDefinition"
-
-        if type:
-            url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/{type}/{self.id}/updateDefinition"
-            
-        payload = {
-            'definition': definition
-        }
-        for _ in range(10):
-            response = requests.post(url=url, headers=self.auth.get_headers(), json=payload)
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code == 202:
-                check_long_running_operation( response.headers, self.auth)
-            if response.status_code not in (200, 202, 429):
-                print(response.status_code)
-                print(response.text)
+        response = self.core_client.update_item_definition(workspace_id=self.workspace_id, item_id=self.id, 
+                                                           definition=definition, type=type)
 
-                raise Exception(f"Error updating item definition: {response.text}")
-            break
-
-        self.definition = payload['definition']
-        return self
+        self.definition = definition 
+        return response
     
-    def get_shortcut(self, path, name):
-        """Get the shortcut in the item"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/shortcuts/{path}/{name}"
-        
-        for _ in range(10):
-            response = requests.get(url=url, headers=self.auth.get_headers())
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-
-                raise Exception(f"Error getting shortcut: {response.text}")
-            break
+    # Shortcut
 
-        shortcut_dict = json.loads(response.text)
-        shortcut_dict['workspaceId'] = self.workspace_id
-        shortcut_dict['itemId'] = self.id
-        return OneLakeShortcut.from_dict(shortcut_dict,
-                                         auth = self.auth)
-    
     def create_shortcut(self, path, name, target):
         """Create a shortcut in the item"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/shortcuts"
-
-        body = {'name': name,
-                'path': path,
-                'target': target}
-
-        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):
-                print(response.status_code)
-                print(response.text)
-
-                raise Exception(f"Error creating shortcut: {response.text}")
-            break
-
-        shortcut_dict = json.loads(response.text)
-        shortcut_dict['workspaceId'] = self.workspace_id
-        shortcut_dict['itemId'] = self.id
-        return OneLakeShortcut.from_dict(shortcut_dict,
-                                         auth = self.auth)
+        return self.core_client.create_shortcut(workspace_id=self.workspace_id, item_id=self.id,
+                                                path=path, name=name, target=target)
     
     def delete_shortcut(self, path, name):
         """Delete the shortcut in the item"""
-        return self.get_shortcut(path, name).delete()
+        return self.core_client.delete_shortcut(workspace_id=self.workspace_id, item_id=self.id,
+                                                path=path, name=name)
+
+    def get_shortcut(self, path, name):
+        """Get the shortcut in the item"""
+        return self.core_client.get_shortcut(workspace_id=self.workspace_id, item_id=self.id,
+                                                path=path, name=name)
     
 
-    def run_on_demand_item_job(self, job_type, execution_data = None):
-        """Run an on demand job on the item"""
+    # Job Scheduler
 
-        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/jobs/instances?jobType={jobType}
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/jobs/instances?jobType={job_type}"
-        payload = {
-            'executionData': execution_data
-        }
+    def cancel_item_job_instance(self, job_instance_id):
+        """Cancel a job instance ofjob the item"""
+        return self.core_client.cancel_item_job_instance(workspace_id=self.workspace_id, item_id=self.id,
+                                                         job_instance_id=job_instance_id)
+        
+    def get_item_job_instance(self, job_instance_id):
+        """Get the job instance of the item"""
+        return self.core_client.get_item_job_instance(workspace_id=self.workspace_id, item_id=self.id,
+                                                      job_instance_id=job_instance_id)
 
-        for _ in range(10):
-            if execution_data:
-                response = requests.post(url=url, headers=self.auth.get_headers(), json=payload)
-            else:
-                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
+    def run_on_demand_item_job(self, job_type, execution_data = None):
+        return self.core_client.run_on_demand_item_job(workspace_id=self.workspace_id, item_id=self.id,
+                                                       job_type=job_type, execution_data=execution_data)
 
-            if response.status_code not in (202, 429):
-                print(response.status_code)
-                print(response.text)
+    
+    # External Data Shares
 
-                raise Exception(f"Error running on demand job: {response.text}")
-            break
-        job_instance_id = response.headers["Location"].split("/")[-1]
-        job_instance = self.get_item_job_instance(job_instance_id=job_instance_id)
-        return job_instance
+    def create_external_data_share(self, paths, recipient):
+        return self.core_client.create_external_data_share(workspace_id=self.workspace_id, item_id=self.id,
+                                                           paths=paths, recipient=recipient)
 
-    def get_item_job_instance(self, job_instance_id):
-        """Get the job instance of the item"""
+    def get_external_data_share(self, external_data_share_id):
+        return self.core_client.get_external_data_share(workspace_id=self.workspace_id, item_id=self.id,
+                                                       external_data_share_id=external_data_share_id)
 
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}/jobs/instances/{job_instance_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):
-                print(response.status_code)
-                print(response.text)
+    def list_external_data_shares_in_item(self):
+        return self.core_client.list_external_data_shares_in_item(workspace_id=self.workspace_id, item_id=self.id)
+    
+    def revoke_external_data_share(self, external_data_share_id):
+        return self.core_client.revoke_external_data_share(workspace_id=self.workspace_id, item_id=self.id,
+                                                          external_data_share_id=external_data_share_id)
 
-                raise Exception(f"Error getting job instance: {response.text}")
-            break
+    # One Lake data access security
 
-        job_dict = json.loads(response.text)
-        job_dict['workspaceId'] = self.workspace_id
-        job_dict['itemId'] = self.id
-        return JobInstance.from_dict(job_dict, auth=self.auth)
-    
-    def cancel_item_job_instance(self, job_instance_id):
-        """Cancel a job instance ofjob the item"""
-        return self.get_item_job_instance(job_instance_id=job_instance_id).cancel()
-        
-    def list_tables(self):
-        raise NotImplementedError("List tables only works on Lakehouse Items")
+    def list_data_access_roles(self):
+        return self.core_client.list_data_access_roles(workspace_id=self.workspace_id, item_id=self.id)
     
-    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")
+    def create_or_update_data_access_roles(self, data_access_roles, dryrun = False, etag_match = None):
+        return self.core_client.create_or_update_data_access_roles(workspace_id=self.workspace_id, item_id=self.id,
+                                                                     data_access_roles=data_access_roles, dryrun=dryrun, etag_match=etag_match)

msfabricpysdkcore/job_instance.py

@@ -1,11 +1,10 @@
 import json 
-import requests
-from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 class JobInstance:
     """Class to represent a job instance in Microsoft Fabric"""
 
-    def __init__(self, id, item_id, workspace_id, auth, job_type, invoke_type, status, root_activity_id,
+    def __init__(self, id, item_id, workspace_id, core_client: FabricClientCore, job_type, invoke_type, status, root_activity_id,
                  start_time_utc, end_time_utc, failureReason):
 
         self.id = id
@@ -19,7 +18,7 @@ class JobInstance:
         self.end_time_utc = end_time_utc
         self.failureReason = failureReason
         
-        self.auth = auth
+        self.core_client = core_client
 
 
     def __str__(self) -> str:
@@ -41,28 +40,15 @@ class JobInstance:
     def __repr__(self) -> str:
         return self.__str__()
     
-    def from_dict(job_dict, auth):
+    def from_dict(job_dict, core_client):
         """Create JobInstance object from dictionary"""
         return JobInstance(id=job_dict['id'], item_id=job_dict['itemId'], workspace_id=job_dict['workspaceId'],
                            job_type=job_dict['jobType'], invoke_type=job_dict['invokeType'], status=job_dict['status'],
                            root_activity_id=job_dict['rootActivityId'], start_time_utc=job_dict['startTimeUtc'],
-                           end_time_utc=job_dict['endTimeUtc'], failureReason=job_dict['failureReason'], auth=auth)
+                           end_time_utc=job_dict['endTimeUtc'], failureReason=job_dict['failureReason'], core_client=core_client)
     
     def cancel(self):
         """Cancel the job instance"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.item_id}/jobs/instances/{self.id}/cancel"
-        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 (202, 429):
-                print(response.status_code)
-                print(response.text)
-
-                raise Exception(f"Error running on demand job: {response.text}")
-            break
-
-        return response.status_code
+        return self.core_client.cancel_item_job_instance(workspace_id=self.workspace_id,
+                                                         item_id=self.item_id,
+                                                         job_instance_id=self.id)