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

msfabricpysdkcore/otheritems.py

@@ -1,5 +1,6 @@
+import json
 from time import sleep
-
+import requests
 from msfabricpysdkcore.item import Item
 
 class SparkJobDefinition(Item):
@@ -8,35 +9,71 @@ class SparkJobDefinition(Item):
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
+    def from_dict(item_dict, auth):
+        return SparkJobDefinition(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', ""), auth=auth)
+    
+    def get_definition(self, format=None):
+        return super().get_definition(type="sparkJobDefinitions", format=format)
+    
+    def update_definition(self, definition):
+        return super().update_definition(definition=definition, type="sparkJobDefinitions")
+    
 class Warehouse(Item):
     """Class to represent a warehouse in Microsoft Fabric"""
      
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
+    def from_dict(item_dict, auth):
+        return Warehouse(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', ""), auth=auth)
+
 class KQLDatabase(Item):
     """Class to represent a kql database in Microsoft Fabric"""
      
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
+    def from_dict(item_dict, auth):
+        return KQLDatabase(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', ""), auth=auth)
+
 class KQLQueryset(Item):
     """Class to represent a kql database in Microsoft Fabric"""
      
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
+    def from_dict(item_dict, auth):
+        return KQLQueryset(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', ""), auth=auth)
+
 class Eventstream(Item):
     """Class to represent a eventstream in Microsoft Fabric"""
      
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
-
+    
+    def from_dict(item_dict, auth):
+        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', ""), auth=auth)
+    
 class MLExperiment(Item):
     """Class to represent a ml experiment in Microsoft Fabric"""
      
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
+    
+    def from_dict(item_dict, auth):
+        return MLExperiment(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', ""), auth=auth)
 
 class MLModel(Item):
     """Class to represent a ml model in Microsoft Fabric"""
@@ -44,29 +81,79 @@ class MLModel(Item):
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
+    def from_dict(item_dict, auth):
+        return MLModel(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', ""), auth=auth)
+
 class Notebook(Item):
     """Class to represent a notebook in Microsoft Fabric"""
      
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
+    def from_dict(item_dict, auth):
+        return Notebook(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', ""), auth=auth)
+    
+    def get_definition(self, format=None):
+        """Method to get the definition of the notebook"""
+        return super().get_definition(type = "notebooks", format = format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the notebook"""
+        return super().update_definition(definition, type = "notebooks")
+
 class Report(Item):
     """Class to represent a report in Microsoft Fabric"""
      
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
+    def from_dict(item_dict, auth):
+        return Report(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', ""), auth=auth)
+    
+    def get_definition(self, type=None, format=None):
+        """Method to get the definition of the report"""
+        return super().get_definition(type = "reports", format = format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the report"""
+        return super().update_definition(definition, type = "reports")
+
 class SemanticModel(Item):
     """Class to represent a semantic model in Microsoft Fabric"""
      
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
+    def from_dict(item_dict, auth):
+        return SemanticModel(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', ""), auth=auth)
+    
+    def get_definition(self, format=None):
+        """Method to get the definition of the semantic model"""
+        return super().get_definition(type="semanticModels", format=format)
+    
+    def update_definition(self, definition):
+        """Method to update the definition of the semantic model"""
+        return super().update_definition(definition, type = "semanticModels")
+
 class DataPipeline(Item):
     """Class to represent a spark job definition in Microsoft Fabric"""
      
     def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
+    def from_dict(item_dict, auth):
+        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', ""), auth=auth)
+    
     def run_on_demand_item_job(self, execution_data=None):
-        return super().run_on_demand_item_job(job_type = "Pipeline", execution_data=execution_data)
+        return super().run_on_demand_item_job(job_type = "Pipeline", execution_data=execution_data)
+    

msfabricpysdkcore/spark_custom_pool.py

@@ -0,0 +1,118 @@
+import json
+from time import sleep
+
+import requests 
+
+
+class SparkCustomPool:
+    """Class to represent a custom pool in Microsoft Fabric"""
+
+    def __init__(self, id, name, type, node_family, node_size, auto_scale, dynamic_executor_allocation, workspace_id, auth) -> None:
+        
+        self.id = id
+        self.name = name
+        self.type = type
+        self.node_family = node_family
+        self.node_size = node_size
+        self.auto_scale = auto_scale
+        self.dynamic_executor_allocation = dynamic_executor_allocation
+        self.workspace_id = workspace_id
+        
+        self.auth = auth
+
+    def __str__(self) -> str:
+        """Return a string representation of the workspace object"""
+        dict_ = {
+            "id": self.id,
+            "name": self.name,
+            "type": self.type,
+            "nodeFamily": self.node_family,
+            "nodeSize": self.node_size,
+            "autoScale": self.auto_scale,
+            "dynamicExecutorAllocation": self.dynamic_executor_allocation,
+            "workspaceId": self.workspace_id
+        }
+        return json.dumps(dict_, indent=2)
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def from_dict(item_dict, auth):
+        """Create Item object from dictionary"""
+
+        if 'autoScale' not in item_dict:
+            item_dict['autoScale'] = item_dict['auto_scale']
+
+        if 'dynamicExecutorAllocation' not in item_dict:
+            item_dict['dynamicExecutorAllocation'] = item_dict['dynamic_executor_allocation']
+        
+        if 'nodeFamily' not in item_dict:
+            item_dict['nodeFamily'] = item_dict['node_family']
+        
+        if 'nodeSize' not in item_dict:
+            item_dict['nodeSize'] = item_dict['node_size']
+        
+        return SparkCustomPool(id=item_dict['id'], name=item_dict['name'], type=item_dict['type'], node_family=item_dict['nodeFamily'],
+                                node_size=item_dict['nodeSize'], auto_scale=item_dict['autoScale'], dynamic_executor_allocation=item_dict['dynamicExecutorAllocation'],
+                                workspace_id=item_dict['workspaceId'], auth=auth)
+
+
+    def delete(self):
+        """Delete the custom pool item"""
+        # DELETE http://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/spark/pools/{poolId}
+
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/spark/pools/{self.id}"
+        for _ in range(10):
+            response = requests.delete(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 deleting spark pool: {response.status_code}, {response.text}")
+            break
+
+        return response.status_code
+    
+
+    def update(self, name, node_family, node_size, auto_scale, dynamic_executor_allocation):
+        """Update the custom pool item"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/spark/pools/{self.id}"
+        body = {}
+
+        if name is not None:
+            body['name'] = name
+        if node_family is not None:
+            body['nodeFamily'] = node_family
+        if node_size is not None:
+            body['nodeSize'] = node_size
+        if auto_scale is not None:
+            body['autoScale'] = auto_scale
+        if dynamic_executor_allocation is not None:
+            body['dynamicExecutorAllocation'] = dynamic_executor_allocation
+
+        if not body:
+            return self
+        for _ in range(10):
+            response = requests.patch(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 not in (200, 429):
+                raise Exception(f"Error updating item: {response.status_code}, {response.text}")
+            break
+
+        if name is not None:
+            self.name = name
+        if node_family is not None:
+            self.node_family = node_family
+        if node_size is not None:
+            self.node_size = node_size
+        if auto_scale is not None:
+            self.auto_scale = auto_scale
+        if dynamic_executor_allocation is not None:
+            self.dynamic_executor_allocation = dynamic_executor_allocation
+
+        return self
+    

msfabricpysdkcore/tests/test_admin_apis.py

@@ -1,16 +1,17 @@
 import unittest
-#from dotenv import load_dotenv
+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_domains(self):
-        fca = FabricClientAdmin()
+    def test_admin_api(self):
+        fca = self.fca
 
         user_id = 'b4f4e299-e6e1-4667-886c-57e4a8dde1c2'
 
@@ -26,24 +27,24 @@ class TestFabricClientCore(unittest.TestCase):
 
         # Get workspace access details
 
-        ws_access = fca.get_workspace_access_details(ws.id)
+        ws_access = fca.list_workspace_access_details(ws.id)
         principials = ws_access["accessDetails"]
         principials_ids = [p["principal"]["id"] for p in principials]
         self.assertIn(user_id, principials_ids)
 
         # Get access entities
 
-        access_entities = fca.get_access_entities(user_id, type="Notebook")
+        access_entities = fca.list_access_entities(user_id, type="Notebook")
         self.assertGreater(len(access_entities), 0)
 
         # Get tenant settings
 
-        tenant_settings = fca.get_tenant_settings()
+        tenant_settings = fca.list_tenant_settings()
         self.assertGreater(len(tenant_settings["tenantSettings"]), 0)
 
         # Get capacity tenant settings overrides
 
-        overrides = fca.get_capacities_tenant_settings_overrides()
+        overrides = fca.list_capacities_tenant_settings_overrides()
         self.assertGreater(len(overrides), -1)
 
         # List items
@@ -58,7 +59,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         # Get item access details
 
-        item_access = fca.get_item_access_details(workspace_id=ws.id, item_id=item_list[0].id)
+        item_access = fca.list_item_access_details(workspace_id=ws.id, item_id=item_list[0].id)
         principials = item_access["accessDetails"]
 
         principials_ids = [p["principal"]["id"] for p in principials]
@@ -66,3 +67,13 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertIn(user_id, principials_ids)
 
 
+    def test_labels(self):
+
+        fca = self.fca
+
+        items = [{"id": "d417b834-d381-454c-9cf0-c491f69508de", "type": "Lakehouse"}]
+        label_id = "defa4170-0d19-0005-000a-bc88714345d2"
+        resp = fca.bulk_set_labels(items=items, label_id=label_id)
+        self.assertEqual(resp["itemsChangeLabelStatus"][0]["status"], "Succeeded")
+        resp = fca.bulk_remove_labels(items=items)
+        self.assertEqual(resp["itemsChangeLabelStatus"][0]["status"], "Succeeded")

msfabricpysdkcore/tests/test_deployment_pipeline.py

@@ -0,0 +1,64 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fc = FabricClientCore()
+        
+
+
+    def test_spark_workspace_custom_pools(self):
+        fc = self.fc
+
+        dep_pipes = fc.list_deployment_pipelines()
+
+        self.assertGreater(len(dep_pipes), 0)
+
+        self.assertIn("sdkpipe", [pipe.display_name for pipe in dep_pipes])
+
+        for pipe in dep_pipes:
+            if pipe.display_name == 'sdkpipe':
+                pipe_id = pipe.id
+                break
+
+        pipe = fc.get_deployment_pipeline(pipe_id)
+
+        self.assertEqual(pipe.display_name, 'sdkpipe')
+        self.assertEqual(pipe.id, pipe_id)
+
+        stages = fc.get_deployment_pipeline_stages(pipe_id)
+
+        self.assertGreater(len(stages), 0)
+        names = [stage.display_name for stage in stages]
+        self.assertIn("Development", names)
+        self.assertIn("Production", names)
+
+        dev_stage = [stage for stage in stages if stage.display_name == "Development"][0]
+        prod_stage = [stage for stage in stages if stage.display_name == "Production"][0]
+
+        items = fc.get_deployment_pipeline_stages_items(pipeline_id=pipe_id, stage_id=dev_stage.id)
+        
+        self.assertGreater(len(items), 0)
+        self.assertIn("cicdlakehouse", [item["itemDisplayName"] for item in items])
+       
+        items = [item for item in dev_stage.get_items() if item["itemDisplayName"] == 'cicdlakehouse']
+        item = items[0]
+        item = {"sourceItemId": item["itemId"],
+                "itemType": item["itemType"]}
+        items = [item]
+
+        
+        response = pipe.deploy(source_stage_id=dev_stage.id,target_stage_id=prod_stage.id, items=items)
+
+        self.assertEqual(response["status"], "Succeeded")
+
+        
+
+
+

msfabricpysdkcore/tests/test_domains.py

@@ -1,9 +1,10 @@
 import unittest
-#from dotenv import load_dotenv
-from datetime import datetime
+from dotenv import load_dotenv
 from msfabricpysdkcore import FabricClientCore, FabricClientAdmin
 
 
+load_dotenv()
+
 class TestFabricClientCore(unittest.TestCase):
 
     def __init__(self, *args, **kwargs):

msfabricpysdkcore/tests/test_environments.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()
+        self.workspace_id = "d8a5abe0-9eed-406d-ab46-343bc57ddbe5"
+
+        
+    def test_environments(self):
+        fc = self.fc
+        workspace_id = self.workspace_id
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        envname = "testitem" + datetime_str
+        env1 = fc.create_environment(workspace_id, envname, "testenv description")
+
+        env2 = fc.get_environment(workspace_id, environment_name=envname)
+
+        self.assertEqual(env1.id, env2.id)
+
+        env_list = fc.list_environments(workspace_id, with_properties=True)
+        env_names = [env.display_name for env in env_list]
+
+        self.assertIn(envname, env_names)
+
+        env3 = fc.update_environment(workspace_id, env1.id, envname + "name", "testenv description updated")
+
+        env4 = fc.get_environment(workspace_id, environment_name=env3.display_name)
+
+        self.assertEqual(env1.id, env4.id)
+
+        fc.delete_environment(workspace_id, env4.id)
+
+        env_list = fc.list_environments(workspace_id, with_properties=True)
+        env_names = [env.display_name for env in env_list]
+
+        self.assertNotIn(env4.display_name, env_names)
+
+        

msfabricpysdkcore/tests/test_git.py

@@ -1,7 +1,9 @@
 import unittest
 from msfabricpysdkcore.coreapi import FabricClientCore
 from datetime import datetime
-#from dotenv import load_dotenv
+from dotenv import load_dotenv
+
+load_dotenv()
 
 class TestFabricClientCore(unittest.TestCase):
 

msfabricpysdkcore/tests/test_items_incl_lakehouse.py

@@ -1,9 +1,11 @@
 import unittest
 from datetime import datetime
-#from dotenv import load_dotenv
+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):
@@ -104,17 +106,39 @@ class TestFabricClientCore(unittest.TestCase):
 
         lakehouse = self.fc.get_item(workspace_id=self.workspace_id, item_name="lakehouse1", item_type="Lakehouse")
         self.assertIsNotNone(lakehouse.properties)
-        item_id = lakehouse.id
+        lakehouse_id = lakehouse.id
+        workspace_id = self.workspace_id
         date_str = datetime.now().strftime("%Y%m%d%H%M%S")
         table_name = f"table{date_str}"
 
 
-        status_code = self.fc.load_table(workspace_id=self.workspace_id, item_id=item_id, table_name=table_name, 
+        status_code = self.fc.load_table(workspace_id=self.workspace_id, lakehouse_id=lakehouse_id, table_name=table_name, 
                                          path_type="File", relative_path="Files/folder1/titanic.csv")
 
         self.assertEqual(status_code, 202)
 
-        table_list = self.fc.list_tables(workspace_id=self.workspace_id, item_id=item_id)
+        # Run on demand table maintenance
+        table_name_maintenance = "table20240515114529"
+
+        execution_data = {
+            "tableName": table_name_maintenance,
+            "optimizeSettings": {
+            "vOrder": True,
+            "zOrderBy": [
+                "tipAmount"
+            ]
+            },
+            "vacuumSettings": {
+            "retentionPeriod": "7:01:00:00"
+            }
+        }
+        
+        response = self.fc.run_on_demand_table_maintenance(workspace_id=workspace_id, lakehouse_id=lakehouse_id, 
+                                                           execution_data = execution_data,
+                                                           job_type = "TableMaintenance", wait_for_completion = True)
+        self.assertIn(response.status_code, [200, 202])
+
+        table_list = self.fc.list_tables(workspace_id=self.workspace_id, lakehouse_id=lakehouse_id)
         table_names = [table["name"] for table in table_list]
 
         self.assertIn(table_name, table_names)
@@ -163,6 +187,11 @@ class TestFabricClientCore(unittest.TestCase):
         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)
@@ -174,8 +203,8 @@ class TestFabricClientCore(unittest.TestCase):
         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.id)
-        # self.assertEqual(status_code, 200)
+        status_code = fc.delete_data_pipeline(workspace_id, dp_new.id)
+        self.assertEqual(status_code, 200)
 
     def test_eventstreams(self):
 
@@ -222,14 +251,24 @@ class TestFabricClientCore(unittest.TestCase):
         kqldb = fc.get_kql_database(workspace_id, kql_database_name="kqldatabase1")
         self.assertIsNotNone(kqldb.id)
         self.assertEqual(kqldb.display_name, "kqldatabase1")
-
+        
         kqldb2 = fc.update_kql_database(workspace_id, kqldb.id, display_name="kqldb2")
 
         kqldb = fc.get_kql_database(workspace_id, kql_database_id=kqldb.id)
         self.assertEqual(kqldb.display_name, "kqldb2")
         self.assertEqual(kqldb.id, kqldb2.id)
         
-        kqldb2 = fc.update_kql_database(workspace_id, kqldb.id, display_name="kqldatabase1")
+        # retry 3 times
+        i = 0
+        while i < 3:
+            try:
+                kqldb2 = fc.update_kql_database(workspace_id, kqldb.id, display_name="kqldatabase1")
+                break
+            except Exception as e:
+                sleep(10)
+                i += 1
+            
+        
 
         kqldb = fc.get_kql_database(workspace_id, kql_database_id=kqldb.id)
         self.assertEqual(kqldb.display_name, "kqldatabase1")
@@ -335,8 +374,12 @@ class TestFabricClientCore(unittest.TestCase):
         notebook_name = "notebook125"
 
         notebook_w_content = fc.get_notebook(workspace_id, notebook_name="HelloWorld")
-        definition = notebook_w_content.definition
 
+        definition = fc.get_notebook_definition(workspace_id, notebook_w_content.id)
+        
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
         notebook = fc.create_notebook(workspace_id, definition=definition, display_name=notebook_name)
         fc.update_notebook_definition(workspace_id, notebook.id, definition=definition)
         notebook = fc.get_notebook(workspace_id, notebook_id=notebook.id)
@@ -370,7 +413,13 @@ class TestFabricClientCore(unittest.TestCase):
         report_name = "report1234"
 
         report_w_content = fc.get_report(workspace_id, report_name="HelloWorldReport")
-        definition = report_w_content.definition
+
+        definition = fc.get_report_definition(workspace_id, report_w_content.id)
+        
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+
         report = fc.create_report(workspace_id, display_name=report_name, definition=definition)
         fc.update_report_definition(workspace_id, report.id, definition=definition)
         report = fc.get_report(workspace_id, report_id=report.id)
@@ -398,7 +447,12 @@ class TestFabricClientCore(unittest.TestCase):
         semantic_model_name = "semanticmodel1234"
 
         semantic_model_w_content = fc.get_semantic_model(workspace_id, semantic_model_name="Table")
-        definition = semantic_model_w_content.definition
+
+        definition = fc.get_semantic_model_definition(workspace_id, semantic_model_w_content.id)
+
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
         semantic_model = fc.create_semantic_model(workspace_id, display_name=semantic_model_name, definition=definition)
         fc.update_semantic_model_definition(workspace_id, semantic_model.id, definition=definition)
         semantic_model = fc.get_semantic_model(workspace_id, semantic_model_id=semantic_model.id)
@@ -428,7 +482,13 @@ class TestFabricClientCore(unittest.TestCase):
         spark_job_definition_name = f"sjd{datetime_str}"
 
         spark_job_definition_w_content = fc.get_spark_job_definition(workspace_id, spark_job_definition_name="helloworld")
-        definition = spark_job_definition_w_content.definition
+
+        definition = fc.get_spark_job_definition_definition(workspace_id, spark_job_definition_w_content.id)
+        
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+
         spark_job_definition = fc.create_spark_job_definition(workspace_id, display_name=spark_job_definition_name)
         fc.update_spark_job_definition_definition(workspace_id, spark_job_definition.id, definition=definition)
         spark_job_definition = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=spark_job_definition.id)

msfabricpysdkcore/tests/test_jobs.py

@@ -1,5 +1,9 @@
 import unittest
 from msfabricpysdkcore.coreapi import FabricClientCore
+from dotenv import load_dotenv
+
+load_dotenv()
+
 
 class TestFabricClientCore(unittest.TestCase):