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

msfabricpysdkcore/auth.py

@@ -26,8 +26,9 @@ class FabricAuth():
 class FabricAuthClient(FabricAuth):
     """FabricAuthClient class to interact with Entra ID"""
 
-    def __init__(self):
-        print("Using Azure CLI for authentication")
+    def __init__(self, silent = False):
+        if not silent:
+            print("Using Azure CLI for authentication")
         self.auth = AzureCliCredential()
 
     def get_token(self):
@@ -38,8 +39,9 @@ class FabricAuthClient(FabricAuth):
 class FabricServicePrincipal(FabricAuth):
     """FabricServicePrincipal class to interact with Entra ID"""
 
-    def __init__(self, tenant_id, client_id, client_secret):
-        print("Using Service Principal for authentication")
+    def __init__(self, tenant_id, client_id, client_secret, silent = False):
+        if not silent:
+            print("Using Service Principal for authentication")
 
         self.tenant_id = tenant_id
         self.client_id = client_id
@@ -65,9 +67,10 @@ class FabricServicePrincipal(FabricAuth):
 class FabricSparkUtilsAuthentication(FabricAuth):
     """FabricSparkUtilsAuthentication class to interact with Entra ID"""
 
-    def __init__(self):
+    def __init__(self, silent = False):
         mssparkutils.credentials.getToken("pbi")
-        print("Using Synapse Spark Utils for authentication")
+        if not silent:
+            print("Using Synapse Spark Utils for authentication")
 
     def get_token(self):
         """Get token from Azure AD"""

msfabricpysdkcore/client.py

@@ -6,7 +6,7 @@ from msfabricpysdkcore.auth import FabricAuthClient, FabricServicePrincipal, Fab
 class FabricClient():
     """FabricClient class to interact with Fabric API"""
 
-    def __init__(self, tenant_id = None, client_id = None, client_secret = None) -> None:
+    def __init__(self, tenant_id = None, client_id = None, client_secret = None, silent=False) -> None:
         """Initialize FabricClient object"""
         self.tenant_id = tenant_id if tenant_id else os.getenv("FABRIC_TENANT_ID")
         self.client_id = client_id if client_id else os.getenv("FABRIC_CLIENT_ID")
@@ -16,10 +16,11 @@ class FabricClient():
 
         if self.client_id is None or self.client_secret is None or self.tenant_id is None:
             try:
-                self.auth = FabricSparkUtilsAuthentication()
+                self.auth = FabricSparkUtilsAuthentication(silent=silent)
             except:
-                self.auth = FabricAuthClient()
+                self.auth = FabricAuthClient(silent=silent)
         else:
             self.auth = FabricServicePrincipal(tenant_id = self.tenant_id,
                                                client_id = self.client_id, 
-                                               client_secret = self.client_secret)
+                                               client_secret = self.client_secret,
+                                               silent=silent)

msfabricpysdkcore/coreapi.py

@@ -11,9 +11,9 @@ from msfabricpysdkcore.workspace import Workspace
 class FabricClientCore(FabricClient):
     """FabricClientCore class to interact with Fabric Core APIs"""
 
-    def __init__(self, tenant_id = None, client_id = None, client_secret = None) -> None:
+    def __init__(self, tenant_id = None, client_id = None, client_secret = None, silent=False) -> None:
         """Initialize FabricClientCore object"""
-        super().__init__(tenant_id, client_id, client_secret)
+        super().__init__(tenant_id, client_id, client_secret, silent=silent)
 
 
     def list_workspaces(self, continuationToken = None):
@@ -81,10 +81,10 @@ class FabricClientCore(FabricClient):
             return self.get_workspace_by_name(name)
         raise ValueError("Either id or name must be provided")
         
-    def get_workspace_role_assignments(self, workspace_id):
+    def list_workspace_role_assignments(self, workspace_id):
         """Get role assignments for a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
-        return ws.get_role_assignments()
+        return ws.list_role_assignments()
     
     def create_workspace(self, display_name, capacity_id = None, description = None, exists_ok = True):
         """Create a workspace"""
@@ -129,20 +129,25 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.add_role_assignment(role, principal)
     
-    def delete_workspace_role_assignment(self, workspace_id, principal_id):
+    def delete_workspace_role_assignment(self, workspace_id, workspace_role_assignment_id):
         """Delete a role assignment from a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
-        return ws.delete_role_assignment(principal_id)
+        return ws.delete_role_assignment(workspace_role_assignment_id)
     
     def update_workspace(self, workspace_id, display_name = None, description = None):
         """Update a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
         return ws.update(display_name, description)
+
+    def get_workspace_role_assignment(self, workspace_id, workspace_role_assignment_id):
+        """Get a role assignment for a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_role_assignment(workspace_role_assignment_id)
     
-    def update_workspace_role_assignment(self, workspace_id, role, principal_id):
+    def update_workspace_role_assignment(self, workspace_id, role, workspace_role_assignment_id):
         """Update a role assignment for a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
-        return ws.update_role_assignment(role, principal_id)
+        return ws.update_role_assignment(role, workspace_role_assignment_id)
 
     def assign_to_capacity(self, workspace_id, capacity_id):
         """Assign a workspace to a capacity"""
@@ -153,6 +158,16 @@ class FabricClientCore(FabricClient):
         """Unassign a workspace from a capacity"""
         ws = self.get_workspace_by_id(workspace_id)
         return ws.unassign_from_capacity()
+    
+    def provision_identity(self, workspace_id):
+        """Provision an identity for a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.provision_identity()
+    
+    def deprovision_identity(self, workspace_id):
+        """Deprovision an identity for a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.deprovision_identity()
  
     def list_capacities(self, continuationToken = None):
         """List all capacities in the tenant"""
@@ -414,12 +429,20 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.get_environment(environment_id).get_staging_settings()
     
-    def update_staging_settings(self, workspace_id, environment_id, instance_pool, driver_cores, driver_memory, executor_cores, executor_memory,
-                                dynamic_executor_allocation, spark_properties, runtime_version):
-        """Update staging settings for an environment"""
-        ws = self.get_workspace_by_id(workspace_id)
-        return ws.get_environment(environment_id).update_staging_settings(instance_pool, driver_cores, driver_memory, executor_cores, executor_memory,
-                                dynamic_executor_allocation, spark_properties, runtime_version)
+    def update_staging_settings(self, workspace_id, environment_id,
+                                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):
+        
+        return self.get_environment(workspace_id, environment_id).update_staging_settings(driver_cores=driver_cores,
+                                                                            driver_memory=driver_memory,
+                                                                            dynamic_executor_allocation=dynamic_executor_allocation,
+                                                                            executor_cores=executor_cores,
+                                                                            executor_memory=executor_memory,
+                                                                            instance_pool=instance_pool,
+                                                                            runtime_version=runtime_version,
+                                                                            spark_properties=spark_properties)
+
     
     # environmentSparkLibraries
 
@@ -433,10 +456,10 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.get_environment(environment_id).get_staging_libraries()
     
-    def update_staging_library(self, workspace_id, environment_id):
+    def upload_staging_library(self, workspace_id, environment_id, file_path):
         """Update staging libraries for an environment"""
         ws = self.get_workspace_by_id(workspace_id)
-        return ws.get_environment(environment_id).update_staging_libraries()
+        return ws.get_environment(environment_id).upload_staging_library(file_path=file_path)
     
     def publish_environment(self, workspace_id, environment_id):
         """Publish an environment"""
@@ -453,6 +476,33 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.get_environment(environment_id).cancel_publish()
 
+    # eventhouses
+
+    def list_eventhouses(self, workspace_id):
+        """List eventhouses in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_eventhouses()
+    
+    def create_eventhouse(self, workspace_id, display_name, description = None):
+        """Create an eventhouse in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_eventhouse(display_name = display_name, description = description)
+    
+    def get_eventhouse(self, workspace_id, eventhouse_id = None, eventhouse_name = None):
+        """Get an eventhouse from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_eventhouse(eventhouse_id = eventhouse_id, eventhouse_name = eventhouse_name)
+    
+    def delete_eventhouse(self, workspace_id, eventhouse_id):
+        """Delete an eventhouse from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_eventhouse(eventhouse_id)
+    
+    def update_eventhouse(self, workspace_id, eventhouse_id, display_name = None, description = None):
+        """Update an eventhouse in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_eventhouse(eventhouse_id, display_name = display_name, description = description)
+
     # eventstreams
 
     def list_eventstreams(self, workspace_id):
@@ -486,6 +536,11 @@ class FabricClientCore(FabricClient):
         """List kql databases in a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
         return ws.list_kql_databases()
+    
+    def create_kql_database(self, workspace_id, creation_payload, display_name, description = None):
+        """Create a kql database in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_kql_database(creation_payload = creation_payload, display_name = display_name, description = description)
    
     def get_kql_database(self, workspace_id, kql_database_id = None, kql_database_name = None):
         """Get a kql database from a workspace"""
@@ -769,6 +824,11 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.update_spark_job_definition_definition(spark_job_definition_id, definition)
     
+    def run_on_demand_spark_job_definition(self, workspace_id, spark_job_definition_id, job_type = "sparkjob"):
+        """Run an on demand spark job definition"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.run_on_demand_spark_job_definition(spark_job_definition_id, job_type)
+    
     # warehouses
 
     def list_warehouses(self, workspace_id, with_properties = False):

msfabricpysdkcore/environment.py

@@ -8,23 +8,13 @@ from msfabricpysdkcore.long_running_operation import check_long_running_operatio
 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="", 
-                 sparkcompute = None, staging_sparkcompute = None, libraries = None, staging_libraries = None):
+    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)
 
-        self.sparkcompute = sparkcompute
-        self.staging_sparkcompute = staging_sparkcompute
-        self.libraries = libraries
-        self.staging_libraries = staging_libraries
-
     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', ""), 
-            sparkcompute=item_dict.get('sparkcompute', None),
-            staging_sparkcompute=item_dict.get('staging_sparkcompute', None),
-            libraries=item_dict.get('libraries', None),
-            staging_libraries=item_dict.get('staging_libraries', 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
@@ -39,14 +29,10 @@ class Environment(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 getting published settings: {response.text}")
+                raise Exception(f"Error getting published settings: {response.status_code}, {response.text}")
             break
 
         resp_json = json.loads(response.text)        
-        self.sparkcompute = resp_json
         return resp_json
     
     # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/sparkcompute
@@ -62,30 +48,38 @@ class Environment(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 getting staging settings: {response.text}")
+                raise Exception(f"Error getting staging settings: {response.status_code}, {response.text}")
             break
 
         resp_json = json.loads(response.text)        
-        self.staging_sparkcompute = resp_json
         return resp_json
 
-    def update_staging_settings(self, instance_pool, driver_cores, driver_memory, executor_cores, executor_memory,
-                                dynamic_executor_allocation, spark_properties, runtime_version):
+
+    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 = {
-            "instancePool": instance_pool,
-            "driverCores": driver_cores,
-            "driverMemory": driver_memory,
-            "executorCores": executor_cores,
-            "executorMemory": executor_memory,
-            "dynamicExecutorAllocation": dynamic_executor_allocation,
-            "sparkProperties": spark_properties,
-            "runtimeVersion": runtime_version
-        }
+        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:
@@ -93,14 +87,10 @@ class Environment(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 updating staging settings: {response.text}")
+                raise Exception(f"Error updating staging settings: {response.status_code}, {response.text}")
             break
 
-        self.staging_sparkcompute = body
-        return body
+        return json.loads(response.text)
 
 #  GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/libraries
 
@@ -115,14 +105,10 @@ class Environment(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 getting published libraries: {response.text}")
+                raise Exception(f"Error getting published libraries: {response.status_code}, {response.text}")
             break
 
         resp_json = json.loads(response.text)
-        self.libraries = resp_json
         return resp_json
     
 # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries
@@ -138,19 +124,29 @@ class Environment(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 getting staging libraries: {response.text}")
+                raise Exception(f"Error getting staging libraries: {response.status_code}, {response.text}")
             break
 
         resp_json = json.loads(response.text)
-        self.staging_libraries = resp_json
         return resp_json
     
 
-    def update_staging_libraries(self):
-        raise NotImplementedError("This method is not implemented yet because the REST API is not complete")
+    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}
 
@@ -165,10 +161,7 @@ class Environment(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 staging libraries: {response.text}")
+                raise Exception(f"Error deleting staging libraries: {response.status_code}, {response.text}")
             break
 
         return response.text
@@ -189,10 +182,7 @@ class Environment(Item):
                 publish_info = check_long_running_operation(response.headers, self.auth)
                 return publish_info
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error publishing staging: {response.text}")
+                raise Exception(f"Error publishing staging: {response.status_code}, {response.text}")
             break
 
         resp_dict = json.loads(response.text)
@@ -212,10 +202,7 @@ class Environment(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 canceling publishing: {response.text}")
+                raise Exception(f"Error canceling publishing: {response.status_code}, {response.text}")
             break
 
         resp_dict = json.loads(response.text)

msfabricpysdkcore/item.py

@@ -58,10 +58,7 @@ 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

msfabricpysdkcore/long_running_operation.py

@@ -1,6 +1,6 @@
 import json 
 import requests
-from time import sleep
+from time import sleep, time
 
 class LongRunningOperation:
     """Class to represent a workspace in Microsoft Fabric"""
@@ -49,12 +49,17 @@ class LongRunningOperation:
     def wait_for_completion(self):
         """Wait for the operation to complete"""
         max_iter = 20
+        start_time = time()
         while self.state not in ('Succeeded', 'Failed'):
             self.state = self.get_operation_state()["status"]
+            duration = int(time() - start_time)
+            if duration > 60:
+                
+                if self.state == "Running":
+                    print(f"Operation did not complete after {duration} seconds")
+                    return "Running"
+                raise Exception(f"Operation did not complete after {duration} seconds")
             sleep(3)
-            if max_iter == 0:
-                raise Exception("Operation did not complete after 60 seconds")
-            max_iter -= 1
         return self.state
     
 

msfabricpysdkcore/otheritems.py

@@ -2,6 +2,39 @@ import json
 from time import sleep
 import requests
 from msfabricpysdkcore.item import Item
+from msfabricpysdkcore.long_running_operation import check_long_running_operation
+
+
+class Eventhouse(Item):
+    """Class to represent a eventhouse in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, description=""):
+        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"""
@@ -20,6 +53,34 @@ class SparkJobDefinition(Item):
     def update_definition(self, definition):
         return super().update_definition(definition=definition, type="sparkJobDefinitions")
     
+    def run_on_demand_spark_job_definition(self, job_type = "sparkjob"):
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/sparkJobDefinitions/{sparkJobDefinitionId}/jobs/instances?jobType={jobType}
+        """Method to run a spark job definition on demand"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/sparkJobDefinitions/{self.id}/jobs/instances?jobType={job_type}"
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers())
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code == 202:
+                location = response.headers['Location']
+                job_instance_id = location.split('/')[-1]
+                
+                from msfabricpysdkcore import FabricClientCore
+                fc = FabricClientCore(silent=True)
+                fc.auth = self.auth
+                return fc.get_item_job_instance(workspace_id = self.workspace_id,
+                                                item_id = self.id,
+                                                job_instance_id = job_instance_id)
+            if response.status_code not in (200, 201, 202, 429):
+                raise Exception(f"Error running on demand spark job definition: {response.status_code}, {response.text}")
+            break
+        
+        return response
+
+
 class Warehouse(Item):
     """Class to represent a warehouse in Microsoft Fabric"""
      

msfabricpysdkcore/tests/test_datapipelines.py

@@ -0,0 +1,48 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+
+    def test_data_pipelines(self):
+
+        fc = self.fc
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        
+        dps = fc.list_data_pipelines(workspace_id)
+        dp_names = [dp.display_name for dp in dps]
+        self.assertGreater(len(dps), 0)
+        self.assertIn("pipeline1", dp_names)
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_name="pipeline1")
+        self.assertIsNotNone(dp.id)
+        self.assertIsNotNone(dp.definition)
+        self.assertEqual(dp.display_name, "pipeline1")
+
+        dp_new = fc.create_data_pipeline(workspace_id, display_name="pipeline_new", description="asda")
+        dp_new.update_definition(dp.definition)
+        
+        self.assertEqual(dp_new.display_name, "pipeline_new")
+
+        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline2")
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
+        self.assertEqual(dp.display_name, "pipeline2")
+        self.assertEqual(dp.id, dp2.id)
+
+        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline1")
+
+        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
+        self.assertEqual(dp.display_name, "pipeline1")
+        self.assertEqual(dp.id, dp2.id)
+        status_code = fc.delete_data_pipeline(workspace_id, dp_new.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_deployment_pipeline.py

@@ -53,8 +53,7 @@ class TestFabricClientCore(unittest.TestCase):
                 "itemType": item["itemType"]}
         items = [item]
 
-        
-        response = pipe.deploy(source_stage_id=dev_stage.id,target_stage_id=prod_stage.id, items=items)
+        response = fc.deploy_stage_content(deployment_pipeline_id=pipe_id, source_stage_id=dev_stage.id,target_stage_id=prod_stage.id, items=items)
 
         self.assertEqual(response["status"], "Succeeded")