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

msfabricpysdkcore/item.py

@@ -1,15 +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
@@ -19,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"""
@@ -37,376 +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"
-
-        if format:
-            url += f"?format={format}"
+        resp_dict = self.core_client.get_item_definition(self.workspace_id, self.id, type=type, 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)
+    # Shortcut
 
-                raise Exception(f"Error getting 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)
-    
     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()
-    
-
-    def run_on_demand_item_job(self, job_type, execution_data = None):
-        """Run an on demand job on the item"""
+        return self.core_client.delete_shortcut(workspace_id=self.workspace_id, item_id=self.id,
+                                                path=path, name=name)
 
-        # 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
-        }
-
-        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
-
-            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
-        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 get_item_job_instance(self, job_instance_id):
-        """Get the job instance of the item"""
+    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)
+    
 
-        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):
-                raise Exception(f"Error getting job instance: {response.status_code}, {response.text}")
-            break
+    # Job Scheduler
 
-        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()
+        return self.core_client.cancel_item_job_instance(workspace_id=self.workspace_id, item_id=self.id,
+                                                         job_instance_id=job_instance_id)
         
-    def list_tables(self):
-        raise NotImplementedError("List tables only works on Lakehouse Items")
-    
-    def load_table(self, table_name, path_type, relative_path,
-                    file_extension = None, format_options = None,
-                    mode = None, recursive = None, wait_for_completion = True):
-        raise NotImplementedError("Load table only works on Lakehouse Items")
-    
-    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
-        }
+    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):
-            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}"
+    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)
 
-        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}
+    # External Data Shares
 
-        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']
+    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)
 
-        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)
+    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)
 
-        return external_data_shares
+    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):
-        # 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
-
+        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)
 
     # 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 list_data_access_roles(self):
+        return self.core_client.list_data_access_roles(workspace_id=self.workspace_id, item_id=self.id)
     
     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
+        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)

msfabricpysdkcore/lakehouse.py

@@ -1,136 +1,27 @@
-import json 
-import requests
-from time import sleep
-
 from msfabricpysdkcore.item import Item
-from msfabricpysdkcore.long_running_operation import check_long_running_operation
 
 class Lakehouse(Item):
     """Class to represent a item in Microsoft Fabric"""
 
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return Lakehouse(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
-    def list_tables(self, continuationToken = None):
+    def list_tables(self):
         """List all tables in the lakehouse"""
-        # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/lakehouses/{lakehouseId}/tables
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/lakehouses/{self.id}/tables"
-
-        if continuationToken:
-            url = f"{url}?continuationToken={continuationToken}"
-
-        for _ in range(10):
-            response = requests.get(url=url, headers=self.auth.get_headers())
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                raise Exception(f"Error listing tables: {response.status_code},  {response.text}")
-            break
-        resp_dict = json.loads(response.text)
-
-        table_list = resp_dict["data"]
-
-        if "continuationToken" in resp_dict and resp_dict["continuationToken"] is not None:
-            table_list_next = self.list_tables(continuationToken=resp_dict["continuationToken"])
-            table_list.extend(table_list_next)
-
-        return table_list
+        return self.core_client.list_tables(self.workspace_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):
         """Load a table in the lakehouse"""
-        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/lakehouses/{lakehouseId}/tables/{tableName}/load
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/lakehouses/{self.id}/tables/{table_name}/load"
-
-        body = {
-                "relativePath": relative_path,
-                "pathType": path_type,
-              }
-
-        if file_extension:
-            body["fileExtension"] = file_extension
-        if format_options:
-            body["formatOptions"] = format_options
-        if mode:
-            body["mode"] = mode
-        if recursive:
-            body["recursive"] = recursive
-
-        for _ in range(10):
-            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code == 202:
-                if wait_for_completion:
-                    success = self.check_if_table_is_created(table_name)
-                    
-                if not success:
-                    print("Warning: Table not created after 3 minutes")
-                else:
-                    print("Table created")
-            if response.status_code not in (202, 429):
-                print(response.status_code)
-                print(response.text)
-                raise Exception(f"Error loading table: {response.status_code},  {response.text}")
-            break
-
-        return response.status_code
+        return self.core_client.load_table(self.workspace_id, self.id, table_name, path_type, relative_path,
+                                           file_extension, format_options, mode, recursive, wait_for_completion)
     
-    def check_if_table_is_created(self, table_name):
-        """Check if the table is created"""
-        for _ in range(60):
-            table_names = [table["name"] for table in self.list_tables()]
-            if table_name in table_names:
-                return True
-            
-            sleep(3)
-        return False
-    
-    # run on demand table maintenance
-    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/lakehouses/{lakehouseId}/jobs/instances?jobType={jobType}
-
     def run_on_demand_table_maintenance(self, execution_data, job_type = "TableMaintenance", wait_for_completion = True):
         """Run on demand table maintenance"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/lakehouses/{self.id}/jobs/instances?jobType={job_type}"
-
-        body = {
-                "executionData": execution_data
-              }
-
-        for _ in range(10):
-            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code == 202 and wait_for_completion:
-                print("successfully started the operation")
-                try:
-                    operation_result = check_long_running_operation( response.headers, self.auth)
-                    return operation_result
-                except Exception as e:
-                    
-                    print("Problem waiting for long running operation. Returning initial response.")
-                    print(e)
-                    return response
-                
-            if response.status_code not in (200, 202, 429):
-                print(response.status_code)
-                print(response.text)
-
-                raise Exception(f"Error at run on demand table maintenance: {response.text}")
-            break
-
-        return response
+        return self.core_client.run_on_demand_table_maintenance(self.workspace_id, self.id, execution_data, job_type, wait_for_completion)