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

msfabricpysdkcore/environment.py

@@ -0,0 +1,209 @@
+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"""
+
+    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):
+        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)
+
+    # 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
+    
+    # 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
+
+
+    def update_staging_settings(self,
+                                driver_cores = None, driver_memory = None, dynamic_executor_allocation = None,
+                                executor_cores = None, executor_memory = None, instance_pool = None,
+                                runtime_version = None, spark_properties = None):
+        """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
+
+    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
+    
+# 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
+    
+
+    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)
+    
+# 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
+    
+# 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
+
+    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

msfabricpysdkcore/item.py

@@ -41,11 +41,6 @@ class Item:
     def from_dict(item_dict, auth):
         """Create Item object from dictionary"""
         
-        if item_dict['type'] == "Lakehouse":
-            from msfabricpysdkcore.lakehouse import Lakehouse
-            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)
         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)
@@ -63,18 +58,20 @@ class Item:
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error deleting item: {response.text}")
+                raise Exception(f"Error deleting item: {response.status_code}, {response.text}")
             break
 
         return response.status_code
     
-    def get_definition(self):
+    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}"
 
         for _ in range(10):
             response = requests.post(url=url, headers=self.auth.get_headers())
@@ -127,9 +124,13 @@ class Item:
 
         return self
 
-    def update_definition(self, definition):
+    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
         }

msfabricpysdkcore/lakehouse.py

@@ -3,6 +3,7 @@ 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"""
@@ -10,6 +11,10 @@ class Lakehouse(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):
+        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)
 
     def list_tables(self, continuationToken = None):
         """List all tables in the lakehouse"""
@@ -92,4 +97,40 @@ class Lakehouse(Item):
             
             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

msfabricpysdkcore/long_running_operation.py

@@ -25,9 +25,7 @@ class LongRunningOperation:
             if response.status_code == 400:
                 return None
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                raise Exception(f"Error getting operation results: {response.text}")
+                raise Exception(f"Error getting operation results: {response.status_code}, {response.text}")
             break
 
         return json.loads(response.text)
@@ -43,9 +41,7 @@ class LongRunningOperation:
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                raise Exception(f"Error getting operation state: {response.text}")
+                raise Exception(f"Error getting operation state: {response.status_code},  {response.text}")
             break
 
         return json.loads(response.text)    

msfabricpysdkcore/otheritems.py

@@ -1,42 +1,111 @@
+import json
 from time import sleep
-
+import requests
 from msfabricpysdkcore.item import Item
 
+
+class Eventhouse(Item):
+    """Class to represent a eventhouse in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, description=""):
+        super().__init__(id = id, display_name=display_name, type=type, 
+                         workspace_id=workspace_id, auth=auth, properties=properties, 
+                         description=description)
+        
+    def from_dict(item_dict, auth):
+        if "displayName" not in item_dict:
+            item_dict["displayName"] = item_dict["display_name"]
+        if "workspaceId" not in item_dict:
+            item_dict["workspaceId"] = item_dict["workspace_id"]
+
+        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)
+
+    def create_kql_database(self, display_name = None, description= None):
+        from msfabricpysdkcore.coreapi import FabricClientCore
+        """Method to create a kql database in the eventhouse"""
+        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)
+
 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 from_dict(item_dict, auth):
+        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)
+    
+    def get_definition(self, format=None):
+        return super().get_definition(type="sparkJobDefinitions", format=format)
+    
+    def update_definition(self, definition):
+        return super().update_definition(definition=definition, type="sparkJobDefinitions")
+    
 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 from_dict(item_dict, auth):
+        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)
+
 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 from_dict(item_dict, auth):
+        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)
+
 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 from_dict(item_dict, auth):
+        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)
+
 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 from_dict(item_dict, auth):
+        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)
+    
 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 from_dict(item_dict, auth):
+        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)
 
 class MLModel(Item):
     """Class to represent a ml model in Microsoft Fabric"""
@@ -44,29 +113,79 @@ class MLModel(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):
+        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)
+
 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 from_dict(item_dict, auth):
+        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)
+    
+    def get_definition(self, format=None):
+        """Method to get the definition of the notebook"""
+        return super().get_definition(type = "notebooks", format = format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the notebook"""
+        return super().update_definition(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 from_dict(item_dict, auth):
+        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)
+    
+    def get_definition(self, type=None, format=None):
+        """Method to get the definition of the report"""
+        return super().get_definition(type = "reports", format = format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the report"""
+        return super().update_definition(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 from_dict(item_dict, auth):
+        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)
+    
+    def get_definition(self, format=None):
+        """Method to get the definition of the semantic model"""
+        return super().get_definition(type="semanticModels", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the semantic model"""
+        return super().update_definition(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 from_dict(item_dict, auth):
+        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)
+    
     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 super().run_on_demand_item_job(job_type = "Pipeline", execution_data=execution_data)
+    

msfabricpysdkcore/spark_custom_pool.py

@@ -0,0 +1,118 @@
+import json
+from time import sleep
+
+import requests 
+
+
+class SparkCustomPool:
+    """Class to represent a custom pool in Microsoft Fabric"""
+
+    def __init__(self, id, name, type, node_family, node_size, auto_scale, dynamic_executor_allocation, workspace_id, auth) -> None:
+        
+        self.id = id
+        self.name = name
+        self.type = type
+        self.node_family = node_family
+        self.node_size = node_size
+        self.auto_scale = auto_scale
+        self.dynamic_executor_allocation = dynamic_executor_allocation
+        self.workspace_id = workspace_id
+        
+        self.auth = auth
+
+    def __str__(self) -> str:
+        """Return a string representation of the workspace object"""
+        dict_ = {
+            "id": self.id,
+            "name": self.name,
+            "type": self.type,
+            "nodeFamily": self.node_family,
+            "nodeSize": self.node_size,
+            "autoScale": self.auto_scale,
+            "dynamicExecutorAllocation": self.dynamic_executor_allocation,
+            "workspaceId": self.workspace_id
+        }
+        return json.dumps(dict_, indent=2)
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def from_dict(item_dict, auth):
+        """Create Item object from dictionary"""
+
+        if 'autoScale' not in item_dict:
+            item_dict['autoScale'] = item_dict['auto_scale']
+
+        if 'dynamicExecutorAllocation' not in item_dict:
+            item_dict['dynamicExecutorAllocation'] = item_dict['dynamic_executor_allocation']
+        
+        if 'nodeFamily' not in item_dict:
+            item_dict['nodeFamily'] = item_dict['node_family']
+        
+        if 'nodeSize' not in item_dict:
+            item_dict['nodeSize'] = item_dict['node_size']
+        
+        return SparkCustomPool(id=item_dict['id'], name=item_dict['name'], type=item_dict['type'], node_family=item_dict['nodeFamily'],
+                                node_size=item_dict['nodeSize'], auto_scale=item_dict['autoScale'], dynamic_executor_allocation=item_dict['dynamicExecutorAllocation'],
+                                workspace_id=item_dict['workspaceId'], auth=auth)
+
+
+    def delete(self):
+        """Delete the custom pool item"""
+        # DELETE http://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/spark/pools/{poolId}
+
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/spark/pools/{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 spark pool: {response.status_code}, {response.text}")
+            break
+
+        return response.status_code
+    
+
+    def update(self, name, node_family, node_size, auto_scale, dynamic_executor_allocation):
+        """Update the custom pool item"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/spark/pools/{self.id}"
+        body = {}
+
+        if name is not None:
+            body['name'] = name
+        if node_family is not None:
+            body['nodeFamily'] = node_family
+        if node_size is not None:
+            body['nodeSize'] = node_size
+        if auto_scale is not None:
+            body['autoScale'] = auto_scale
+        if dynamic_executor_allocation is not None:
+            body['dynamicExecutorAllocation'] = dynamic_executor_allocation
+
+        if not body:
+            return self
+        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 item: {response.status_code}, {response.text}")
+            break
+
+        if name is not None:
+            self.name = name
+        if node_family is not None:
+            self.node_family = node_family
+        if node_size is not None:
+            self.node_size = node_size
+        if auto_scale is not None:
+            self.auto_scale = auto_scale
+        if dynamic_executor_allocation is not None:
+            self.dynamic_executor_allocation = dynamic_executor_allocation
+
+        return self
+