msfabricpysdkcore 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

msfabricpysdkcore/coreapi.py

@@ -939,17 +939,21 @@ class FabricClientCore(FabricClient):
                     "environments",
                     "eventhouses",
                     "eventstreams",
+                    "GraphQLApis",
                     "kqlDatabases",
                     "kqlDashboards",
                     "kqlQuerysets",
                     "lakehouses",
                     "mirroredDatabases",
                     "mlExperiments", 
-                    "mlModels", 
-                    "notebooks", 
+                    "mlModels",
+                    "mountedDataFactories", 
+                    "notebooks",
+                    "reflexes", 
                     "reports", 
                     "semanticModels", 
-                    "sparkJobDefinitions", 
+                    "sparkJobDefinitions",
+                    "SQLDatabases",
                     "warehouses"]:
             
             if type == "kqlDatabases":
@@ -975,6 +979,7 @@ class FabricClientCore(FabricClient):
                             "environments": "Environment",
                             "eventhouses": "Eventhouse",
                             "eventstreams": "Eventstream",
+                            "GraphQLApis": "GraphQLApi",
                             "kqlDashboards": "KQLDashboard",
                             "kqlDatabases": "KQLDatabase",
                             "kqlQuerysets": "KQLQueryset",
@@ -982,10 +987,13 @@ class FabricClientCore(FabricClient):
                             "mirroredDatabases": "MirroredDatabase",
                             "mlExperiments": "MLExperiment",
                             "mlModels": "MLModel", 
-                            "notebooks": "Notebook", 
+                            "mountedDataFactories": "MountedDataFactory",
+                            "notebooks": "Notebook",
+                            "reflexes": "Reflex",
                             "reports": "Report", 
                             "semanticModels": "SemanticModel",
-                            "sparkJobDefinitions": "SparkJobDefinition", 
+                            "sparkJobDefinitions": "SparkJobDefinition",
+                            "SQLDatabases": "SQLDatabase",
                             "warehouses": "Warehouse"
                             }
             
@@ -1588,6 +1596,24 @@ class FabricClientCore(FabricClient):
             shortcut['itemId'] = item_id
         return [OneLakeShortcut.from_dict(shortcut, core_client=self) for shortcut in shortcuts]
     
+
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/onelake/resetShortcutCache
+    def reset_shortcut_cache(self, workspace_id, wait_for_completion = False):
+        """Reset the shortcut cache
+
+        Args:
+            workspace_id (str): The ID of the workspace
+
+        Returns:
+            int: The status code of the response
+        """
+
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/onelake/resetShortcutCache"
+        response = self.calling_routine(url=url, operation="POST", response_codes=[200, 202, 429], error_message="Error resetting shortcut cache",
+                                        return_format="response", wait_for_completion = wait_for_completion)
+
+        return response.status_code
+
     ### Workspaces
 
     def add_workspace_role_assignment(self, workspace_id, role, principal):
@@ -2243,8 +2269,23 @@ class FabricClientCore(FabricClient):
 
         item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
                                          error_message="Error getting eventhouse", return_format="json")
-        return Eventhouse.from_dict(item_dict, core_client=self)
+        ev = Eventhouse.from_dict(item_dict, core_client=self)
+        ev.get_definition()
+        return ev
     
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/eventhouses/{eventhouseId}/getDefinition
+
+    def get_eventhouse_definition(self, workspace_id, eventhouse_id, format = None):
+        """Get the definition of an eventhouse
+        Args:
+            workspace_id (str): The ID of the workspace
+            eventhouse_id (str): The ID of the eventhouse
+            format (str): The format of the definition
+        Returns:
+            dict: The eventhouse definition
+        """
+        return self.get_item_definition(workspace_id, eventhouse_id, type="eventhouses", format=format)
+
     def list_eventhouses(self, workspace_id, with_properties = False):
         """List eventhouses in a workspace
         Args:
@@ -2268,6 +2309,19 @@ class FabricClientCore(FabricClient):
         return self.update_item(workspace_id=workspace_id, item_id=eventhouse_id,
                                 display_name=display_name, description=description, type="eventhouses", return_item=return_item)
 
+    def update_eventhouse_definition(self, workspace_id, eventhouse_id, definition, update_metadata = None):
+        """Update the definition of an eventhouse
+        Args:
+            workspace_id (str): The ID of the workspace
+            eventhouse_id (str): The ID of the eventhouse
+            definition (dict): The definition of the eventhouse
+            update_metadata (bool): Whether to update the metadata
+        Returns:
+            dict: The updated eventhouse definition
+        """
+        return self.update_item_definition(workspace_id, eventhouse_id, type="eventhouses", definition=definition, update_metadata=update_metadata)
+
+
     # eventstreams
 
     def create_eventstream(self, workspace_id, display_name, description = None):
@@ -2309,8 +2363,24 @@ class FabricClientCore(FabricClient):
 
         item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
                                             error_message="Error getting eventstream", return_format="json")
-        return Eventstream.from_dict(item_dict, core_client=self)
+        es = Eventstream.from_dict(item_dict, core_client=self)
+        es.get_definition()
+        return es
     
+    def get_eventstream_definition(self, workspace_id, eventstream_id, format = None):
+        """Get the definition of an eventstream
+
+        Args:
+            workspace_id (str): The ID of the workspace
+            eventstream_id (str): The ID of the eventstream
+            format (str): The format of the definition
+        Returns:
+            dict: The eventstream definition
+        """
+
+        return self.get_item_definition(workspace_id, eventstream_id, type="eventstreams", format=format)
+
+
     def delete_eventstream(self, workspace_id, eventstream_id):
         """Delete an eventstream from a workspace
         Args:
@@ -2343,6 +2413,94 @@ class FabricClientCore(FabricClient):
         """
         return self.update_item(workspace_id, eventstream_id, display_name = display_name, description = description, 
                                 type= "eventstreams", return_item=return_item)
+    
+    def update_eventstream_definition(self, workspace_id, eventstream_id, definition, update_metadata = None):
+        """Update the definition of an eventstream
+        Args:
+            workspace_id (str): The ID of the workspace
+            eventstream_id (str): The ID of the eventstream
+            definition (dict): The definition of the eventstream
+            update_metadata (bool): Whether to update the metadata
+        Returns:
+            dict: The updated definition of the eventstream
+        """
+        return self.update_item_definition(workspace_id, eventstream_id, type="eventstreams", definition=definition, update_metadata=update_metadata)
+
+    # graphqlapis
+
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/GraphQLApis
+    def create_graphql_api(self, workspace_id, display_name, description = None):
+        """Create a graphql api in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the graphql api
+            description (str): The description of the graphql api
+        Returns:
+            dict: The created graphql api
+        """
+        return self.create_item(workspace_id = workspace_id,
+                                display_name = display_name,
+                                type = "GraphQLApis",
+                                description = description)
+    
+    def delete_graphql_api(self, workspace_id, graphql_api_id):
+        """Delete a graphql api from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            graphql_api_id (str): The ID of the graphql api
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, graphql_api_id, type="GraphQLApis")
+    
+    def get_graphql_api(self, workspace_id, graphql_api_id = None, graphql_api_name = None):
+        """Get a graphql api from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            graphql_api_id (str): The ID of the graphql api
+            graphql_api_name (str): The name of the graphql api
+        Returns:
+            dict: The graphql api
+        """
+        from msfabricpysdkcore.otheritems import GraphQLApi
+        if graphql_api_id is None and graphql_api_name is not None:
+            graphql_apis = self.list_graphql_apis(workspace_id)
+            graphql_apis = [ga for ga in graphql_apis if ga.display_name == graphql_api_name]
+            if len(graphql_apis) == 0:
+                raise Exception(f"Graphql api with name {graphql_api_name} not found")
+            graphql_api_id = graphql_apis[0].id
+        if graphql_api_id is None:
+            raise Exception("graphql_api_id or the graphql_api_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/GraphQLApis/{graphql_api_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                         error_message="Error getting graphql api", return_format="json")
+        graphql = GraphQLApi.from_dict(item_dict, core_client=self)
+        return graphql
+    
+    def list_graphql_apis(self, workspace_id, with_properties = False):
+        """List graphql apis in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of graphql apis
+        """
+        return self.list_items(workspace_id=workspace_id, type="GraphQLApis", with_properties=with_properties)
+
+    def update_graphql_api(self, workspace_id, graphql_api_id, display_name = None, description = None, return_item=False):
+        """Update a graphql api in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            graphql_api_id (str): The ID of the graphql api
+            display_name (str): The display name of the graphql api
+            description (str): The description of the graphql api
+        Returns:
+            dict: The updated graphql api
+        """
+        return self.update_item(workspace_id, graphql_api_id, display_name = display_name, description = description, 
+                                type= "GraphQLApis", return_item=return_item)
 
     # kqlDashboard
     def create_kql_dashboard(self, workspace_id, display_name, description = None):
@@ -2495,7 +2653,20 @@ class FabricClientCore(FabricClient):
 
         item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
                                          error_message="Error getting kql database", return_format="json")
-        return KQLDatabase.from_dict(item_dict, core_client=self)
+        kqldb = KQLDatabase.from_dict(item_dict, core_client=self)
+        kqldb.get_definition()
+        return kqldb
+    
+    def get_kql_database_definition(self, workspace_id, kql_database_id, format=None):
+        """Get the definition of a kql database
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_database_id (str): The ID of the kql database
+            format (str): The format of the definition
+        Returns:
+            dict: The definition of the kql database
+        """
+        return self.get_item_definition(workspace_id, kql_database_id, type="kqlDatabases", format=format)
 
     def list_kql_databases(self, workspace_id, with_properties = False):
         """List kql databases in a workspace
@@ -2519,6 +2690,19 @@ class FabricClientCore(FabricClient):
         return self.update_item(workspace_id, kql_database_id, display_name = display_name,
                                 description = description, type= "kqlDatabases", return_item=return_item)
 
+    def update_kql_database_definition(self, workspace_id, kql_database_id, definition, update_metadata = None):
+        """Update the definition of a kql database
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_database_id (str): The ID of the kql database
+            definition (dict): The definition of the kql database
+            update_metadata (bool): Whether to update the metadata
+        Returns:
+            dict: The updated definition of the kql database
+        """
+        return self.update_item_definition(workspace_id, kql_database_id,
+                                           type="kqlDatabases", definition=definition, update_metadata=update_metadata)
+
     # kqlQuerysets
 
     def create_kql_queryset(self, workspace_id, display_name, description = None, definition = None):
@@ -2959,6 +3143,7 @@ class FabricClientCore(FabricClient):
         return self.calling_routine(url, operation="POST", response_codes=[200, 429],
                                     error_message="Error stopping mirroring", return_format="response")
 
+
     # mlExperiments
 
     def create_ml_experiment(self, workspace_id, display_name, description = None):
@@ -3105,7 +3290,106 @@ class FabricClientCore(FabricClient):
         """
         return self.update_item(workspace_id, ml_model_id, display_name = display_name, description = description,
                                 type="mlModels", return_item=return_item)
+
+    # mounted data factory
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/mountedDataFactories
+
+    def create_mounted_data_factory(self, workspace_id, display_name, description = None, definition = None):
+        """Create a mounted data factory in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the mounted data factory
+            description (str): The description of the mounted data factory
+            definition (dict): The definition of the mounted data factory
+        Returns:
+            dict: The created mounted data factory
+        """
+        return self.create_item(workspace_id = workspace_id, display_name = display_name, type = "mountedDataFactories",
+                                description = description, definition = definition)
+    
+    def delete_mounted_data_factory(self, workspace_id, mounted_data_factory_id):
+        """Delete a mounted data factory from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, mounted_data_factory_id, type="mountedDataFactories")
+
+    def get_mounted_data_factory(self, workspace_id, mounted_data_factory_id = None, mounted_data_factory_name = None):
+        """Get a mounted data factory from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+            mounted_data_factory_name (str): The name of the mounted data factory
+        Returns:
+            MountedDataFactory: The mounted data factory object
+        """
+        from msfabricpysdkcore.otheritems import MountedDataFactory
+        if mounted_data_factory_id is None and mounted_data_factory_name is not None:
+            mounted_data_factories = self.list_mounted_data_factories(workspace_id)
+            mounted_data_factories = [mdf for mdf in mounted_data_factories if mdf.display_name == mounted_data_factory_name]
+            if len(mounted_data_factories) == 0:
+                raise Exception(f"Mounted data factory with name {mounted_data_factory_name} not found")
+            mounted_data_factory_id = mounted_data_factories[0].id
+        if mounted_data_factory_id is None:
+            raise Exception("mounted_data_factory_id or the mounted_data_factory_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/mountedDataFactories/{mounted_data_factory_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                         error_message="Error getting mounted data factory", return_format="json")
+        
+        mdf = MountedDataFactory.from_dict(item_dict, core_client=self)
+        mdf.get_definition()
+        return mdf
+    
+    def get_mounted_data_factory_definition(self, workspace_id, mounted_data_factory_id, format = None):
+        """Get the definition of a mounted data factory
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+            format (str): The format of the definition
+        Returns:
+            dict: The definition of the mounted data factory
+        """
+        return self.get_item_definition(workspace_id, mounted_data_factory_id, type="mountedDataFactories", format=format)
+
+    def list_mounted_data_factories(self, workspace_id, with_properties = False):
+        """List mounted data factories in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of mounted data factories
+        """
+        return self.list_items(workspace_id=workspace_id, type="mountedDataFactories", with_properties = with_properties)
     
+    def update_mounted_data_factory(self, workspace_id, mounted_data_factory_id, display_name = None, description = None, return_item=False):
+        """Update a mounted data factory in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+            display_name (str): The display name of the mounted data factory
+            description (str): The description of the mounted data factory
+        Returns:
+            dict: The updated mounted data factory
+        """
+        return self.update_item(workspace_id, mounted_data_factory_id, display_name = display_name, description = description,
+                                type="mountedDataFactories", return_item=return_item)
+
+    def update_mounted_data_factory_definition(self, workspace_id, mounted_data_factory_id, definition, update_metadata = None):
+        """Update the definition of a mounted data factory
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+            definition (dict): The definition of the mounted data factory
+        Returns:
+            dict: The updated definition of the mounted data factory
+        """
+        return self.update_item_definition(workspace_id, mounted_data_factory_id, definition, type="mountedDataFactories", update_metadata=update_metadata)
+
     # notebooks
 
     def create_notebook(self, workspace_id, display_name, definition = None, description = None):
@@ -3222,6 +3506,103 @@ class FabricClientCore(FabricClient):
         return self.update_item(workspace_id, paginated_report_id, display_name = display_name, description = description,
                                 type="paginatedReports", return_item=return_item)
 
+    # reflex
+
+    def create_reflex(self, workspace_id, display_name, description = None, definition = None):
+        """Create a reflex in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the reflex
+            description (str): The description of the reflex
+            definition (dict): The definition of the reflex
+        Returns:
+            dict: The created reflex
+        """
+        return self.create_item(workspace_id = workspace_id, display_name = display_name, type = "reflexes", description = description, definition = definition)
+
+    def delete_reflex(self, workspace_id, reflex_id):
+        """Delete a reflex from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, reflex_id, type="reflexes")
+    
+    def get_reflex(self, workspace_id, reflex_id = None, reflex_name = None):
+        """Get a reflex from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+            reflex_name (str): The name of the reflex
+        Returns:
+            Reflex: The reflex object
+        """
+        from msfabricpysdkcore.otheritems import Reflex
+        if reflex_id is None and reflex_name is not None:
+            reflexes = self.list_reflexes(workspace_id)
+            reflexes = [rf for rf in reflexes if rf.display_name == reflex_name]
+            if len(reflexes) == 0:
+                raise Exception(f"Reflex with name {reflex_name} not found")
+            reflex_id = reflexes[0].id
+        if reflex_id is None:
+            raise Exception("reflex_id or the reflex_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/reflexes/{reflex_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                         error_message="Error getting reflex", return_format="json")
+        
+        refl = Reflex.from_dict(item_dict, core_client=self)
+        refl.get_definition()
+        return refl
+    
+    def get_reflex_definition(self, workspace_id, reflex_id, format = None):
+        """Get the definition of a reflex
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+            format (str): The format of the definition
+        Returns:
+            dict: The definition of the reflex
+        """
+        return self.get_item_definition(workspace_id, reflex_id, type="reflexes", format=format)
+
+    def list_reflexes(self, workspace_id, with_properties = False):
+        """List reflexes in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of reflexes
+        """
+        return self.list_items(workspace_id = workspace_id, type = "reflexes", with_properties = with_properties)
+    
+    def update_reflex(self, workspace_id, reflex_id, display_name = None, description = None, return_item=False):
+        """Update a reflex in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+            display_name (str): The display name of the reflex
+            description (str): The description of the reflex
+        Returns:
+            dict: The updated reflex
+        """
+        return self.update_item(workspace_id, reflex_id, display_name = display_name, description = description,
+                                type="reflexes", return_item=return_item)
+    
+    def update_reflex_definition(self, workspace_id, reflex_id, definition, update_metadata = None):
+        """Update the definition of a reflex
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+            definition (dict): The definition of the reflex
+        Returns:
+            dict: The updated reflex
+        """
+        return self.update_item_definition(workspace_id, reflex_id, definition, type="reflexes", update_metadata=update_metadata)
+    
     # reports
 
     def create_report(self, workspace_id, display_name, definition = None, description = None):
@@ -3296,6 +3677,19 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id = workspace_id, type = "reports", with_properties = with_properties)
 
+    def update_report(self, workspace_id, report_id, display_name = None, description = None, return_item=False):
+        """Update a report in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            report_id (str): The ID of the report
+            display_name (str): The display name of the report
+            description (str): The description of the report
+        Returns:
+            dict: The updated report
+        """
+        return self.update_item(workspace_id, report_id, display_name = display_name, description = description,
+                                type="reports", return_item=return_item)
+
     def update_report_definition(self, workspace_id, report_id, definition):
         """Update the definition of a report
         Args:
@@ -3690,7 +4084,80 @@ class FabricClientCore(FabricClient):
                                           item_id = spark_job_definition_id,
                                           job_instance_id = job_instance_id)
 
+    # sql database
+
+    def create_sql_database(self, workspace_id, display_name, description = None, definition = None):
+        """Create a SQL database in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the SQL database
+            description (str): The description of the SQL database
+            definition (dict): The definition of the SQL database
+        Returns:
+            dict: The created SQL database
+        """
+        return self.create_item(workspace_id = workspace_id, display_name = display_name, type = "SQLDatabases", definition = definition, description = description)
     
+    def delete_sql_database(self, workspace_id, sql_database_id):
+        """Delete a SQL database from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            sql_database_id (str): The ID of the SQL database
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, sql_database_id, type="SQLDatabases")
+    
+    def get_sql_database(self, workspace_id, sql_database_id = None, sql_database_name = None):
+        """Get a SQL database from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            sql_database_id (str): The ID of the SQL database
+            sql_database_name (str): The name of the SQL database
+        Returns:
+            SQLDatabase: The SQL database object
+        """
+        from msfabricpysdkcore.otheritems import SQLDatabase
+        if sql_database_id is None and sql_database_name is not None:
+            sql_databases = self.list_sql_databases(workspace_id)
+            sql_databases = [sd for sd in sql_databases if sd.display_name == sql_database_name]
+            if len(sql_databases) == 0:
+                raise Exception(f"SQL database with name {sql_database_name} not found")
+            sql_database_id = sql_databases[0].id
+        elif sql_database_id is None:
+            raise Exception("sql_database_id or the sql_database_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/SQLDatabases/{sql_database_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                         error_message="Error getting SQL database", return_format="json")
+        
+        return SQLDatabase.from_dict(item_dict, core_client=self)
+    
+    def list_sql_databases(self, workspace_id, with_properties = False):
+        """List SQL databases in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of SQL databases
+        """
+        return self.list_items(workspace_id = workspace_id, type = "SQLDatabases", with_properties = with_properties)
+    
+    def update_sql_database(self, workspace_id, sql_database_id, display_name = None, description = None, return_item=False):
+        """Update a SQL database in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            sql_database_id (str): The ID of the SQL database
+            display_name (str): The display name of the SQL database
+            description (str): The description of the SQL database
+        Returns:
+            dict: The updated SQL database
+        """
+        return self.update_item(workspace_id, sql_database_id, display_name = display_name, description = description,
+                                type="SQLDatabases", return_item=return_item)
+    
+
     # warehouses
 
     def create_warehouse(self, workspace_id, display_name, description = None):

msfabricpysdkcore/item.py

@@ -45,9 +45,9 @@ class Item:
 
         return self.core_client.delete_item(self.workspace_id, self.id, type=type)
     
-    def get_definition(self, type = None, format = None):
+    def get_definition(self, type = None, format = None, **kwargs):
         """Get the definition of the item"""
-        resp_dict = self.core_client.get_item_definition(self.workspace_id, self.id, type=type, format=format)
+        resp_dict = self.core_client.get_item_definition(self.workspace_id, self.id, type=type, format=format, **kwargs)
 
         self.definition = resp_dict['definition']
         return resp_dict
@@ -69,10 +69,12 @@ class Item:
 
         return resp_dict
 
-    def update_definition(self, definition, type = None):
+    def update_definition(self, definition, type = None, **kwargs):
         """Update the item definition"""
+        if not type:
+            type = self.type
         response = self.core_client.update_item_definition(workspace_id=self.workspace_id, item_id=self.id, 
-                                                           definition=definition, type=type)
+                                                           definition=definition, type=type, **kwargs)
 
         self.definition = definition 
         return response