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

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)

msfabricpysdkcore/long_running_operation.py

@@ -1,54 +1,24 @@
-import json 
-import requests
 from time import sleep, time
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 class LongRunningOperation:
     """Class to represent a workspace in Microsoft Fabric"""
 
-    def __init__(self, operation_id, auth) -> None:
+    def __init__(self, operation_id, core_client: FabricClientCore) -> None:
         self.operation_id = operation_id
-        self.auth = auth
+        self.core_client = core_client
 
         self.state = self.get_operation_state()["status"]
 
 
     def get_operation_results(self):
-        """Get the results of an operation"""
-        url = f"https://api.fabric.microsoft.com/v1/operations/{self.operation_id}/result"
-
-        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 == 400:
-                return None
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error getting operation results: {response.status_code}, {response.text}")
-            break
-
-        return json.loads(response.text)
+        return self.core_client.get_operation_results(operation_id=self.operation_id)
     
     def get_operation_state(self):
-        """Get the state of an operation"""
-        url = f"https://api.fabric.microsoft.com/v1/operations/{self.operation_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 operation state: {response.status_code},  {response.text}")
-            break
-
-        return json.loads(response.text)    
+        return self.core_client.get_operation_state(operation_id=self.operation_id) 
     
     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"]
@@ -63,7 +33,7 @@ class LongRunningOperation:
         return self.state
     
 
-def check_long_running_operation(headers, auth):
+def check_long_running_operation(headers, core_client):
     """Check the status of a long running operation"""
     location = headers.get('Location', None)
     operation_id = headers.get('x-ms-operation-id', None)
@@ -73,7 +43,7 @@ def check_long_running_operation(headers, auth):
     if not operation_id:
         print("Operation initiated, no operation id found")
         return None
-    lro = LongRunningOperation(operation_id=operation_id, auth=auth)
+    lro = LongRunningOperation(operation_id=operation_id, core_client=core_client)
     lro.wait_for_completion()
     
     return lro.get_operation_results()

msfabricpysdkcore/onelakeshortcut.py

@@ -1,12 +1,11 @@
 import json 
-import requests
-from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
 
 class OneLakeShortcut:
     """Class to represent a onelake shortcut in Microsoft Fabric"""
 
     def __init__(self, name, path, workspace_id, item_id, target,
-                  auth) -> None:
+                  core_client: FabricClientCore) -> None:
         
         self.name = name
         self.path = path
@@ -14,7 +13,7 @@ class OneLakeShortcut:
         self.item_id = item_id
         self.workspace_id = workspace_id
 
-        self.user_auth = auth
+        self.core_client = core_client
 
     def __str__(self) -> str:
         """Return a string representation of the workspace object"""
@@ -30,29 +29,16 @@ class OneLakeShortcut:
     def __repr__(self) -> str:
         return self.__str__()
     
-    def from_dict(short_dict, auth):
+    def from_dict(short_dict, core_client):
         """Create OneLakeShortCut object from dictionary"""
         return OneLakeShortcut(name=short_dict['name'],
                                path=short_dict['path'], 
                                target=short_dict['target'], 
                                item_id=short_dict['itemId'], 
                                workspace_id=short_dict['workspaceId'], 
-                               auth=auth)
+                               core_client=core_client)
     
     def delete(self):
         """Delete the shortcut"""
-
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.item_id}/shortcuts/{self.path}/{self.name}"
-        for _ in range(10):
-            response = requests.delete(url=url, headers=self.user_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 deleting shortcut: {response.text}")
-            break
-
-        return response.status_code
+        return self.core_client.delete_shortcut(workspace_id=self.workspace_id, item_id=self.item_id, path=self.path,
+                                                name=self.name)

msfabricpysdkcore/otheritems.py

@@ -1,19 +1,15 @@
-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):
     """Class to represent a eventhouse in Microsoft Fabric"""
      
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, description=""):
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, description=""):
         super().__init__(id = id, display_name=display_name, type=type, 
-                         workspace_id=workspace_id, auth=auth, properties=properties, 
+                         workspace_id=workspace_id, core_client=core_client, properties=properties, 
                          description=description)
         
-    def from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         if "displayName" not in item_dict:
             item_dict["displayName"] = item_dict["display_name"]
         if "workspaceId" not in item_dict:
@@ -22,7 +18,7 @@ class Eventhouse(Item):
         return Eventhouse(id=item_dict['id'], display_name=item_dict['displayName'], 
                           type=item_dict['type'], workspace_id=item_dict['workspaceId'],
                           properties=item_dict.get('properties', None),
-                          description=item_dict.get('description', ""), auth=auth)
+                          description=item_dict.get('description', ""), core_client=core_client)
 
     def create_kql_database(self, display_name = None, description= None):
         from msfabricpysdkcore.coreapi import FabricClientCore
@@ -30,191 +26,170 @@ class Eventhouse(Item):
         creation_payload = {"databaseType" : "ReadWrite",
                             "parentEventhouseItemId" : self.id}
         
-        fcc = FabricClientCore(silent=True)
-
-        return fcc.create_kql_database(workspace_id = self.workspace_id,
-                                       display_name = display_name, description = description,
-                                       creation_payload= creation_payload)
+        return self.core_client.create_kql_database(self.workspace_id, display_name=display_name, description=description, creation_payload=creation_payload)
 
 class SparkJobDefinition(Item):
     """Class to represent a spark job definition 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 SparkJobDefinition(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 get_definition(self, format=None):
-        return super().get_definition(type="sparkJobDefinitions", format=format)
+        resp_dict = self.core_client.get_spark_job_definition_definition(self.workspace_id, self.id, format=format)
+        self.definition = resp_dict['definition']
+        return resp_dict
     
     def update_definition(self, definition):
-        return super().update_definition(definition=definition, type="sparkJobDefinitions")
+        return self.core_client.update_spark_job_definition_definition(self.workspace_id, self.id, definition)
     
     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
+        return self.core_client.run_on_demand_spark_job_definition(workspace_id=self.workspace_id, spark_job_definition_id=self.id, job_type=job_type)
 
 
 class Warehouse(Item):
     """Class to represent a warehouse 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 Warehouse(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)
 
 class KQLDatabase(Item):
     """Class to represent a kql database 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 KQLDatabase(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)
 
 class KQLQueryset(Item):
     """Class to represent a kql database 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 KQLQueryset(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)
 
 class Eventstream(Item):
     """Class to represent a eventstream 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 Eventstream(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)
     
 class MLExperiment(Item):
     """Class to represent a ml experiment 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 MLExperiment(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)
 
 class MLModel(Item):
     """Class to represent a ml model 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 MLModel(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)
 
 class Notebook(Item):
     """Class to represent a notebook 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 Notebook(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 get_definition(self, format=None):
         """Method to get the definition of the notebook"""
-        return super().get_definition(type = "notebooks", format = format)
+        definition = self.core_client.get_item_definition(self.workspace_id, self.id, type="notebooks", format=format)
+        self.definition = definition
+        return definition
     
     def update_definition(self, definition):
         """Method to update the definition of the notebook"""
-        return super().update_definition(definition, type = "notebooks")
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="notebooks")
 
 class Report(Item):
     """Class to represent a report 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 Report(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 get_definition(self, type=None, format=None):
         """Method to get the definition of the report"""
-        return super().get_definition(type = "reports", format = format)
+        self.definition = self.core_client.get_item_definition(self.workspace_id, self.id, type="reports", format=format)
+        return self.definition
     
     def update_definition(self, definition):
         """Method to update the definition of the report"""
-        return super().update_definition(definition, type = "reports")
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="reports")
 
 class SemanticModel(Item):
     """Class to represent a semantic model 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 SemanticModel(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 get_definition(self, format=None):
         """Method to get the definition of the semantic model"""
-        return super().get_definition(type="semanticModels", format=format)
+        self.definition = self.core_client.get_item_definition(self.workspace_id, self.id, type="semanticModels", format=format)
+        return self.definition
     
     def update_definition(self, definition):
         """Method to update the definition of the semantic model"""
-        return super().update_definition(definition, type = "semanticModels")
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="semanticModels")
 
 class DataPipeline(Item):
     """Class to represent a spark job definition 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 DataPipeline(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 run_on_demand_item_job(self, execution_data=None):
-        return super().run_on_demand_item_job(job_type = "Pipeline", execution_data=execution_data)
+        return self.core_client.run_on_demand_item_job(workspace_id=self.workspace_id, item_id=self.id, job_type="Pipeline", execution_data=execution_data)
+