msfabricpysdkcore 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

msfabricpysdkcore/workspace.py

@@ -2,7 +2,11 @@ import json
 import requests
 from time import sleep
 from msfabricpysdkcore.item import Item
+from msfabricpysdkcore.lakehouse import Lakehouse
 from msfabricpysdkcore.long_running_operation import check_long_running_operation
+from msfabricpysdkcore.otheritems import DataPipeline, Eventstream, KQLDatabase, KQLQueryset, SparkJobDefinition
+from msfabricpysdkcore.otheritems import MLExperiment, MLModel, Notebook, Report, SemanticModel, Warehouse
+
 
 class Workspace:
     """Class to represent a workspace in Microsoft Fabric"""
@@ -218,18 +222,55 @@ class Workspace:
         self.capacity_id = None
         return response.status_code
     
+    def get_item_specific(self, item_dict):
+        if item_dict["type"] == "DataPipeline":
+            return self.get_data_pipeline(item_dict["id"])
+        if item_dict["type"] == "Eventstream":
+            return self.get_eventstream(item_dict["id"])
+        if item_dict["type"] == "KQLDatabase":
+            return self.get_kql_database(item_dict["id"])
+        if item_dict["type"] == "KQLQueryset":
+            return self.get_kql_queryset(item_dict["id"])
+        if item_dict["type"] == "Lakehouse":
+            return self.get_lakehouse(item_dict["id"])
+        if item_dict["type"] == "MLExperiment":
+            return self.get_ml_experiment(item_dict["id"])
+        if item_dict["type"] == "MLModel":
+            return self.get_ml_model(item_dict["id"])
+        if item_dict["type"] == "Notebook":
+            return self.get_notebook(item_dict["id"])
+        if item_dict["type"] == "Report":
+            return self.get_report(item_dict["id"])
+        if item_dict["type"] == "SemanticModel":
+            return self.get_semantic_model(item_dict["id"])
+        if item_dict["type"] == "SparkJobDefinition":
+            return self.get_spark_job_definition(item_dict["id"])
+        if item_dict["type"] == "Warehouse":
+            return self.get_warehouse(item_dict["id"])
+
+        item_obj = Item.from_dict(item_dict, auth=self.auth)
+        return item_obj
+
     def create_item(self, display_name, type, definition = None, description = None):
         """Create an item in a workspace"""
 
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/items"
-
         body = {
             'displayName': display_name,
-            'type': type,
-            'definition': definition,
-            'description': description
+            'type': type
         }
 
+        if definition:
+            body['definition'] = definition
+        if description:
+            body['description'] = description
+
+        if type in ["eventstreams", "lakehouses", "mlExperiments", "mlModels", "notebooks", "reports", "semanticModels", 
+                    "sparkJobDefinitions", "warehouses"]:
+            url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/{type}"
+            body.pop('type')
+
+
         for _ in range(10):
             response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
             if response.status_code == 429:
@@ -247,26 +288,44 @@ class Workspace:
         item_dict = json.loads(response.text)
         if item_dict is None:
             print("Item not returned by API, trying to get it by name")
-            return self.get_item_by_name(display_name, type)        
-        return Item.from_dict(item_dict, auth=self.auth)
-        
+            item = None
+            i = 0
+
+            type_mapping = {"eventstreams": "Eventstream",
+                            "lakehouses": "Lakehouse", 
+                            "mlExperiments": "MLExperiment",
+                            "mlModels": "MLModel", 
+                            "notebooks": "Notebook", 
+                            "reports": "Report", 
+                            "semanticModels": "SemanticModel",
+                            "sparkJobDefinitions": "SparkJobDefinition", 
+                            "warehouses": "Warehouse"}
+            
+            if type in type_mapping.keys():
+                type = type_mapping[type]
+            while item is None and i < 12:
+                item = self.get_item_by_name(display_name, type)
+                if item is not None:
+                    return item
+                print("Item not found, waiting 5 seconds")
+                sleep(5)
+                i += 1
+
+            print("Item not found after 1 minute, returning None")
+            return None
+                
+        return self.get_item_specific(item_dict)
+         
 
     def get_item_by_name(self, item_name, item_type):
         """Get an item from a workspace by name"""
-        ws_items = self.list_items()
+        ws_items = self.list_items(with_properties=False)
         for item in ws_items:
             if item.display_name == item_name and item.type == item_type:
-                return item    
+                return self.get_item(item.id, item_type)    
 
-    def get_item(self, item_id = None, item_name = None, item_type = None):
-        # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}
-        """Get an item from a workspace"""
-        if item_id is None and item_name is not None and item_type is not None:
-            return self.get_item_by_name(item_name, item_type)
-        elif item_id is None:
-            raise Exception("item_id or the combination item_name + item_type is required")
-        
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/items/{item_id}"
+
+    def get_item_internal(self, url):
 
         for _ in range(10):
             response = requests.get(url=url, headers=self.auth.get_headers())
@@ -281,16 +340,69 @@ class Workspace:
             break
         
         item_dict = json.loads(response.text)
-        return Item.from_dict(item_dict, auth=self.auth)
+        return item_dict
+    
+    def get_item(self, item_id = None, item_name = None, item_type = None):
+        # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}
+        """Get an item from a workspace"""
+        if item_type:
+            if item_type.lower() == "datapipeline":
+                return self.get_data_pipeline(item_id, item_name)
+            if item_type.lower() == "eventstream":
+                return self.get_eventstream(item_id, item_name)
+            if item_type.lower() == "kqldatabase":
+                return self.get_kql_database(item_id, item_name)
+            if item_type.lower() == "kqlqueryset":
+                return self.get_kql_queryset(item_id, item_name)
+            if item_type.lower() == "lakehouse":
+                return self.get_lakehouse(item_id, item_name)
+            if item_type.lower() == "mlmodel":
+                return self.get_ml_model(item_id, item_name)
+            if item_type.lower() == "mlexperiment":
+                return self.get_ml_experiment(item_id, item_name)
+            if item_type.lower() == "notebook":
+                return self.get_notebook(item_id, item_name)
+            if item_type.lower() == "report":
+                return self.get_report(item_id, item_name)
+            if item_type.lower() == "semanticmodel":
+                return self.get_semantic_model(item_id, item_name)
+            if item_type.lower() == "sparkjobdefinition":
+                return self.get_spark_job_definition(item_id, item_name)
+            if item_type.lower() == "warehouse":
+                return self.get_warehouse(item_id, item_name)
+                
+        if item_id is None and item_name is not None and item_type is not None:
+            return self.get_item_by_name(item_name, item_type)
+        elif item_id is None:
+            raise Exception("item_id or the combination item_name + item_type is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/items/{item_id}"
+
+        item_dict = self.get_item_internal(url)
+
+        return self.get_item_specific(item_dict)
 
     def delete_item(self, item_id):
         """Delete an item from a workspace"""
         return self.get_item(item_id).delete()
   
 
-    def list_items(self, continuationToken = None):
+    def get_item_object_w_properties(self, item_list):
+
+        new_item_list = []
+        for item in item_list:
+            item_ = self.get_item_specific(item)
+            new_item_list.append(item_)
+        return new_item_list
+
+    def list_items(self, with_properties = False, continuationToken = None, type = None):
         """List items in a workspace"""
+
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/items"
+        
+        if type:
+            url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/{type}"
+        
 
         if continuationToken:
             url = f"{url}?continuationToken={continuationToken}"
@@ -309,10 +421,14 @@ class Workspace:
         
         resp_dict = json.loads(response.text)
         items = resp_dict["value"]
-        items = [Item.from_dict(item, auth=self.auth) for item in items]
+        if with_properties:
+            items = self.get_item_object_w_properties(items)
+        else:
+            items = [Item.from_dict(item, auth=self.auth) for item in items]
 
         if "continuationToken" in resp_dict:
-            item_list_next = self.list_items(continuationToken=resp_dict["continuationToken"])
+            item_list_next = self.list_items(with_properties=with_properties, 
+                                             continuationToken=resp_dict["continuationToken"])
             items.extend(item_list_next)
 
         return items
@@ -519,3 +635,441 @@ class Workspace:
         return self.get_item(item_id).load_table(table_name, path_type, relative_path,
                     file_extension, format_options,
                     mode, recursive, wait_for_completion)
+
+    def list_dashboards(self):
+        """List dashboards in a workspace"""
+        return self.list_items(type="dashboards")
+    
+    def list_datamarts(self):
+        """List datamarts in a workspace"""
+        return self.list_items(type="datamarts")
+    
+    def list_paginated_reports(self):
+        """List paginated reports in a workspace"""
+        return self.list_items(type="paginatedReports")
+
+    def list_sql_endpoints(self):
+        """List sql endpoints in a workspace"""
+        return self.list_items(type="sqlEndpoints")
+
+    def list_mirrored_warehouses(self):
+        """List mirrored warehouses in a workspace"""
+        return self.list_items(type="mirroredWarehouses")
+    
+    def list_data_pipelines(self, with_properties = False):
+        """List data pipelines in a workspace"""
+        return self.list_items(with_properties = with_properties, type="dataPipelines")
+    
+    def get_data_pipeline(self, data_pipeline_id = None, data_pipeline_name = None):
+        """Get a data pipeline from a workspace"""
+        if data_pipeline_id is None and data_pipeline_name is not None:
+            return self.get_item_by_name(data_pipeline_name, "DataPipeline")
+        elif data_pipeline_id is None:
+            raise Exception("data_pipeline_id or the data_pipeline_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/dataPipelines/{data_pipeline_id}"
+
+        item_dict = self.get_item_internal(url)
+        dp = DataPipeline.from_dict(item_dict, auth=self.auth)
+        dp.get_definition()
+        return dp
+    
+    def delete_data_pipeline(self, data_pipeline_id):
+        """Delete a data pipeline from a workspace"""
+        return self.get_item(item_id=data_pipeline_id).delete(type="dataPipelines")
+    
+    def update_data_pipeline(self, data_pipeline_id, display_name = None, description = None):
+        """Update a data pipeline in a workspace"""
+        return self.get_item(item_id=data_pipeline_id).update(display_name=display_name, description=description, type="dataPipelines")
+    
+    def list_eventstreams(self):
+        """List eventstreams in a workspace"""
+        return self.list_items(type="eventstreams")
+    
+    def create_eventstream(self, display_name, description = None):
+        """Create an eventstream in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "eventstreams",
+                                definition = None,
+                                description = description)
+    
+    def get_eventstream(self, eventstream_id = None, eventstream_name = None):
+        """Get an eventstream from a workspace"""
+        if eventstream_id is None and eventstream_name is not None:
+            return self.get_item_by_name(eventstream_name, "Eventstream")
+        elif eventstream_id is None:
+            raise Exception("eventstream_id or the eventstream_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/eventstreams/{eventstream_id}"
+
+        item_dict = self.get_item_internal(url)
+        return Eventstream.from_dict(item_dict, auth=self.auth)
+    
+    def delete_eventstream(self, eventstream_id):
+        """Delete an eventstream from a workspace"""
+        return self.get_item(item_id=eventstream_id).delete(type="eventstreams")
+    
+    def update_eventstream(self, eventstream_id, display_name = None, description = None):
+        """Update an eventstream in a workspace"""
+        return self.get_item(item_id=eventstream_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="eventstreams")
+    
+    # kqlDatabases
+
+    def list_kql_databases(self):
+        """List kql databases in a workspace"""
+        return self.list_items(type="kqlDatabases")
+    
+    def get_kql_database(self, kql_database_id = None, kql_database_name = None):
+        """Get a kql database from a workspace"""
+
+        if kql_database_id is None and kql_database_name is not None:
+            return self.get_item_by_name(kql_database_name, "KQLDatabase")
+        elif kql_database_id is None:
+            raise Exception("kql_database_id or the kql_database_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/kqlDatabases/{kql_database_id}"
+
+        item_dict = self.get_item_internal(url)
+        return KQLDatabase.from_dict(item_dict, auth=self.auth)
+    
+    def delete_kql_database(self, kql_database_id):
+        """Delete a kql database from a workspace"""
+        return self.get_item(item_id=kql_database_id).delete(type="kqlDatabases")
+    
+    def update_kql_database(self, kql_database_id, display_name = None, description = None):
+        """Update a kql database in a workspace"""
+        return self.get_item(item_id=kql_database_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="kqlDatabases")
+
+    # kqlQuerysets
+
+    def list_kql_querysets(self):
+        """List kql querysets in a workspace"""
+        return self.list_items(type="kqlQuerysets")
+
+    def get_kql_queryset(self, kql_queryset_id = None, kql_queryset_name = None):
+        """Get a kql queryset from a workspace"""
+
+        if kql_queryset_id is None and kql_queryset_name is not None:
+            return self.get_item_by_name(kql_queryset_name, "KQLQueryset")
+        elif kql_queryset_id is None:
+            raise Exception("kql_queryset_id or the kql_queryset_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/kqlQuerysets/{kql_queryset_id}"
+
+        item_dict = self.get_item_internal(url)
+        return KQLQueryset.from_dict(item_dict, auth=self.auth) 
+    
+    def delete_kql_queryset(self, kql_queryset_id):
+        """Delete a kql queryset from a workspace"""
+        return self.get_item(item_id=kql_queryset_id).delete(type="kqlQuerysets")
+    
+    def update_kql_queryset(self, kql_queryset_id, display_name = None, description = None):
+        """Update a kql queryset in a workspace"""
+        return self.get_item(item_id=kql_queryset_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="kqlQuerysets")
+
+
+    # lakehouses
+
+    def list_lakehouses(self, with_properties = False):
+        """List lakehouses in a workspace"""
+        return self.list_items(with_properties = with_properties, type="lakehouses")
+    
+    def create_lakehouse(self, display_name, description = None):
+        """Create a lakehouse in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "lakehouses",
+                                definition = None,
+                                description = description)
+    
+    def delete_lakehouse(self, lakehouse_id):
+        """Delete a lakehouse from a workspace"""
+        return self.get_item(item_id=lakehouse_id).delete(type="lakehouses")
+    
+    def update_lakehouse(self, lakehouse_id, display_name = None, description = None):
+        """Update a lakehouse in a workspace"""
+        return self.get_item(item_id=lakehouse_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="lakehouses")
+    
+    def get_lakehouse(self, lakehouse_id = None, lakehouse_name = None):
+        """Get a lakehouse from a workspace"""
+
+        if lakehouse_id is None and lakehouse_name is not None:
+            return self.get_item_by_name(lakehouse_name, "Lakehouse")
+        elif lakehouse_id is None:
+            raise Exception("lakehouse_id or the lakehouse_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/lakehouses/{lakehouse_id}"
+
+        item_dict = self.get_item_internal(url)
+        return Lakehouse.from_dict(item_dict, auth=self.auth)
+    
+    # mlExperiments
+
+    def list_ml_experiments(self):
+        """List ml experiments in a workspace"""
+        return self.list_items(type="mlExperiments")
+    
+    def create_ml_experiment(self, display_name, description = None):
+        """Create an ml experiment in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "mlExperiments",
+                                definition = None,
+                                description = description)
+    
+    def get_ml_experiment(self, ml_experiment_id = None, ml_experiment_name = None):
+        """Get an ml experiment from a workspace"""
+        if ml_experiment_id is None and ml_experiment_name is not None:
+            return self.get_item_by_name(ml_experiment_name, "MLExperiment")
+        elif ml_experiment_id is None:
+            raise Exception("ml_experiment_id or the ml_experiment_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/mlExperiments/{ml_experiment_id}"
+
+        item_dict = self.get_item_internal(url)
+        return MLExperiment.from_dict(item_dict, auth=self.auth)
+    
+    def delete_ml_experiment(self, ml_experiment_id):
+        """Delete an ml experiment from a workspace"""
+        return self.get_item(item_id=ml_experiment_id).delete(type="mlExperiments")
+    
+    def update_ml_experiment(self, ml_experiment_id, display_name = None, description = None):
+        """Update an ml experiment in a workspace"""
+        return self.get_item(item_id=ml_experiment_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="mlExperiments")
+    
+    # mlModels
+
+    def list_ml_models(self):
+        """List ml models in a workspace"""
+        return self.list_items(type="mlModels")
+
+    def create_ml_model(self, display_name, description = None):
+        """Create an ml model in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "mlModels",
+                                definition = None,
+                                description = description)
+    
+    def get_ml_model(self, ml_model_id = None, ml_model_name = None):
+        """Get an ml model from a workspace"""
+        if ml_model_id is None and ml_model_name is not None:
+            return self.get_item_by_name(ml_model_name, "MLModel")
+        elif ml_model_id is None:
+            raise Exception("ml_model_id or the ml_model_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/mlModels/{ml_model_id}"
+
+        item_dict = self.get_item_internal(url)
+        return MLModel.from_dict(item_dict, auth=self.auth)
+    
+    def delete_ml_model(self, ml_model_id):
+        """Delete an ml model from a workspace"""
+        return self.get_item(item_id=ml_model_id).delete(type="mlModels")
+    
+    def update_ml_model(self, ml_model_id, display_name = None, description = None):
+        """Update an ml model in a workspace"""
+        return self.get_item(item_id=ml_model_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="mlModels")
+    
+    # notebooks
+
+    def list_notebooks(self, with_properties = False):
+        """List notebooks in a workspace"""
+        return self.list_items(type="notebooks", with_properties = with_properties)
+    
+    def create_notebook(self, display_name, definition = None, description = None):
+        """Create a notebook in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "notebooks",
+                                definition = definition,
+                                description = description)
+    
+    def get_notebook(self, notebook_id = None, notebook_name = None):
+        """Get a notebook from a workspace"""
+        if notebook_id is None and notebook_name is not None:
+            return self.get_item_by_name(notebook_name, "Notebook")
+        elif notebook_id is None:
+            raise Exception("notebook_id or the notebook_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/notebooks/{notebook_id}"
+
+        item_dict = self.get_item_internal(url)
+        noteb =  Notebook.from_dict(item_dict, auth=self.auth)
+        noteb.get_definition()
+        return noteb
+    
+    def delete_notebook(self, notebook_id):
+        """Delete a notebook from a workspace"""
+        return self.get_item(item_id=notebook_id).delete(type="notebooks")
+    
+    def update_notebook(self, notebook_id, display_name = None, description = None):
+        """Update a notebook in a workspace"""
+        return self.get_item(item_id=notebook_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="notebooks")
+    
+    def update_notebook_definition(self, notebook_id, definition):
+        """Update the definition of a notebook in a workspace"""
+        return self.get_notebook(notebook_id=notebook_id).update_definition(definition=definition)
+    
+    # reports
+
+    def list_reports(self, with_properties = False):
+        """List reports in a workspace"""
+        return self.list_items(type="reports", with_properties = with_properties)
+    
+    def create_report(self, display_name, definition = None, description = None):
+        """Create a report in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "reports",
+                                definition = definition,
+                                description = description)
+    
+    def get_report(self, report_id = None, report_name = None):
+        """Get a report from a workspace"""
+        if report_id is None and report_name is not None:
+            return self.get_item_by_name(report_name, "Report")
+        elif report_id is None:
+            raise Exception("report_id or the report_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/reports/{report_id}"
+
+        item_dict = self.get_item_internal(url)
+        rep = Report.from_dict(item_dict, auth=self.auth)
+        rep.get_definition()
+        return rep
+    
+    def delete_report(self, report_id):
+        """Delete a report from a workspace"""
+        return self.get_item(item_id=report_id).delete(type="reports")
+    
+    def update_report_definition(self, report_id, definition):
+        """Update the definition of a report in a workspace"""
+        return self.get_report(report_id=report_id).update_definition(definition=definition)
+
+    # semanticModels
+
+    def list_semantic_models(self, with_properties = False):
+        """List semantic models in a workspace"""
+        return self.list_items(type="semanticModels", with_properties = with_properties)
+    
+    def create_semantic_model(self, display_name, definition = None, description = None):
+        """Create a semantic model in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "semanticModels",
+                                definition = definition,
+                                description = description)
+    
+    def get_semantic_model(self, semantic_model_id = None, semantic_model_name = None):
+        """Get a semantic model from a workspace"""
+        if semantic_model_id is None and semantic_model_name is not None:
+            return self.get_item_by_name(semantic_model_name, "SemanticModel")
+        elif semantic_model_id is None:
+            raise Exception("semantic_model_id or the semantic_model_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/semanticModels/{semantic_model_id}"
+
+        item_dict = self.get_item_internal(url)
+        semmodel = SemanticModel.from_dict(item_dict, auth=self.auth)
+        semmodel.get_definition()
+        return semmodel
+    
+    def delete_semantic_model(self, semantic_model_id):
+        """Delete a semantic model from a workspace"""
+        return self.get_item(item_id=semantic_model_id).delete(type="semanticModels")
+    
+    def update_semantic_model(self, semantic_model_id, display_name = None, description = None):
+        """Update a semantic model in a workspace"""
+        return self.get_item(item_id=semantic_model_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="semanticModels")
+    
+    def update_semantic_model_definition(self, semantic_model_id, definition):
+        """Update the definition of a semantic model in a workspace"""
+        return self.get_semantic_model(semantic_model_id=semantic_model_id).update_definition(definition=definition)
+    
+    # sparkJobDefinitions
+
+    def list_spark_job_definitions(self, with_properties = False):
+        """List spark job definitions in a workspace"""
+        return self.list_items(type="sparkJobDefinitions", with_properties = with_properties)
+    
+    def create_spark_job_definition(self, display_name, definition = None, description = None):
+        """Create a spark job definition in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "sparkJobDefinitions",
+                                definition = definition,
+                                description = description)
+    
+    def get_spark_job_definition(self, spark_job_definition_id = None, spark_job_definition_name = None):
+        """Get a spark job definition from a workspace"""
+        if spark_job_definition_id is None and spark_job_definition_name is not None:
+            return self.get_item_by_name(spark_job_definition_name, "SparkJobDefinition")
+        elif spark_job_definition_id is None:
+            raise Exception("spark_job_definition_id or the spark_job_definition_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/sparkjobdefinitions/{spark_job_definition_id}"
+
+        item_dict = self.get_item_internal(url)
+        sjd_obj =  SparkJobDefinition.from_dict(item_dict, auth=self.auth)
+        sjd_obj.get_definition()
+        return sjd_obj
+
+    def delete_spark_job_definition(self, spark_job_definition_id):
+        """Delete a spark job definition from a workspace"""
+        return self.get_item(item_id=spark_job_definition_id).delete(type="sparkJobDefinitions")
+    
+    def update_spark_job_definition(self, spark_job_definition_id, display_name = None, description = None):
+        """Update a spark job definition in a workspace"""
+        return self.get_spark_job_definition(spark_job_definition_id=spark_job_definition_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="sparkJobDefinitions")
+
+    def update_spark_job_definition_definition(self, spark_job_definition_id, definition):
+        """Update the definition of a spark job definition in a workspace"""
+        return self.get_spark_job_definition(spark_job_definition_id=spark_job_definition_id).update_definition(definition=definition)
+
+    # warehouses
+
+    def list_warehouses(self, with_properties = False):
+        """List warehouses in a workspace"""
+        return self.list_items(type="warehouses")
+    
+    def create_warehouse(self, display_name, description = None):
+        """Create a warehouse in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "warehouses",description = description)
+    
+    def get_warehouse(self, warehouse_id = None, warehouse_name = None):
+        """Get a warehouse from a workspace"""
+        if warehouse_id is None and warehouse_name is not None:
+            return self.get_item_by_name(warehouse_name, "Warehouse")
+        elif warehouse_id is None:
+            raise Exception("warehouse_id or the warehouse_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/warehouses/{warehouse_id}"
+
+        item_dict = self.get_item_internal(url)
+        return Warehouse.from_dict(item_dict, auth=self.auth)
+    
+    def delete_warehouse(self, warehouse_id):
+        """Delete a warehouse from a workspace"""
+        return self.get_item(item_id=warehouse_id).delete(type="warehouses")
+    
+    def update_warehouse(self, warehouse_id, display_name = None, description = None):
+        """Update a warehouse in a workspace"""
+        return self.get_item(item_id=warehouse_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="warehouses")
+    
+
+