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

msfabricpysdkcore/coreapi.py

@@ -4,14 +4,16 @@ from time import sleep
 
 from msfabricpysdkcore.capacity import Capacity
 from msfabricpysdkcore.client import FabricClient
+from msfabricpysdkcore.deployment_pipeline import DeploymentPipeline
+from msfabricpysdkcore.long_running_operation import LongRunningOperation
 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):
@@ -311,17 +313,18 @@ class FabricClientCore(FabricClient):
                 return cap
         raise ValueError("No capacity found") 
     
-    def list_tables(self, workspace_id, item_id):
-        ws = self.get_workspace_by_id(workspace_id)
-        return ws.list_tables(item_id=item_id)
-    
-    def load_table(self, workspace_id, item_id, table_name, path_type, relative_path,
-                    file_extension = None, format_options = None,
-                    mode = None, recursive = None, wait_for_completion = True):
-        ws = self.get_workspace_by_id(workspace_id)
-        return ws.load_table(item_id, table_name, path_type, relative_path,
-                    file_extension, format_options,
-                    mode, recursive, wait_for_completion)
+
+    # long running operations
+
+    def get_operation_results(self, operation_id):
+        """Get the results of an operation"""
+        lro = LongRunningOperation(operation_id=operation_id, auth=self.auth)
+        return lro.get_operation_results()
+
+    def get_operation_state(self, operation_id):
+        """Get the state of an operation"""
+        lro = LongRunningOperation(operation_id=operation_id, auth=self.auth)
+        return lro.get_operation_state()
 
     # list things
 
@@ -347,6 +350,11 @@ class FabricClientCore(FabricClient):
     
     # dataPipelines
 
+    def create_data_pipeline(self, workspace_id, display_name, description = None):
+        """Create a data pipeline in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_data_pipeline(display_name = display_name, description = description)
+
     def list_data_pipelines(self, workspace_id, with_properties = False):
         """List data pipelines in a workspace"""
         ws = self.get_workspace_by_id(workspace_id)
@@ -367,6 +375,119 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.get_data_pipeline(data_pipeline_id).update(display_name=display_name, description=description)
 
+    # environments
+
+    def list_environments(self, workspace_id, with_properties = False):
+        """List environments in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_environments(with_properties = with_properties)
+    
+    def create_environment(self, workspace_id, display_name, description = None):
+        """Create an environment in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_environment(display_name = display_name, description = description)
+    
+    def get_environment(self, workspace_id, environment_id = None, environment_name = None):
+        """Get an environment from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_environment(environment_id = environment_id, environment_name = environment_name)
+    
+    def delete_environment(self, workspace_id, environment_id):
+        """Delete an environment from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_environment(environment_id)
+    
+    def update_environment(self, workspace_id, environment_id, display_name = None, description = None):
+        """Update an environment in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_environment(environment_id, display_name = display_name, description = description)
+    
+    # environmentSparkCompute
+
+    def get_published_settings(self, workspace_id, environment_id):
+        """Get published settings for an environment"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_environment(environment_id).get_published_settings()
+    
+    def get_staging_settings(self, workspace_id, environment_id):
+        """Get staging settings for an environment"""
+        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,
+                                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
+
+    def get_published_libraries(self, workspace_id, environment_id):
+        """Get published libraries for an environment"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_environment(environment_id).get_published_libraries()
+    
+    def get_staging_libraries(self, workspace_id, environment_id):
+        """Get staging libraries for an environment"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_environment(environment_id).get_staging_libraries()
+    
+    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).upload_staging_library(file_path=file_path)
+    
+    def publish_environment(self, workspace_id, environment_id):
+        """Publish an environment"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_environment(environment_id).publish_environment()
+    
+    def delete_staging_library(self, workspace_id, environment_id, library_to_delete):
+        """Delete a staging library from an environment"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_environment(environment_id).delete_staging_library(library_to_delete)
+    
+    def cancel_publish(self, workspace_id, environment_id):
+        """Cancel publishing an environment"""
+        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):
@@ -400,6 +521,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"""
@@ -465,6 +591,27 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.get_lakehouse(lakehouse_id = lakehouse_id, lakehouse_name = lakehouse_name)
 
+    def list_tables(self, workspace_id, lakehouse_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_tables(lakehouse_id=lakehouse_id)
+    
+    def load_table(self, workspace_id, lakehouse_id, table_name, path_type, relative_path,
+                    file_extension = None, format_options = None,
+                    mode = None, recursive = None, wait_for_completion = True):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.load_table(lakehouse_id, table_name, path_type, relative_path,
+                    file_extension, format_options,
+                    mode, recursive, wait_for_completion)
+
+    def run_on_demand_table_maintenance(self, workspace_id, lakehouse_id, 
+                                        execution_data = None,
+                                        job_type = "TableMaintenance", wait_for_completion = True):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.run_on_demand_table_maintenance(lakehouse_id = lakehouse_id, 
+                                                  execution_data = execution_data, 
+                                                  job_type = job_type, 
+                                                  wait_for_completion= wait_for_completion)
+
     # mlExperiments
 
     def list_ml_experiments(self, workspace_id):
@@ -546,6 +693,11 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.update_notebook(notebook_id, display_name = display_name, description = description)
     
+    def get_notebook_definition(self, workspace_id, notebook_id, format = None):
+        """Get the definition of a notebook"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_notebook_definition(notebook_id, format = format)
+
     def update_notebook_definition(self, workspace_id, notebook_id, definition):
         """Update the definition of a notebook"""
         ws = self.get_workspace_by_id(workspace_id)
@@ -573,6 +725,11 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.delete_report(report_id)
     
+    def get_report_definition(self, workspace_id, report_id, format = None):
+        """Get the definition of a report"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_report_definition(report_id, format = format)
+    
     def update_report_definition(self, workspace_id, report_id, definition):
         """Update the definition of a report"""
         ws = self.get_workspace_by_id(workspace_id)
@@ -600,11 +757,16 @@ class FabricClientCore(FabricClient):
         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(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 get_semantic_model_definition(self, workspace_id, semantic_model_id, format = None):
+        """Get the definition of a semantic model"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_semantic_model_definition(semantic_model_id, format = format)
+
     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)
@@ -637,6 +799,11 @@ class FabricClientCore(FabricClient):
         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 get_spark_job_definition_definition(self, workspace_id, spark_job_definition_id, format = None):
+        """Get the definition of a spark job definition"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_spark_job_definition_definition(spark_job_definition_id, format = format)
+
     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)
@@ -668,3 +835,160 @@ class FabricClientCore(FabricClient):
         """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)
+
+    # spark workspace custom pools
+
+    def list_workspace_custom_pools(self, workspace_id):
+        """List workspace custom pools"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_workspace_custom_pools()
+    
+    def create_workspace_custom_pool(self, workspace_id, name, node_family, node_size, auto_scale, dynamic_executor_allocation):
+        """Create a workspace custom pool"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_workspace_custom_pool(name = name, 
+                                               node_family = node_family,
+                                               node_size = node_size,
+                                               auto_scale = auto_scale,
+                                               dynamic_executor_allocation = dynamic_executor_allocation)
+    
+
+    def get_workspace_custom_pool(self, workspace_id, pool_id):
+        """Get a workspace custom pool"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_workspace_custom_pool(pool_id)
+    
+    def delete_workspace_custom_pool(self, workspace_id, pool_id):
+        """Delete a workspace custom pool"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_workspace_custom_pool(pool_id)
+    
+    def update_workspace_custom_pool(self, workspace_id, pool_id, name = None, node_family = None, node_size = None, auto_scale = None, dynamic_executor_allocation = None):
+        """Update a workspace custom pool"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_workspace_custom_pool(pool_id, name = name, node_family = node_family, node_size = node_size, auto_scale = auto_scale, dynamic_executor_allocation = dynamic_executor_allocation)
+    
+    # Deployment Pipelines
+
+    def deploy_stage_content(self, deployment_pipeline_id, source_stage_id, target_stage_id, created_workspace_details = None,
+               items = None, note = None, wait_for_completion = True):
+        """Deploy stage content
+        Args:
+            deployment_pipeline_id (str): The ID of the deployment pipeline
+            source_stage_id (str): The ID of the source stage
+            target_stage_id (str): The ID of the target stage
+            created_workspace_details (list): A list of created workspace details
+            items (list): A list of items
+            note (str): A note
+            wait_for_completion (bool): Whether to wait for the deployment to complete
+        Returns:
+            Details about the dpeloyment"""
+
+        pipeline = DeploymentPipeline.get_pipeline(deployment_pipeline_id, auth=self.auth)
+
+        return pipeline.deploy(source_stage_id, target_stage_id, created_workspace_details = created_workspace_details,
+               items = items, note = note, wait_for_completion = wait_for_completion)
+
+    def list_deployment_pipelines(self, continuationToken = None):
+        """List deployment pipelines
+        Args:
+            continuationToken (str): The continuation token for pagination
+        Returns:
+            list: List of DeploymentPipeline objects
+        """
+        # GET https://api.fabric.microsoft.com/v1/deploymentPipelines
+
+        url = "https://api.fabric.microsoft.com/v1/deploymentPipelines"
+
+        if continuationToken:
+            url = f"{url}?continuationToken={continuationToken}"
+
+        for _ in range(10):
+            response = requests.get(url=url, headers=self.auth.get_headers())
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                raise Exception(f"Error listing deployment pipelines: {response.status_code}, {response.text}")
+            break
+
+        resp_dict = json.loads(response.text)
+        items = resp_dict["value"]
+
+        dep_pipes = [DeploymentPipeline.from_dict(i, auth=self.auth) for i in items]
+
+        if "continuationToken" in resp_dict:
+            dep_pipes_next = self.list_deployment_pipelines(continuationToken=resp_dict["continuationToken"])
+            dep_pipes.extend(dep_pipes_next)
+
+        return dep_pipes
+    
+    def get_deployment_pipeline(self, pipeline_id):
+        """Get a deployment pipeline by ID
+        Args:
+            pipeline_id (str): The ID of the deployment pipeline
+        Returns:
+            DeploymentPipeline: The deployment pipeline
+        """
+        return DeploymentPipeline.get_pipeline(pipeline_id, auth=self.auth)
+    
+    def get_deployment_pipeline_stages_items(self, pipeline_id, stage_id = None, stage_name = None):
+        """Get the items in a deployment stage
+        Args:
+            pipeline_id (str): The ID of the deployment pipeline
+            stage_id (str): The ID of the deployment stage
+            stage_name (str): The name of the deployment stage
+        Returns:
+            list: List of DeploymentStageItem objects
+        """
+        pipeline = DeploymentPipeline.get_pipeline(pipeline_id, auth=self.auth)
+        return pipeline.get_deployment_pipeline_stages_items(stage_id, stage_name)
+
+    def get_deployment_pipeline_stages(self, pipeline_id):
+        """Get the stages of a deployment pipeline
+        Args:
+            pipeline_id (str): The ID of the deployment pipeline
+        Returns:
+            list: List of DeploymentPipelineStage objects
+        """
+        pipeline = self.get_deployment_pipeline(pipeline_id)
+        return pipeline.get_stages()
+    
+    def list_deployment_pipeline_stages(self, pipeline_id):
+        """Get the stages of a deployment pipeline
+        Args:
+            pipeline_id (str): The ID of the deployment pipeline
+        Returns:
+            list: List of DeploymentPipelineStage objects
+        """
+        return self.get_deployment_pipeline_stages(pipeline_id)
+    
+
+    # Spark workspace settings
+
+    def get_spark_settings(self, workspace_id):
+        """Get spark settings for a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+        Returns:
+            dict: The spark settings"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_spark_settings()
+    
+    def update_spark_settings(self, workspace_id, automatic_log = None, 
+                              environment = None, high_concurrency = None, pool = None):
+        """Update spark settings for a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            automatic_log (bool): Whether to automatically log
+            environment (str): The environment
+            high_concurrency (bool): Whether to use high concurrency
+            pool (str): The pool
+        Returns:
+            dict: The updated spark settings"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_spark_settings(automatic_log=automatic_log, 
+                                        environment=environment, 
+                                        high_concurrency=high_concurrency, 
+                                        pool=pool)

msfabricpysdkcore/deployment_pipeline.py

@@ -0,0 +1,240 @@
+import json
+from time import sleep
+
+import requests 
+from msfabricpysdkcore.long_running_operation import check_long_running_operation
+
+
+class DeploymentPipeline:
+    """Class to represent a deployment pipeline in Microsoft Fabric"""
+
+    def __init__(self, id, display_name, description, auth) -> None:
+        self.id = id
+        self.display_name = display_name
+        self.description = description
+        self.auth = auth
+
+    
+    def from_dict(dict,  auth):
+        """Create a Workspace object from a dictionary"""
+        if dict["displayName"] == None:
+            dict["displayName"] = dict["display_name"]
+
+        
+        return DeploymentPipeline(
+            id=dict["id"],
+            display_name=dict["displayName"],
+            description=dict["description"],
+            auth=auth
+        )
+
+    
+    def __str__(self) -> str:
+        """Return a string representation of the workspace object"""
+        dict_ = {"id": self.id, "display_name": self.display_name, "description": self.description}
+
+        return json.dumps(dict_, indent=2)
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def get_pipeline(deployment_pipeline_id, auth):
+        """Get a deployment pipeline"""
+        # GET https://api.fabric.microsoft.com/v1/deploymentPipelines/{deploymentPipelineId}
+
+        url = f"https://api.fabric.microsoft.com/v1/deploymentPipelines/{deployment_pipeline_id}"
+
+        for _ in range(10):
+            response = requests.get(url=url, headers=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):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error getting item: {response.text}")
+            break
+        
+        item_dict = json.loads(response.text)
+        return DeploymentPipeline.from_dict(item_dict, auth)
+    
+    def get_stages(self, continuationToken = None):
+        """Get stages in a deployment pipeline"""
+        # GET https://api.fabric.microsoft.com/v1/deploymentPipelines/{deploymentPipelineId}/stages
+
+        url = f"https://api.fabric.microsoft.com/v1/deploymentPipelines/{self.id}/stages"
+
+        if continuationToken:
+            url += f"?continuationToken={continuationToken}"
+
+        for _ in range(10):
+            response = requests.get(url=url, headers=self.auth.get_headers())
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error getting stages: {response.text}")
+            break
+        
+        resp_dict = json.loads(response.text)
+        items = resp_dict["value"]
+        for item in items:
+            item["deploymentPipelineId"] = self.id
+        stages = [Deployment_Pipeline_Stage.from_dict(item, self.auth) for item in items]
+
+        if "continuationToken" in resp_dict:
+            stages_next = self.get_stages(continuationToken=resp_dict["continuationToken"])
+            stages.extend(stages_next)
+        
+        return stages
+    
+
+    def deploy(self, source_stage_id, target_stage_id, created_workspace_details = None,
+               items = None, note = None, wait_for_completion = True):
+        # POST https://api.fabric.microsoft.com/v1/deploymentPipelines/{deploymentPipelineId}/deploy
+
+        url = f"https://api.fabric.microsoft.com/v1/deploymentPipelines/{self.id}/deploy"
+
+        body = {
+            "sourceStageId": source_stage_id,
+            "targetStageId": target_stage_id
+        }
+
+        if created_workspace_details:
+            body["createdWorkspaceDetails"] = created_workspace_details
+        if items:
+            body["items"] = items
+        if note:
+            body["note"] = note
+            
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code == 202 and wait_for_completion:
+                print("successfully started the operation")
+                try:
+                    operation_result = check_long_running_operation( response.headers, self.auth)
+                    return operation_result
+                except Exception as e:
+                    print("Problem waiting for long running operation. Returning initial response.")
+                    print(e)
+                    return response
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error deploying: {response.text}")
+            break
+
+        return response.json()
+
+
+
+    def get_deployment_pipeline_stages_items(self, stage_id = None, stage_name = None):
+        """Get items in a deployment pipeline stage"""
+
+        if stage_id == None and stage_name == None:
+            raise Exception("Please provide either stage_id or stage_name")
+        stages = self.get_stages()
+        if stage_id is None:
+            dep_pip_stages = [stage for stage in stages if stage.display_name == stage_name]
+            if len(dep_pip_stages) == 0:
+                raise Exception(f"Stage with name {stage_name} not found")
+        else:
+            dep_pip_stages = [stage for stage in stages if stage.id == stage_id]
+            if len(dep_pip_stages) == 0:
+                raise Exception(f"Stage with id {stage_id} not found")
+        dep_pip_stage = dep_pip_stages[0]
+        return dep_pip_stage.get_items()
+
+class Deployment_Pipeline_Stage():
+
+    """Class to represent a deployment pipeline stage in Microsoft Fabric"""
+
+    def __init__(self, id, order, display_name, description, workspace_id, workspace_name, is_public, deployment_pipeline_id, auth) -> None:
+        self.id = id
+        self.order = order
+        self.display_name = display_name
+        self.description = description
+        self.workspace_id = workspace_id
+        self.workspace_name = workspace_name
+        self.is_public = is_public
+        self.deployment_pipeline_id = deployment_pipeline_id
+        self.auth = auth
+
+    
+    def from_dict(dict,  auth):
+        """Create a Workspace object from a dictionary"""
+        if dict["displayName"] is None:
+            dict["displayName"] = dict["display_name"]
+
+        if dict.get("workspaceId", None) is None:
+            dict["workspaceId"] = dict.get("workspace_id", None)
+        
+        if dict.get("workspaceName", None)  is None:
+            dict["workspaceName"] = dict.get("workspace_name", None)
+        
+        if dict["deploymentPipelineId"] is None:
+            dict["deploymentPipelineId"] = dict["deployment_pipeline_id"]
+
+        if dict["isPublic"] is None:
+            dict["isPublic"] = dict["is_public"]
+
+        
+        return Deployment_Pipeline_Stage(id=dict["id"],
+                                         order=dict["order"],
+                                         display_name=dict["displayName"],
+                                         description=dict["description"],
+                                         workspace_id=dict["workspaceId"],
+                                         workspace_name=dict["workspaceName"],
+                                         is_public=dict["isPublic"],
+                                         deployment_pipeline_id=dict["deploymentPipelineId"],
+                                         auth=auth
+                                        )
+    
+    def __str__(self) -> str:
+        """Return a string representation of the workspace object"""
+        dict_ = {"id": self.id, "order": self.order, "display_name": self.display_name, 
+                 "description": self.description, "workspace_id": self.workspace_id, 
+                 "workspace_name": self.workspace_name, 
+                 "deployment_pipeline_id": self.deployment_pipeline_id,
+                 "is_public": self.is_public}
+
+        return json.dumps(dict_, indent=2)
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+
+    def get_items(self, continuationToken = None):
+        """Get items in a deployment pipeline stage"""
+        # GET https://api.fabric.microsoft.com/v1/deploymentPipelines/{deploymentPipelineId}/stages/{stageId}/items
+
+        url = f"https://api.fabric.microsoft.com/v1/deploymentPipelines/{self.deployment_pipeline_id}/stages/{self.id}/items"
+        if continuationToken is not None:
+            url += f"?continuationToken={continuationToken}"
+
+        for _ in range(10):
+            response = requests.get(url=url, headers=self.auth.get_headers())
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error getting items: {response.text}")
+            break
+
+        resp_dict = json.loads(response.text)
+        items = resp_dict["value"]
+        return items
+
+