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

msfabricpysdkcore/deployment_pipeline.py

@@ -6,10 +6,11 @@ from msfabricpysdkcore.coreapi import FabricClientCore
 class DeploymentPipeline:
     """Class to represent a deployment pipeline in Microsoft Fabric"""
 
-    def __init__(self, id, display_name, description, core_client: FabricClientCore) -> None:
+    def __init__(self, id, display_name, description, stages, core_client: FabricClientCore) -> None:
         self.id = id
         self.display_name = display_name
         self.description = description
+        self.stages = stages
         self.core_client = core_client
 
     
@@ -18,56 +19,108 @@ class DeploymentPipeline:
         if dict["displayName"] == None:
             dict["displayName"] = dict["display_name"]
 
-        
-        return DeploymentPipeline(
+        depl_pipe = DeploymentPipeline(
             id=dict["id"],
             display_name=dict["displayName"],
             description=dict["description"],
+            stages=[],
             core_client=core_client
         )
 
+        if "stages" in dict:
+            depl_pipe.stages = dict["stages"]
+        else:
+            dict["stages"] = depl_pipe.List_stages()
+
+        return depl_pipe
+
     
     def __str__(self) -> str:
         """Return a string representation of the workspace object"""
-        dict_ = {"id": self.id, "display_name": self.display_name, "description": self.description}
+        dict_ = {"id": self.id, "display_name": self.display_name, "description": self.description, "stages": self.stages}
 
         return json.dumps(dict_, indent=2)
     
     def __repr__(self) -> str:
         return self.__str__()
 
-    def deploy(self, source_stage_id, target_stage_id, created_workspace_details = None,
-               items = None, note = None, wait_for_completion = True):
+    def add_role_assignment(self, principal, role):
+        """Add a role assignment to the deployment pipeline"""
+        return self.core_client.add_deployment_pipeline_role_assignment(deployment_pipeline_id=self.id, principal=principal, role=role)
+    
+    def assign_workspace_to_stage(self, stage_id, workspace_id):
+        """Assign a workspace to a stage in the deployment pipeline"""
+        return self.core_client.assign_workspace_to_stage(deployment_pipeline_id=self.id, stage_id=stage_id, workspace_id=workspace_id)
+
+    def delete(self):
+        """Delete the deployment pipeline"""
+        return self.core_client.delete_deployment_pipeline(deployment_pipeline_id=self.id)
+
+    def delete_role_assignment(self, principal_id):
+        """Delete a role assignment from the deployment pipeline"""
+        return self.core_client.delete_deployment_pipeline_role_assignment(deployment_pipeline_id=self.id, principal_id=principal_id)
+    
+    def deploy_stage_content(self, source_stage_id, target_stage_id, created_workspace_details = None,
+               items = None, note = None, options = None, wait_for_completion = True):
+        """Deploy the content of a stage to another stage in the deployment pipeline"""
         return self.core_client.deploy_stage_content(deployment_pipeline_id=self.id, source_stage_id=source_stage_id,
                                                      target_stage_id=target_stage_id, created_workspace_details=created_workspace_details,
-                                                     items=items, note=note, wait_for_completion=wait_for_completion)
+                                                     items=items, note=note, options=options, wait_for_completion=wait_for_completion)
+  
+    def deploy(self, source_stage_id, target_stage_id, created_workspace_details = None,
+               items = None, note = None, options = None, wait_for_completion = True):
+        return self.deploy_stage_content(deployment_pipelinesource_stage_id=source_stage_id,
+                                         target_stage_id=target_stage_id, created_workspace_details=created_workspace_details,
+                                         items=items, note=note, options=options, wait_for_completion=wait_for_completion)
     
-    def get_pipeline(deployment_pipeline_id, core_client: FabricClientCore):
-        return core_client.get_deployment_pipeline(deployment_pipeline_id=deployment_pipeline_id)   
+    def get(self):
+        """Get the deployment pipeline"""
+        return self.core_client.get_deployment_pipeline(deployment_pipeline_id=self.id)
 
+    def get_operation(self, operation_id):
+        """Get the deployment pipeline operation"""
+        return self.core_client.get_deployment_pipeline_operation(deployment_pipeline_id=self.id, operation_id=operation_id)
 
-    def get_stages(self):
-        warn("DEPRECATED: Use list_stages() instead", DeprecationWarning, stacklevel=2)
-        return self.list_stages(self)
+    def get_stage(self, stage_id):
+        """Get the deployment pipeline stage"""
+        return self.core_client.get_deployment_pipeline_stage(deployment_pipeline_id=self.id, stage_id=stage_id)
+
+    def list_operations(self):
+        """List the deployment pipeline operations"""
+        return self.core_client.list_deployment_pipeline_operations(deployment_pipeline_id=self.id)
     
-    def list_stages(self):
-        return self.core_client.list_deployment_pipeline_stages(deployment_pipeline_id=self.id)
+    def list_role_assignments(self):
+        """List the role assignments of the deployment pipeline"""
+        return self.core_client.list_deployment_pipeline_role_assignments(deployment_pipeline_id=self.id)
 
+    def list_stage_items(self, stage_id = None, stage_name = None):
+        """List the items in the deployment pipeline stage"""
+        return self.core_client.list_deployment_pipeline_stage_items(deployment_pipeline_id=self.id, stage_id=stage_id, stage_name=stage_name)
 
-    def get_deployment_pipeline_stages_items(self, stage_id = None, stage_name = None):
-        warn("DEPRECATED: get_deployment_pipeline_stages_items. Use list_deployment_pipeline_stages_items() instead", DeprecationWarning, stacklevel=2)
-        return self.list_deployment_pipeline_stages_items(stage_id=stage_id, stage_name=stage_name)
+    def list_stages(self):
+        """List the stages in the deployment pipeline"""
+        return self.core_client.list_deployment_pipeline_stages(deployment_pipeline_id=self.id)
 
+    def unassign_workspace_from_stage(self, stage_id):
+        """Unassign a workspace from a stage in the deployment pipeline"""
+        return self.core_client.unassign_workspace_from_stage(deployment_pipeline_id=self.id, stage_id=stage_id)
+    
+    def update(self, display_name = None, description = None):
+        """Update the deployment pipeline"""
+        return self.core_client.update_deployment_pipeline(deployment_pipeline_id=self.id, display_name=display_name, description=description)
 
-    def list_deployment_pipeline_stages_items(self, stage_id = None, stage_name = None):
-        return self.core_client.list_deployment_pipeline_stages_items(deployment_pipeline_id=self.id, stage_id=stage_id, stage_name=stage_name)
+    def update_stage(self, stage_id, display_name, description = None, is_public = None):
+        """Update the deployment pipeline stage"""
+        return self.core_client.update_deployment_pipeline_stage(deployment_pipeline_id=self.id, stage_id=stage_id, display_name=display_name, description=description, is_public=is_public)
 
+        
 
-class Deployment_Pipeline_Stage():
+class DeploymentPipelineStage():
 
     """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, core_client: FabricClientCore) -> None:
+    def __init__(self, id, order, display_name, description, workspace_id, workspace_name, is_public,
+                 deployment_pipeline_id, core_client: FabricClientCore, items = None) -> None:
         self.id = id
         self.order = order
         self.display_name = display_name
@@ -75,6 +128,7 @@ class Deployment_Pipeline_Stage():
         self.workspace_id = workspace_id
         self.workspace_name = workspace_name
         self.is_public = is_public
+        self.items = items
         self.deployment_pipeline_id = deployment_pipeline_id
         self.core_client = core_client
 
@@ -97,13 +151,14 @@ class Deployment_Pipeline_Stage():
             dict["isPublic"] = dict["is_public"]
 
         
-        return Deployment_Pipeline_Stage(id=dict["id"],
+        return DeploymentPipelineStage(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"],
+                                         items = dict.get("items", None),
                                          deployment_pipeline_id=dict["deploymentPipelineId"],
                                          core_client=core_client
                                         )
@@ -121,10 +176,28 @@ class Deployment_Pipeline_Stage():
     def __repr__(self) -> str:
         return self.__str__()
     
-    def get_items(self):
-        warn("DEPRECATED: get_items. Use list_items() instead", DeprecationWarning, stacklevel=2)
-        return self.list_items()
-    
+    def assign_workspace_to_stage(self, workspace_id):
+        """Assign a workspace to the stage"""
+        resp = self.core_client.assign_workspace_to_stage(deployment_pipeline_id=self.deployment_pipeline_id, stage_id=self.id, workspace_id=workspace_id)
+        self.workspace_id = workspace_id
+        ws = self.core_client.get_workspace(workspace_id=workspace_id)
+        self.workspace_name = ws.display_name
+        return resp
+
+    def get(self):
+        """Get the deployment pipeline stage"""
+        return self.core_client.get_deployment_pipeline_stage(deployment_pipeline_id=self.deployment_pipeline_id, stage_id=self.id)
+
     def list_items(self):
-        return self.core_client.list_deployment_pipeline_stages_items(deployment_pipeline_id=self.deployment_pipeline_id, stage_id=self.id)
-        
+        return self.core_client.list_deployment_pipeline_stage_items(deployment_pipeline_id=self.deployment_pipeline_id, stage_id=self.id)
+    
+    def unassign_workspacee(self):
+        """Unassign the workspace from the stage"""
+        resp = self.core_client.unassign_workspace_from_stage(deployment_pipeline_id=self.deployment_pipeline_id, stage_id=self.id)
+        self.workspace_id = None
+        self.workspace_name = None
+        return resp
+    
+    def update(self, display_name = None, description = None, is_public = None):
+        """Update the deployment pipeline stage"""
+        return self.core_client.update_deployment_pipeline_stage(deployment_pipeline_id=self.deployment_pipeline_id, stage_id=self.id, display_name=display_name, description=description, is_public=is_public)

msfabricpysdkcore/domain.py

@@ -54,7 +54,10 @@ class Domain:
         if "display_name" not in dic:
             dic["display_name"] = dic["displayName"]
         if "parent_domain_id" not in dic:
-            dic["parent_domain_id"] = dic["parentDomainId"]
+            if "parentDomainId" in dic:
+                dic["parent_domain_id"] = dic["parentDomainId"]
+            else:
+                dic["parent_domain_id"] = None
         if "contributors_scope" not in dic:
             dic["contributors_scope"] = dic["contributorsScope"]
         return Domain(id=dic['id'], display_name=dic['display_name'],

msfabricpysdkcore/eventstream.py

@@ -0,0 +1,68 @@
+from msfabricpysdkcore.item import Item
+
+class Eventstream(Item):
+    """Class to represent a eventstream in Microsoft Fabric"""
+
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties=None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+    
+    def from_dict(item_dict, core_client):
+        return Eventstream(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', ""), core_client=core_client)
+
+    def get_definition(self, type=None, format=None):
+        """Method to get the definition of the eventstream"""
+        return super().get_definition(type="eventstreams", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the eventstream"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="eventstreams")
+    
+    # eventstream topology
+    def get_eventstream_destination(self, destination_id):
+        """Get the destination of an eventstream in a workspace"""
+        return self.core_client.get_eventstream_destination(workspace_id=self.workspace_id, eventstream_id=self.id, destination_id=destination_id)
+    
+    def get_eventstream_destination_connection(self, destination_id):
+        """Get the connection of a destination in an eventstream in a workspace"""
+        return self.core_client.get_eventstream_destination_connection(workspace_id=self.workspace_id, eventstream_id=self.id, destination_id=destination_id)
+
+    def get_eventstream_source(self, source_id):
+        """Get the source of an eventstream in a workspace"""
+        return self.core_client.get_eventstream_source(workspace_id=self.workspace_id, eventstream_id=self.id, source_id=source_id)
+
+    def get_eventstream_source_connection(self, source_id):
+        """Get the connection of a source in an eventstream in a workspace"""
+        return self.core_client.get_eventstream_source_connection(workspace_id=self.workspace_id, eventstream_id=self.id, source_id=source_id)
+
+    def get_eventstream_topology(self):
+        """Get the topology of an eventstream in a workspace"""
+        return self.core_client.get_eventstream_topology(workspace_id=self.workspace_id, eventstream_id=self.id)
+    
+    def pause_eventstream(self):
+        """Pause an eventstream in a workspace"""
+        return self.core_client.pause_eventstream(workspace_id=self.workspace_id, eventstream_id=self.id)
+    
+    def pause_eventstream_destination(self, destination_id):
+        """Pause a destination in an eventstream in a workspace"""
+        return self.core_client.pause_eventstream_destination(workspace_id=self.workspace_id, eventstream_id=self.id, destination_id=destination_id)
+
+    def pause_eventstream_source(self, source_id):
+        """Pause a source in an eventstream in a workspace"""
+        return self.core_client.pause_eventstream_source(workspace_id=self.workspace_id, eventstream_id=self.id, source_id=source_id)
+
+    def resume_eventstream(self, start_type, custom_start_date_time = None):
+        """Resume an eventstream in a workspace"""
+        return self.core_client.resume_eventstream(workspace_id=self.workspace_id, eventstream_id=self.id, start_type=start_type, custom_start_date_time=custom_start_date_time)
+
+    def resume_eventstream_destination(self, destination_id, start_type, custom_start_date_time = None):
+        """Resume a destination in an eventstream in a workspace"""
+        return self.core_client.resume_eventstream_destination(workspace_id=self.workspace_id, eventstream_id=self.id,
+                                                               destination_id=destination_id, start_type=start_type, custom_start_date_time=custom_start_date_time)
+
+    def resume_eventstream_source(self, source_id, start_type, custom_start_date_time = None):
+        """Resume a source in an eventstream in a workspace"""
+        return self.core_client.resume_eventstream_source(workspace_id=self.workspace_id, eventstream_id=self.id,
+                                                          source_id=source_id, start_type=start_type, custom_start_date_time=custom_start_date_time)
+

msfabricpysdkcore/folder.py

@@ -0,0 +1,69 @@
+import json 
+
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+class Folder:
+    """Class to represent a folder in Microsoft Fabric"""
+
+    def __init__(self, id, display_name, workspace_id, core_client: FabricClientCore, parent_folder_id) -> None:
+        
+        self.id = id
+        self.display_name = display_name
+        self.parent_folder_id = parent_folder_id
+        self.workspace_id = workspace_id
+        
+        self.core_client = core_client
+
+    def __str__(self) -> str:
+        """Return a string representation of the workspace object"""
+        dict_ = {
+            'id': self.id,
+            'display_name': self.display_name,
+            'parent_folder_id': self.parent_folder_id,
+            'workspace_id': self.workspace_id,
+        }
+        return json.dumps(dict_, indent=2)
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def from_dict(folder_dict, core_client):
+        """Create Folder object from dictionary"""
+        
+        return Folder(id=folder_dict['id'], display_name=folder_dict['displayName'], workspace_id=folder_dict['workspaceId'],
+                       parent_folder_id=folder_dict.get('parentFolderId', ""), core_client=core_client)
+
+    def delete(self):
+        """Delete the folder"""
+        return self.core_client.delete_folder(workspace_id=self.workspace_id, folder_id=self.id)
+    
+    def get(self):
+        """Get the folder"""
+        returned_folder = self.core_client.get_folder(workspace_id=self.workspace_id, folder_id=self.id)
+        self.display_name = returned_folder.display_name
+        self.parent_folder_id = returned_folder.parent_folder_id
+        self.workspace_id = returned_folder.workspace_id
+        return returned_folder
+    
+    def move(self, target_folder_id = None):
+        """Move a folder
+        Args:
+            target_folder_id (str): The ID of the target folder
+        Returns:
+            dict: The moved folder
+        """
+        moved_folder =  self.core_client.move_folder(folder_id=self.id, target_folder_id=target_folder_id)
+        self.id = moved_folder.id
+        self.display_name = moved_folder.display_name
+        self.parent_folder_id = moved_folder.parent_folder_id
+        self.workspace_id = moved_folder.workspace_id
+
+        return moved_folder
+    
+    def update(self, display_name = None):
+        """Update the folder"""
+        updated_folder = self.core_client.update_folder(workspace_id=self.workspace_id, folder_id=self.id, display_name=display_name)
+        self.display_name = updated_folder.display_name
+        self.parent_folder_id = updated_folder.parent_folder_id
+        self.workspace_id = updated_folder.workspace_id
+        return updated_folder

msfabricpysdkcore/item.py

@@ -79,6 +79,15 @@ class Item:
         self.definition = definition 
         return response
     
+    # Tags   
+    def apply_tags(self, tags):
+        """Apply tags to an item in a workspace"""
+        return self.core_client.apply_tags(workspace_id=self.workspace_id, item_id=self.id, tags=tags)
+    
+    def unapply_tags(self, tags):
+        """Unapply tags from an item in a workspace"""
+        return self.core_client.unapply_tags(workspace_id=self.workspace_id, item_id=self.id, tags=tags)
+    
     # Shortcut
 
     def create_shortcut(self, path, name, target):

msfabricpysdkcore/lakehouse.py

@@ -24,4 +24,12 @@ class Lakehouse(Item):
     
     def run_on_demand_table_maintenance(self, execution_data, job_type = "TableMaintenance", wait_for_completion = True):
         """Run on demand table maintenance"""
-        return self.core_client.run_on_demand_table_maintenance(self.workspace_id, self.id, execution_data, job_type, wait_for_completion)
+        return self.core_client.run_on_demand_table_maintenance(self.workspace_id, self.id, execution_data, job_type, wait_for_completion)
+    
+    def list_livy_sessions(self):
+        """List all livy sessions in the lakehouse"""
+        return self.core_client.list_lakehouse_livy_sessions(self.workspace_id, self.id)
+
+    def get_livy_session(self, livy_id):
+        """Get a livy session in the lakehouse"""
+        return self.core_client.get_lakehouse_livy_session(self.workspace_id, self.id, livy_id)

msfabricpysdkcore/otheritems.py

@@ -1,6 +1,42 @@
 from msfabricpysdkcore.item import Item
 
 
+class CopyJob(Item):
+    """Class to represent a copy job in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return CopyJob(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', ""), core_client=core_client)
+
+class Dataflow(Item):
+    """Class to represent a dataflow in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return Dataflow(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', ""), core_client=core_client)
+    
+class DataPipeline(Item):
+    """Class to represent a spark job definition in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return DataPipeline(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', ""), core_client=core_client)
+        
+    def run_on_demand_item_job(self, execution_data=None):
+        return self.core_client.run_on_demand_item_job(workspace_id=self.workspace_id, item_id=self.id, job_type="Pipeline", execution_data=execution_data)
+    
 class Eventhouse(Item):
     """Class to represent a eventhouse in Microsoft Fabric"""
      
@@ -56,6 +92,13 @@ class SparkJobDefinition(Item):
     def run_on_demand_spark_job_definition(self, job_type = "sparkjob"):
         return self.core_client.run_on_demand_spark_job_definition(workspace_id=self.workspace_id, spark_job_definition_id=self.id, job_type=job_type)
 
+    def list_livy_sessions(self):
+        """List all livy sessions in the spark job definition"""
+        return self.core_client.list_spark_job_definition_livy_sessions(self.workspace_id, self.id)
+
+    def get_livy_session(self, livy_id):
+        """Get a livy session in the spark job definition"""
+        return self.core_client.get_spark_job_definition_livy_session(self.workspace_id, self.id, livy_id)
 
 class Warehouse(Item):
     """Class to represent a warehouse in Microsoft Fabric"""
@@ -126,31 +169,11 @@ class KQLQueryset(Item):
         return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="kqlQuerysets",
                                                        update_metadata=update_metadata)
     
-    
-
-class Eventstream(Item):
-    """Class to represent a eventstream in Microsoft Fabric"""
-     
-    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
-        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
-    
-    def from_dict(item_dict, core_client):
-        return Eventstream(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', ""), core_client=core_client)
-
-    def get_definition(self, type=None, format=None):
-        """Method to get the definition of the eventstream"""
-        return super().get_definition(type="eventstreams", format=format)
-    
-    def update_definition(self, definition):
-        """Method to update the definition of the eventstream"""
-        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="eventstreams")
 
 class GraphQLApi(Item):
     """Class to represent a graphql api in Microsoft Fabric"""
-     
-    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties=None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
     
     def from_dict(item_dict, core_client):
@@ -251,6 +274,14 @@ class Notebook(Item):
     def update_definition(self, definition):
         """Method to update the definition of the notebook"""
         return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="notebooks")
+    
+    def list_livy_sessions(self):
+        """List all livy sessions in the notebook"""
+        return self.core_client.list_notebook_livy_sessions(self.workspace_id, self.id)
+
+    def get_livy_session(self, livy_id):
+        """Get a livy session in the notebook"""
+        return self.core_client.get_notebook_livy_session(self.workspace_id, self.id, livy_id)
 
 class Reflex(Item):
     """Class to represent a reflex in Microsoft Fabric"""
@@ -320,25 +351,13 @@ class SQLDatabase(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
 
-class DataPipeline(Item):
-    """Class to represent a spark job definition in Microsoft Fabric"""
-     
-    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+class VariableLibrary(Item):
+    """Class to represent a variable library in Microsoft Fabric"""
+
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties=None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
 
     def from_dict(item_dict, core_client):
-        return DataPipeline(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+        return VariableLibrary(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', ""), core_client=core_client)
-    
-    def get_definition(self, type=None, format=None, **kwargs):
-        return super().get_definition(type="dataPipelines", format=format, **kwargs)
-    
-    def update_definition(self, definition):
-        """Method to update the definition of the dataPipeline"""
-        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="dataPipelines")
-    
-    def run_on_demand_item_job(self, execution_data=None):
-        return self.core_client.run_on_demand_item_job(workspace_id=self.workspace_id, item_id=self.id, job_type="Pipeline", execution_data=execution_data)
-    
-    
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)

msfabricpysdkcore/tests/test_admin_tags.py

@@ -0,0 +1,46 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientAdmin
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fca = FabricClientAdmin()
+                  
+    def test_admin_api(self):
+        fca = self.fca
+
+        sdk_tag = [tag for tag in fca.list_tags() if tag["displayName"] == "sdk_tag_temp"]
+        if len(sdk_tag) > 0:
+            sdk_tag = sdk_tag[0]
+            resp = fca.delete_tag(tag_id=sdk_tag["id"])
+            self.assertEqual(resp, 200)
+      
+        new_tags = [{"displayName": "sdk_tag_temp"}]
+        resp = fca.bulk_create_tags(create_tags_request=new_tags)
+        self.assertEqual(len(resp["tags"]), 1)
+        resp = resp["tags"][0]
+        self.assertEqual(resp["displayName"], "sdk_tag_temp")
+
+        sdk_tag = [tag for tag in fca.list_tags() if tag["displayName"] == "sdk_tag_temp"]
+        self.assertEqual(len(sdk_tag), 1)
+        sdk_tag = sdk_tag[0]
+
+        self.assertIsNotNone(sdk_tag["id"])
+
+        resp = fca.update_tag(tag_id=sdk_tag["id"], display_name="sdk_tag_updated")
+        self.assertIsNotNone(resp["id"])
+        self.assertEqual(resp["displayName"], "sdk_tag_updated")
+
+
+        resp = fca.delete_tag(tag_id=resp["id"])
+        self.assertEqual(resp, 200)
+
+        sdk_tag = [tag for tag in fca.list_tags() if tag["displayName"] == "sdk_tag_temp"]
+        self.assertEqual(len(sdk_tag), 0)
+
+
+

msfabricpysdkcore/tests/test_copy_jobs.py

@@ -0,0 +1,60 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+from datetime import datetime
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_copy_jobs(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "a9e59ec1-524b-49b1-a185-37e47dc0ceb9"
+
+        copy_jobs = fcc.list_copy_jobs(workspace_id=workspace_id)
+        for copy_job in copy_jobs:
+            if copy_job.id != item_id:
+                resp = fcc.delete_copy_job(workspace_id=workspace_id, copy_job_id=copy_job.id)
+                self.assertEqual(resp, 200)
+
+        copy_job_definition = fcc.get_copy_job_definition(workspace_id=workspace_id, copy_job_id=item_id)
+        self.assertIn("definition", copy_job_definition)
+        definition = copy_job_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"copyjob{date_str}"
+
+        copy_job_new = fcc.create_copy_job(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(copy_job_new.display_name, date_str)
+
+        copy_job_get = fcc.get_copy_job(workspace_id=workspace_id, copy_job_id=copy_job_new.id)
+        self.assertEqual(copy_job_get.display_name, date_str)
+
+        copy_jobs = fcc.list_copy_jobs(workspace_id=workspace_id)
+        self.assertEqual(len(copy_jobs), 2)
+
+        date_str_updated = date_str + "_updated"
+        copy_job_updated = fcc.update_copy_job(workspace_id=workspace_id, copy_job_id=copy_job_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(copy_job_updated.display_name, date_str_updated)
+
+        copy_job_updated = fcc.update_copy_job_definition(workspace_id=workspace_id, copy_job_id=copy_job_new.id, definition=definition)
+        self.assertEqual(copy_job_updated.status_code, 200)
+
+        for copy_job in copy_jobs:
+            if copy_job.id != item_id:
+                resp = fcc.delete_copy_job(workspace_id=workspace_id, copy_job_id=copy_job.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+