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

msfabricpysdkcore/coreapi.py

@@ -203,10 +203,10 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.delete_item(item_id)
 
-    def list_items(self, workspace_id):
+    def list_items(self, workspace_id, with_properties = False):
         """List items in a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
-        return ws.list_items()
+        return ws.list_items(with_properties=with_properties)
     
     def get_item_definition(self, workspace_id, item_id):
         """Get the definition of an item"""
@@ -322,3 +322,349 @@ class FabricClientCore(FabricClient):
         return ws.load_table(item_id, table_name, path_type, relative_path,
                     file_extension, format_options,
                     mode, recursive, wait_for_completion)
+
+    # list things
+
+    def list_dashboards(self, workspace_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_dashboards()
+    
+    def list_datamarts(self, workspace_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_datamarts()
+    
+    def list_paginated_reports(self, workspace_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_paginated_reports()
+    
+    def list_sql_endpoints(self, workspace_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_sql_endpoints()
+    
+    def list_mirrored_warehouses(self, workspace_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_mirrored_warehouses()
+    
+    # dataPipelines
+
+    def list_data_pipelines(self, workspace_id, with_properties = False):
+        """List data pipelines in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_data_pipelines(with_properties = with_properties)
+
+    def get_data_pipeline(self, workspace_id, data_pipeline_id = None, data_pipeline_name = None):
+        """Get a data pipeline from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_data_pipeline(data_pipeline_id = data_pipeline_id, data_pipeline_name = data_pipeline_name)
+    
+    def delete_data_pipeline(self, workspace_id, data_pipeline_id):
+        """Delete a data pipeline from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_data_pipeline(data_pipeline_id)
+
+    def update_data_pipeline(self, workspace_id, data_pipeline_id, display_name = None, description = None):
+        """Update a data pipeline in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_data_pipeline(data_pipeline_id).update(display_name=display_name, description=description)
+
+    # eventstreams
+
+    def list_eventstreams(self, workspace_id):
+        """List eventstreams in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_eventstreams()
+
+    def create_eventstream(self, workspace_id, display_name, description = None):
+        """Create an eventstream in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_eventstream(display_name = display_name, description = description)
+    
+    def get_eventstream(self, workspace_id, eventstream_id = None, eventstream_name = None):
+        """Get an eventstream from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_eventstream(eventstream_id = eventstream_id, eventstream_name = eventstream_name)
+
+    def delete_eventstream(self, workspace_id, eventstream_id):
+        """Delete an eventstream from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_eventstream(eventstream_id)
+    
+    def update_eventstream(self, workspace_id, eventstream_id, display_name = None, description = None):
+        """Update an eventstream in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_eventstream(eventstream_id, display_name = display_name, description = description)
+
+    # kqlDatabases
+
+    def list_kql_databases(self, workspace_id):
+        """List kql databases in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_kql_databases()
+   
+    def get_kql_database(self, workspace_id, kql_database_id = None, kql_database_name = None):
+        """Get a kql database from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_kql_database(kql_database_id = kql_database_id, kql_database_name = kql_database_name)
+
+    def delete_kql_database(self, workspace_id, kql_database_id):
+        """Delete a kql database from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_kql_database(kql_database_id)
+    
+    def update_kql_database(self, workspace_id, kql_database_id, display_name = None, description = None):
+        """Update a kql database in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_kql_database(kql_database_id, display_name = display_name, description = description)
+
+    # kqlQuerysets
+
+    def list_kql_querysets(self, workspace_id):
+        """List kql querysets in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_kql_querysets()
+    
+    def get_kql_queryset(self, workspace_id, kql_queryset_id = None, kql_queryset_name = None):
+        """Get a kql queryset from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_kql_queryset(kql_queryset_id = kql_queryset_id, kql_queryset_name = kql_queryset_name)
+
+    def update_kql_queryset(self, workspace_id, kql_queryset_id, display_name = None, description = None):
+        """Update a kql queryset in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_kql_queryset(kql_queryset_id, display_name = display_name, description = description)
+    
+    def delete_kql_queryset(self, workspace_id, kql_queryset_id):
+        """Delete a kql queryset from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_kql_queryset(kql_queryset_id)
+
+    # lakehouses
+
+    def list_lakehouses(self, workspace_id):
+        """List lakehouses in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_lakehouses()
+    
+    def create_lakehouse(self, workspace_id, display_name, description = None):
+        """Create a lakehouse in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_lakehouse(display_name = display_name, description = description)
+    
+    def delete_lakehouse(self, workspace_id, lakehouse_id):
+        """Delete a lakehouse from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_lakehouse(lakehouse_id)
+    
+    def update_lakehouse(self, workspace_id, lakehouse_id, display_name = None, description = None):
+        """Update a lakehouse in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_lakehouse(lakehouse_id, display_name = display_name, description = description)
+    
+    def get_lakehouse(self, workspace_id, lakehouse_id = None, lakehouse_name = None):
+        """Get a lakehouse from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_lakehouse(lakehouse_id = lakehouse_id, lakehouse_name = lakehouse_name)
+
+    # mlExperiments
+
+    def list_ml_experiments(self, workspace_id):
+        """List ml experiments in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_ml_experiments()
+    
+    def create_ml_experiment(self, workspace_id, display_name, description = None):
+        """Create an ml experiment in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_ml_experiment(display_name = display_name, description = description)
+    
+    def get_ml_experiment(self, workspace_id, ml_experiment_id = None, ml_experiment_name = None):
+        """Get an ml experiment from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_ml_experiment(ml_experiment_id = ml_experiment_id, ml_experiment_name = ml_experiment_name)
+    
+    def delete_ml_experiment(self, workspace_id, ml_experiment_id):
+        """Delete an ml experiment from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_ml_experiment(ml_experiment_id)
+    
+    def update_ml_experiment(self, workspace_id, ml_experiment_id, display_name = None, description = None):
+        """Update an ml experiment in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_ml_experiment(ml_experiment_id, display_name = display_name, description = description)
+  
+    # mlModels
+
+    def list_ml_models(self, workspace_id):
+        """List ml models in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_ml_models()
+    
+    def create_ml_model(self, workspace_id, display_name, description = None):
+        """Create an ml model in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_ml_model(display_name = display_name, description = description)
+    
+    def get_ml_model(self, workspace_id, ml_model_id = None, ml_model_name = None):
+        """Get an ml model from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_ml_model(ml_model_id = ml_model_id, ml_model_name = ml_model_name)
+    
+    def delete_ml_model(self, workspace_id, ml_model_id):
+        """Delete an ml model from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_ml_model(ml_model_id)
+    
+    def update_ml_model(self, workspace_id, ml_model_id, display_name = None, description = None):
+        """Update an ml model in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_ml_model(ml_model_id, display_name = display_name, description = description)
+    
+    # notebooks
+
+    def list_notebooks(self, workspace_id):
+        """List notebooks in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_notebooks()
+    
+    def create_notebook(self, workspace_id, display_name, definition = None, description = None):
+        """Create a notebook in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_notebook(display_name = display_name, definition = definition, description = description)
+    
+    def get_notebook(self, workspace_id, notebook_id = None, notebook_name = None):
+        """Get a notebook from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_notebook(notebook_id = notebook_id, notebook_name = notebook_name)
+    
+    def delete_notebook(self, workspace_id, notebook_id):
+        """Delete a notebook from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_notebook(notebook_id)
+    
+    def update_notebook(self, workspace_id, notebook_id, display_name = None, description = None):
+        """Update a notebook in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_notebook(notebook_id, display_name = display_name, description = description)
+    
+    def update_notebook_definition(self, workspace_id, notebook_id, definition):
+        """Update the definition of a notebook"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_notebook_definition(notebook_id, definition)
+    
+    # reports
+
+    def list_reports(self, workspace_id, with_properties = False):
+        """List reports in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_reports(with_properties = with_properties)
+
+    def create_report(self, workspace_id, display_name, definition = None, description = None):
+        """Create a report in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_report(display_name = display_name, definition = definition, description = description)
+    
+    def get_report(self, workspace_id, report_id = None, report_name = None):
+        """Get a report from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_report(report_id = report_id, report_name = report_name)
+    
+    def delete_report(self, workspace_id, report_id):
+        """Delete a report from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_report(report_id)
+    
+    def update_report_definition(self, workspace_id, report_id, definition):
+        """Update the definition of a report"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_report_definition(report_id, definition)
+
+    # semanticModels
+
+    def list_semantic_models(self, workspace_id, with_properties = False):
+        """List semantic models in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_semantic_models(with_properties = with_properties)
+    
+    def create_semantic_model(self, workspace_id, display_name, definition = None, description = None):
+        """Create a semantic model in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_semantic_model(display_name = display_name, definition = definition, description = description)
+    
+    def get_semantic_model(self, workspace_id, semantic_model_id = None, semantic_model_name = None):
+        """Get a semantic model from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_semantic_model(semantic_model_id = semantic_model_id, semantic_model_name = semantic_model_name)
+    
+    def delete_semantic_model(self, workspace_id, semantic_model_id):
+        """Delete a semantic model from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_semantic_model(semantic_model_id)
+    
+    def update_semantic_model(self, workspace_id, semantic_model_id, display_name = None, description = None):
+        """Update a semantic model in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_semantic_model(semantic_model_id, display_name = display_name, description = description)
+    
+    def update_semantic_model_definition(self, workspace_id, semantic_model_id, definition):
+        """Update the definition of a semantic model"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_semantic_model_definition(semantic_model_id, definition)
+   
+    # sparkJobDefinitions
+
+    def list_spark_job_definitions(self, workspace_id, with_properties = False):
+        """List spark job definitions in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_spark_job_definitions(with_properties = with_properties)
+    
+    def create_spark_job_definition(self, workspace_id, display_name, definition = None, description = None):
+        """Create a spark job definition in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_spark_job_definition(display_name = display_name, definition = definition, description = description)
+    
+    def get_spark_job_definition(self, workspace_id, spark_job_definition_id = None, spark_job_definition_name = None):
+        """Get a spark job definition from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_spark_job_definition(spark_job_definition_id = spark_job_definition_id, spark_job_definition_name = spark_job_definition_name)
+    
+    def delete_spark_job_definition(self, workspace_id, spark_job_definition_id):
+        """Delete a spark job definition from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_spark_job_definition(spark_job_definition_id)
+    
+    def update_spark_job_definition(self, workspace_id, spark_job_definition_id, display_name = None, description = None):
+        """Update a spark job definition in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_spark_job_definition(spark_job_definition_id, display_name = display_name, description = description)
+    
+    def update_spark_job_definition_definition(self, workspace_id, spark_job_definition_id, definition):
+        """Update the definition of a spark job definition"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_spark_job_definition_definition(spark_job_definition_id, definition)
+    
+    # warehouses
+
+    def list_warehouses(self, workspace_id, with_properties = False):
+        """List warehouses in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_warehouses(with_properties = with_properties)
+
+    def create_warehouse(self, workspace_id, display_name, description = None):
+        """Create a warehouse in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_warehouse(display_name = display_name, description = description)
+    
+    def get_warehouse(self, workspace_id, warehouse_id = None, warehouse_name = None):
+        """Get a warehouse from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_warehouse(warehouse_id = warehouse_id, warehouse_name = warehouse_name)
+    
+    def delete_warehouse(self, workspace_id, warehouse_id):
+        """Delete a warehouse from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_warehouse(warehouse_id)
+    
+    def update_warehouse(self, workspace_id, warehouse_id, display_name = None, description = None):
+        """Update a warehouse in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_warehouse(warehouse_id, display_name = display_name, description = description)

msfabricpysdkcore/item.py

@@ -50,9 +50,12 @@ class Item:
                     properties=item_dict.get('properties', None),
                     definition=item_dict.get('definition', None), description=item_dict.get('description', ""), auth=auth)
 
-    def delete(self):
+    def delete(self, type = None):
         """Delete the workspace item"""
+
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}"
+        if type:
+            url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/{type}/{self.id}"
         for _ in range(10):
             response = requests.delete(url=url, headers=self.auth.get_headers())
             if response.status_code == 429:
@@ -80,7 +83,9 @@ class Item:
                 sleep(10)
                 continue
             if response.status_code == 202:
-                check_long_running_operation( response.headers, self.auth)
+                operation_result = check_long_running_operation( response.headers, self.auth)
+                self.definition = operation_result['definition']
+                return operation_result
                 
             if response.status_code not in (200, 202, 429):
                 print(response.status_code)
@@ -88,20 +93,21 @@ class Item:
                 raise Exception(f"Error getting item definition: {response.text}")
             break
         
-        print(response.text)
-        print(response.status_code)
-        return json.loads(response.text)
+        resp_dict = json.loads(response.text)
+        self.definition = resp_dict['definition']
+        return resp_dict
     
-    def update(self, display_name = None, description = None):
+    def update(self, display_name = None, description = None, type = None):
         """Update the item"""
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/items/{self.id}"
+        if type:
+            url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/{type}/{self.id}"
 
         payload = dict()
         if display_name:
             payload['displayName'] = display_name
         if description:
             payload['description'] = description
-
         for _ in range(10):
             response = requests.patch(url=url, headers=self.auth.get_headers(), json=payload)
             if response.status_code == 429:

msfabricpysdkcore/job_instance.py

@@ -1,7 +1,6 @@
 import json 
 import requests
 from time import sleep
-from msfabricpysdkcore.long_running_operation import check_long_running_operation
 
 class JobInstance:
     """Class to represent a job instance in Microsoft Fabric"""

msfabricpysdkcore/lakehouse.py

@@ -2,7 +2,6 @@ import json
 import requests
 from time import sleep
 
-from msfabricpysdkcore.long_running_operation import check_long_running_operation
 from msfabricpysdkcore.item import Item
 
 class Lakehouse(Item):

msfabricpysdkcore/long_running_operation.py

@@ -22,13 +22,14 @@ class LongRunningOperation:
                 print("Too many requests, waiting 10 seconds")
                 sleep(10)
                 continue
+            if response.status_code == 400:
+                return None
             if response.status_code not in (200, 429):
                 print(response.status_code)
                 print(response.text)
                 raise Exception(f"Error getting operation results: {response.text}")
             break
 
-        print(json.loads(response.text))
         return json.loads(response.text)
     
     def get_operation_state(self):
@@ -47,7 +48,6 @@ class LongRunningOperation:
                 raise Exception(f"Error getting operation state: {response.text}")
             break
 
-        print(json.loads(response.text))
         return json.loads(response.text)    
     
     def wait_for_completion(self):
@@ -72,10 +72,7 @@ def check_long_running_operation(headers, auth):
     if not operation_id:
         print("Operation initiated, no operation id found")
         return None
-    else:
-        print("Operation initiated, waiting for completion")
-        lro = LongRunningOperation(operation_id=operation_id, auth=auth)
-        lro.wait_for_completion()
-        print("Operation completed")
-    lro = LongRunningOperation(operation_id, auth)
-    return lro.wait_for_completion()
+    lro = LongRunningOperation(operation_id=operation_id, auth=auth)
+    lro.wait_for_completion()
+    
+    return lro.get_operation_results()

msfabricpysdkcore/otheritems.py

@@ -0,0 +1,72 @@
+from time import sleep
+
+from msfabricpysdkcore.item import Item
+
+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)
+
+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)
+
+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)
+
+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)
+
+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)
+
+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)
+
+class MLModel(Item):
+    """Class to represent a ml model in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+
+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)
+
+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)
+
+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)
+
+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 run_on_demand_item_job(self, execution_data=None):
+        return super().run_on_demand_item_job(job_type = "Pipeline", execution_data=execution_data)