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

msfabricpysdkcore/auth.py

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

msfabricpysdkcore/client.py

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

msfabricpysdkcore/coreapi.py

@@ -11,9 +11,9 @@ from msfabricpysdkcore.workspace import Workspace
 class FabricClientCore(FabricClient):
     """FabricClientCore class to interact with Fabric Core APIs"""
 
-    def __init__(self, tenant_id = None, client_id = None, client_secret = None) -> None:
+    def __init__(self, tenant_id = None, client_id = None, client_secret = None, silent=False) -> None:
         """Initialize FabricClientCore object"""
-        super().__init__(tenant_id, client_id, client_secret)
+        super().__init__(tenant_id, client_id, client_secret, silent=silent)
 
 
     def list_workspaces(self, continuationToken = None):
@@ -414,12 +414,20 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.get_environment(environment_id).get_staging_settings()
     
-    def update_staging_settings(self, workspace_id, environment_id, instance_pool, driver_cores, driver_memory, executor_cores, executor_memory,
-                                dynamic_executor_allocation, spark_properties, runtime_version):
-        """Update staging settings for an environment"""
-        ws = self.get_workspace_by_id(workspace_id)
-        return ws.get_environment(environment_id).update_staging_settings(instance_pool, driver_cores, driver_memory, executor_cores, executor_memory,
-                                dynamic_executor_allocation, spark_properties, runtime_version)
+    def update_staging_settings(self, workspace_id, environment_id,
+                                driver_cores = None, driver_memory = None, dynamic_executor_allocation = None,
+                                executor_cores = None, executor_memory = None, instance_pool = None,
+                                runtime_version = None, spark_properties = None):
+        
+        return self.get_environment(workspace_id, environment_id).update_staging_settings(driver_cores=driver_cores,
+                                                                            driver_memory=driver_memory,
+                                                                            dynamic_executor_allocation=dynamic_executor_allocation,
+                                                                            executor_cores=executor_cores,
+                                                                            executor_memory=executor_memory,
+                                                                            instance_pool=instance_pool,
+                                                                            runtime_version=runtime_version,
+                                                                            spark_properties=spark_properties)
+
     
     # environmentSparkLibraries
 
@@ -433,10 +441,10 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.get_environment(environment_id).get_staging_libraries()
     
-    def update_staging_library(self, workspace_id, environment_id):
+    def upload_staging_library(self, workspace_id, environment_id, file_path):
         """Update staging libraries for an environment"""
         ws = self.get_workspace_by_id(workspace_id)
-        return ws.get_environment(environment_id).update_staging_libraries()
+        return ws.get_environment(environment_id).upload_staging_library(file_path=file_path)
     
     def publish_environment(self, workspace_id, environment_id):
         """Publish an environment"""
@@ -453,6 +461,33 @@ class FabricClientCore(FabricClient):
         ws = self.get_workspace_by_id(workspace_id)
         return ws.get_environment(environment_id).cancel_publish()
 
+    # eventhouses
+
+    def list_eventhouses(self, workspace_id):
+        """List eventhouses in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_eventhouses()
+    
+    def create_eventhouse(self, workspace_id, display_name, description = None):
+        """Create an eventhouse in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.create_eventhouse(display_name = display_name, description = description)
+    
+    def get_eventhouse(self, workspace_id, eventhouse_id = None, eventhouse_name = None):
+        """Get an eventhouse from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.get_eventhouse(eventhouse_id = eventhouse_id, eventhouse_name = eventhouse_name)
+    
+    def delete_eventhouse(self, workspace_id, eventhouse_id):
+        """Delete an eventhouse from a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.delete_eventhouse(eventhouse_id)
+    
+    def update_eventhouse(self, workspace_id, eventhouse_id, display_name = None, description = None):
+        """Update an eventhouse in a workspace"""
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.update_eventhouse(eventhouse_id, display_name = display_name, description = description)
+
     # eventstreams
 
     def list_eventstreams(self, workspace_id):
@@ -486,6 +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"""

msfabricpysdkcore/environment.py

@@ -8,23 +8,13 @@ from msfabricpysdkcore.long_running_operation import check_long_running_operatio
 class Environment(Item):
     """Class to represent a item in Microsoft Fabric"""
 
-    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description="", 
-                 sparkcompute = None, staging_sparkcompute = None, libraries = None, staging_libraries = None):
+    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, definition=None, description=""):
         super().__init__(id, display_name, type, workspace_id, auth, properties, definition, description)
 
-        self.sparkcompute = sparkcompute
-        self.staging_sparkcompute = staging_sparkcompute
-        self.libraries = libraries
-        self.staging_libraries = staging_libraries
-
     def from_dict(item_dict, auth):
         return Environment(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
-            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), 
-            sparkcompute=item_dict.get('sparkcompute', None),
-            staging_sparkcompute=item_dict.get('staging_sparkcompute', None),
-            libraries=item_dict.get('libraries', None),
-            staging_libraries=item_dict.get('staging_libraries', None),
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""),
             auth=auth)
 
     # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/sparkcompute
@@ -39,14 +29,10 @@ class Environment(Item):
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error getting published settings: {response.text}")
+                raise Exception(f"Error getting published settings: {response.status_code}, {response.text}")
             break
 
         resp_json = json.loads(response.text)        
-        self.sparkcompute = resp_json
         return resp_json
     
     # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/sparkcompute
@@ -62,30 +48,38 @@ class Environment(Item):
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error getting staging settings: {response.text}")
+                raise Exception(f"Error getting staging settings: {response.status_code}, {response.text}")
             break
 
         resp_json = json.loads(response.text)        
-        self.staging_sparkcompute = resp_json
         return resp_json
 
-    def update_staging_settings(self, instance_pool, driver_cores, driver_memory, executor_cores, executor_memory,
-                                dynamic_executor_allocation, spark_properties, runtime_version):
+
+    def update_staging_settings(self,
+                                driver_cores = None, driver_memory = None, dynamic_executor_allocation = None,
+                                executor_cores = None, executor_memory = None, instance_pool = None,
+                                runtime_version = None, spark_properties = None):
         """Update the staging settings of the environment"""
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/sparkcompute"
-        body = {
-            "instancePool": instance_pool,
-            "driverCores": driver_cores,
-            "driverMemory": driver_memory,
-            "executorCores": executor_cores,
-            "executorMemory": executor_memory,
-            "dynamicExecutorAllocation": dynamic_executor_allocation,
-            "sparkProperties": spark_properties,
-            "runtimeVersion": runtime_version
-        }
+        body = {}
+        if driver_cores is not None:
+            body['driverCores'] = driver_cores
+        if driver_memory is not None:
+            body['driverMemory'] = driver_memory
+        if dynamic_executor_allocation is not None:
+            body['dynamicExecutorAllocation'] = dynamic_executor_allocation
+        if executor_cores is not None:
+            body['executorCores'] = executor_cores
+        if executor_memory is not None:
+            body['executorMemory'] = executor_memory
+        if instance_pool is not None:
+            body['instancePool'] = instance_pool
+        if runtime_version is not None:
+            body['runtimeVersion'] = runtime_version
+        if spark_properties is not None:
+            body['sparkProperties'] = spark_properties
+
+        
         for _ in range(10):
             response = requests.patch(url=url, headers=self.auth.get_headers(), json=body)
             if response.status_code == 429:
@@ -93,14 +87,10 @@ class Environment(Item):
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error updating staging settings: {response.text}")
+                raise Exception(f"Error updating staging settings: {response.status_code}, {response.text}")
             break
 
-        self.staging_sparkcompute = body
-        return body
+        return json.loads(response.text)
 
 #  GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/libraries
 
@@ -115,14 +105,10 @@ class Environment(Item):
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error getting published libraries: {response.text}")
+                raise Exception(f"Error getting published libraries: {response.status_code}, {response.text}")
             break
 
         resp_json = json.loads(response.text)
-        self.libraries = resp_json
         return resp_json
     
 # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries
@@ -138,19 +124,29 @@ class Environment(Item):
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error getting staging libraries: {response.text}")
+                raise Exception(f"Error getting staging libraries: {response.status_code}, {response.text}")
             break
 
         resp_json = json.loads(response.text)
-        self.staging_libraries = resp_json
         return resp_json
     
 
-    def update_staging_libraries(self):
-        raise NotImplementedError("This method is not implemented yet because the REST API is not complete")
+    def upload_staging_library(self, file_path):
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries
+        raise NotImplementedError("Not implemented yet")
+        # url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/libraries"
+
+        # for _ in range(10):
+        #     response = requests.post(url=url, files={'file': file_path}, headers=self.auth.get_headers())
+        #     if response.status_code == 429:
+        #         print("Too many requests, waiting 10 seconds")
+        #         sleep(10)
+        #         continue
+        #     if response.status_code not in (200, 429):
+        #         raise Exception(f"Error uploading staging libraries: {response.status_code}, {response.text}")
+        #     break
+
+        # return json.loads(response.text)
     
 # DELETE https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries?libraryToDelete={libraryToDelete}
 
@@ -165,10 +161,7 @@ class Environment(Item):
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error deleting staging libraries: {response.text}")
+                raise Exception(f"Error deleting staging libraries: {response.status_code}, {response.text}")
             break
 
         return response.text
@@ -189,10 +182,7 @@ class Environment(Item):
                 publish_info = check_long_running_operation(response.headers, self.auth)
                 return publish_info
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error publishing staging: {response.text}")
+                raise Exception(f"Error publishing staging: {response.status_code}, {response.text}")
             break
 
         resp_dict = json.loads(response.text)
@@ -212,10 +202,7 @@ class Environment(Item):
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error canceling publishing: {response.text}")
+                raise Exception(f"Error canceling publishing: {response.status_code}, {response.text}")
             break
 
         resp_dict = json.loads(response.text)

msfabricpysdkcore/item.py

@@ -58,10 +58,7 @@ class Item:
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                print(self)
-                raise Exception(f"Error deleting item: {response.text}")
+                raise Exception(f"Error deleting item: {response.status_code}, {response.text}")
             break
 
         return response.status_code

msfabricpysdkcore/otheritems.py

@@ -3,6 +3,38 @@ from time import sleep
 import requests
 from msfabricpysdkcore.item import Item
 
+
+class Eventhouse(Item):
+    """Class to represent a eventhouse in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, auth, properties = None, description=""):
+        super().__init__(id = id, display_name=display_name, type=type, 
+                         workspace_id=workspace_id, auth=auth, properties=properties, 
+                         description=description)
+        
+    def from_dict(item_dict, auth):
+        if "displayName" not in item_dict:
+            item_dict["displayName"] = item_dict["display_name"]
+        if "workspaceId" not in item_dict:
+            item_dict["workspaceId"] = item_dict["workspace_id"]
+
+        return Eventhouse(id=item_dict['id'], display_name=item_dict['displayName'], 
+                          type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+                          properties=item_dict.get('properties', None),
+                          description=item_dict.get('description', ""), auth=auth)
+
+    def create_kql_database(self, display_name = None, description= None):
+        from msfabricpysdkcore.coreapi import FabricClientCore
+        """Method to create a kql database in the eventhouse"""
+        creation_payload = {"databaseType" : "ReadWrite",
+                            "parentEventhouseItemId" : self.id}
+        
+        fcc = FabricClientCore(silent=True)
+
+        return fcc.create_kql_database(workspace_id = self.workspace_id,
+                                       display_name = display_name, description = description,
+                                       creation_payload= creation_payload)
+
 class SparkJobDefinition(Item):
     """Class to represent a spark job definition in Microsoft Fabric"""
      

msfabricpysdkcore/tests/test_datapipelines.py

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

msfabricpysdkcore/tests/test_environments.py

@@ -10,39 +10,56 @@ 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):
+    def test_environments_crudl(self):
         fc = self.fc
-        workspace_id = self.workspace_id
-
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
         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)
 
-        
+        env_name = "env" + datetime_str
+        environment1 = fc.create_environment(workspace_id, display_name=env_name)
+        self.assertEqual(environment1.display_name, env_name)
+
+        environments = fc.list_environments(workspace_id)
+        environment_names = [env.display_name for env in environments]
+        self.assertGreater(len(environments), 0)
+        self.assertIn(env_name, environment_names)
+
+        env = fc.get_environment(workspace_id, environment_name=env_name)
+        self.assertIsNotNone(env.id)
+        self.assertEqual(env.display_name, env_name)
+        new_name = env_name + "2"
+        env2 = fc.update_environment(workspace_id, env.id, display_name=new_name)
+
+        env = fc.get_environment(workspace_id, environment_id=env.id)
+        self.assertEqual(env.display_name, new_name)
+        self.assertEqual(env.id, env2.id)
+
+        status_code = fc.delete_environment(workspace_id, env.id)
+        self.assertEqual(status_code, 200)
+
+    def test_environment_details(self):
+        fc = FabricClientCore()
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        environment_id = 'fae6d1a7-d671-4091-89b1-f42626deb56f'
+        published_settings = fc.get_published_settings(workspace_id=workspace_id, environment_id=environment_id)
+        self.assertIsNotNone(published_settings)
+        self.assertIn("instancePool", published_settings)
+        self.assertIn("dynamicExecutorAllocation", published_settings)
+        staging_settings = fc.get_staging_settings(workspace_id=workspace_id, environment_id=environment_id)
+        self.assertIsNotNone(staging_settings)
+        self.assertIn("instancePool", staging_settings)
+        self.assertIn("dynamicExecutorAllocation", staging_settings)
+        if staging_settings["driverCores"] == 8:
+            driver_cores = 4
+        else:
+            driver_cores = 8
+        updated_settings = fc.update_staging_settings(workspace_id=workspace_id, environment_id=environment_id, driver_cores=driver_cores)
+        self.assertIn("instancePool", updated_settings)
+        self.assertIn("dynamicExecutorAllocation", updated_settings)
+        self.assertEqual(updated_settings["driverCores"], driver_cores)
+        updated_settings = fc.get_staging_settings(workspace_id=workspace_id, environment_id=environment_id)
+        self.assertIn("instancePool", updated_settings)
+        self.assertIn("dynamicExecutorAllocation", updated_settings)
+        self.assertEqual(updated_settings["driverCores"], driver_cores)

msfabricpysdkcore/tests/test_evenstreams.py

@@ -0,0 +1,44 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+
+    def test_eventstreams(self):
+
+            fc = self.fc
+            workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+
+            datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+            es_name = "es" + datetime_str
+
+            eventstream = fc.create_eventstream(workspace_id, display_name=es_name)
+            self.assertEqual(eventstream.display_name, es_name)
+
+            eventstreams = fc.list_eventstreams(workspace_id)
+            eventstream_names = [es.display_name for es in eventstreams]
+            self.assertGreater(len(eventstreams), 0)
+            self.assertIn(es_name, eventstream_names)
+
+            
+            es = fc.get_eventstream(workspace_id, eventstream_name=es_name)
+            self.assertIsNotNone(es.id)
+            self.assertEqual(es.display_name, es_name)
+
+            es2 = fc.update_eventstream(workspace_id, es.id, display_name=f"{es_name}2")
+
+            es = fc.get_eventstream(workspace_id, eventstream_id=es.id)
+            self.assertEqual(es.display_name, f"{es_name}2")
+            self.assertEqual(es.id, es2.id)
+
+            status_code = fc.delete_eventstream(workspace_id, es.id)
+            self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_items_incl_lakehouse.py

@@ -78,8 +78,7 @@ class TestFabricClientCore(unittest.TestCase):
 
         fc = self.fc
 
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         list_dashboards = fc.list_dashboards(workspace_id)
         dashboard_names = [dashboard.display_name for dashboard in list_dashboards]
@@ -144,8 +143,7 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertIn(table_name, table_names)
 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         lakehouse = fc.create_lakehouse(workspace_id=workspace_id, display_name="lakehouse2")
         self.assertIsNotNone(lakehouse.id)
@@ -171,116 +169,37 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertEqual(status_code, 200)
 
 
-    def test_data_pipelines(self):
-
-        fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
-        
-        dps = fc.list_data_pipelines(workspace_id)
-        dp_names = [dp.display_name for dp in dps]
-        self.assertGreater(len(dps), 0)
-        self.assertIn("pipeline1", dp_names)
-
-        dp = fc.get_data_pipeline(workspace_id, data_pipeline_name="pipeline1")
-        self.assertIsNotNone(dp.id)
-        self.assertIsNotNone(dp.definition)
-        self.assertEqual(dp.display_name, "pipeline1")
-
-        dp_new = fc.create_data_pipeline(workspace_id, display_name="pipeline_new", description="asda")
-        dp_new.update_definition(dp.definition)
-        
-        self.assertEqual(dp_new.display_name, "pipeline_new")
-
-        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline2")
-
-        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
-        self.assertEqual(dp.display_name, "pipeline2")
-        self.assertEqual(dp.id, dp2.id)
-
-        dp2 = fc.update_data_pipeline(workspace_id, dp.id, display_name="pipeline1")
-
-        dp = fc.get_data_pipeline(workspace_id, data_pipeline_id=dp.id)
-        self.assertEqual(dp.display_name, "pipeline1")
-        self.assertEqual(dp.id, dp2.id)
-        status_code = fc.delete_data_pipeline(workspace_id, dp_new.id)
-        self.assertEqual(status_code, 200)
-
-    def test_eventstreams(self):
-
+    def test_eventhouses(self):
+            
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
-
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        es_name = "es" + datetime_str
-
-        eventstream = fc.create_eventstream(workspace_id, display_name=es_name)
-        self.assertEqual(eventstream.display_name, es_name)
-
-        eventstreams = fc.list_eventstreams(workspace_id)
-        eventstream_names = [es.display_name for es in eventstreams]
-        self.assertGreater(len(eventstreams), 0)
-        self.assertIn(es_name, eventstream_names)
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
+        eventhouse1 = fc.create_eventhouse(workspace_id, display_name="eventhouse1")
+        self.assertEqual(eventhouse1.display_name, "eventhouse1")
         
-        es = fc.get_eventstream(workspace_id, eventstream_name=es_name)
-        self.assertIsNotNone(es.id)
-        self.assertEqual(es.display_name, es_name)
-
-        es2 = fc.update_eventstream(workspace_id, es.id, display_name=f"{es_name}2")
-
-        es = fc.get_eventstream(workspace_id, eventstream_id=es.id)
-        self.assertEqual(es.display_name, f"{es_name}2")
-        self.assertEqual(es.id, es2.id)
-
-        status_code = fc.delete_eventstream(workspace_id, es.id)
-        self.assertEqual(status_code, 200)
-
-    def test_kql_database(self):
+        eventhouses = fc.list_eventhouses(workspace_id)
+        eventhouse_names = [eh.display_name for eh in eventhouses]
+        self.assertGreater(len(eventhouses), 0)
+        self.assertIn("eventhouse1", eventhouse_names)
 
-        fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        eh = fc.get_eventhouse(workspace_id, eventhouse_name="eventhouse1")
+        self.assertIsNotNone(eh.id)
+        self.assertEqual(eh.display_name, "eventhouse1")
 
-        kql_databases = fc.list_kql_databases(workspace_id)
-        kql_database_names = [kqldb.display_name for kqldb in kql_databases]
-        self.assertGreater(len(kql_databases), 0)
-        self.assertIn("kqldatabase1", kql_database_names)
+        eh2 = fc.update_eventhouse(workspace_id, eh.id, display_name="eventhouse2")
 
-        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")
+        eh = fc.get_eventhouse(workspace_id, eventhouse_id=eh.id)
+        self.assertEqual(eh.display_name, "eventhouse2")
+        self.assertEqual(eh.id, eh2.id)
 
-        kqldb = fc.get_kql_database(workspace_id, kql_database_id=kqldb.id)
-        self.assertEqual(kqldb.display_name, "kqldb2")
-        self.assertEqual(kqldb.id, kqldb2.id)
-        
-        # 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
-            
-        
+        status_code = fc.delete_eventhouse(workspace_id, eh.id)
+        self.assertEqual(status_code, 200)
 
-        kqldb = fc.get_kql_database(workspace_id, kql_database_id=kqldb.id)
-        self.assertEqual(kqldb.display_name, "kqldatabase1")
-        self.assertEqual(kqldb.id, kqldb2.id)
-        # status_code = fc.delete_kql_database(workspace_id, kqldb.id)
-        # self.assertEqual(status_code, 200)
 
     def test_kql_querysets(self):
 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         kql_queryset_name = "kqlqueryset1"
 
@@ -312,8 +231,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_ml_experiments(self):
             
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         ml_experiment = fc.create_ml_experiment(workspace_id, display_name="mlexperiment1")
         self.assertEqual(ml_experiment.display_name, "mlexperiment1")
@@ -339,8 +257,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_ml_models(self):
 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         model_name = "mlm" + datetime_str
 
@@ -368,8 +285,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_notebooks(self):
             
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         notebook_name = "notebook125"
 
@@ -407,8 +323,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_reports(self):
                 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         report_name = "report1234"
 
@@ -441,8 +356,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_semantic_models(self):
                     
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         semantic_model_name = "semanticmodel1234"
 
@@ -475,8 +389,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_spark_job_definitions(self):
         
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         spark_job_definition_name = f"sjd{datetime_str}"
@@ -514,8 +427,7 @@ class TestFabricClientCore(unittest.TestCase):
     def test_warehouses(self):
 
         fc = self.fc
-        workspace = fc.get_workspace_by_name("testitems")
-        workspace_id = workspace.id
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
 
         datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
         warehouse1 = f"wh{datetime_str}"

msfabricpysdkcore/tests/test_kqldatabases.py

@@ -0,0 +1,48 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+    
+    def test_kql_database(self):
+
+        fc = self.fc
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        evenhouse_id = "14822d45-5460-4efa-9b30-8628510a9197"
+
+        creation_payload = {"databaseType" : "ReadWrite",
+                            "parentEventhouseItemId" : evenhouse_id}
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        kqldb_name = "kql" + datetime_str
+        kqldb = fc.create_kql_database(workspace_id = workspace_id, display_name=kqldb_name,
+                                    creation_payload=creation_payload)
+        self.assertEqual(kqldb.display_name, kqldb_name)
+
+        kql_databases = fc.list_kql_databases(workspace_id)
+        kql_database_names = [kqldb.display_name for kqldb in kql_databases]
+        self.assertGreater(len(kql_databases), 0)
+        self.assertIn(kqldb_name, kql_database_names)
+
+        kqldb = fc.get_kql_database(workspace_id, kql_database_name=kqldb_name)
+        self.assertIsNotNone(kqldb.id)
+        self.assertEqual(kqldb.display_name, kqldb_name)
+        
+        new_name = kqldb_name+"2"
+        kqldb2 = fc.update_kql_database(workspace_id, kqldb.id, display_name=new_name)
+
+        kqldb = fc.get_kql_database(workspace_id, kql_database_id=kqldb.id)
+        self.assertEqual(kqldb.display_name, new_name)
+        self.assertEqual(kqldb.id, kqldb2.id)
+        
+        status_code = fc.delete_kql_database(workspace_id, kqldb.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_workspaces_capacities.py

@@ -105,12 +105,12 @@ class TestFabricClientCore(unittest.TestCase):
 
 #    def test_update_workspace(self):
         ws_updated = self.fc.update_workspace(workspace_id=ws.id, 
-                                              display_name="newname8912389u1293", 
+                                              display_name="newn912389u8293", 
                                               description="new description")
-        self.assertEqual(ws_updated.display_name, "newname8912389u1293")
+        self.assertEqual(ws_updated.display_name, "newn912389u8293")
         self.assertEqual(ws_updated.description, "new description")
         ws = self.fc.get_workspace_by_id(id = ws.id)
-        self.assertEqual(ws.display_name, "newname8912389u1293")
+        self.assertEqual(ws.display_name, "newn912389u8293")
         self.assertEqual(ws.description, "new description")
 
 #    def test_unassign_from_capacity(self):
@@ -121,7 +121,7 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertEqual(ws.capacity_id, None)
 
 #    def test_delete_workspace(self):
-        result_status = self.fc.delete_workspace(display_name="newname8912389u1293")
+        result_status = self.fc.delete_workspace(display_name="newn912389u8293")
         self.assertEqual(result_status, 200)
 
     def test_list_capacities(self):

msfabricpysdkcore/workspace.py

@@ -6,7 +6,7 @@ from msfabricpysdkcore.lakehouse import Lakehouse
 from msfabricpysdkcore.environment import Environment
 from msfabricpysdkcore.long_running_operation import check_long_running_operation
 from msfabricpysdkcore.otheritems import DataPipeline, Eventstream, KQLDatabase, KQLQueryset, SparkJobDefinition
-from msfabricpysdkcore.otheritems import MLExperiment, MLModel, Notebook, Report, SemanticModel, Warehouse
+from msfabricpysdkcore.otheritems import Eventhouse, MLExperiment, MLModel, Notebook, Report, SemanticModel, Warehouse
 from msfabricpysdkcore.spark_custom_pool import SparkCustomPool
 
 
@@ -140,9 +140,7 @@ class Workspace:
                 sleep(10)
                 continue
             if response.status_code not in (200, 429):
-                print(response.status_code)
-                print(response.text)
-                raise Exception(f"Error updating workspace: {response.text}")
+                raise Exception(f"Error updating workspace: {response.status_code}, {response.text}")
             break
 
         assert response.status_code == 200
@@ -229,6 +227,8 @@ class Workspace:
             return self.get_data_pipeline(item_dict["id"])
         if item_dict["type"] == "Eventstream":
             return self.get_eventstream(item_dict["id"])
+        if item_dict["type"] == "Eventhouse":
+            return self.get_eventhouse(item_dict["id"])
         if item_dict["type"] == "KQLDatabase":
             return self.get_kql_database(item_dict["id"])
         if item_dict["type"] == "KQLQueryset":
@@ -255,7 +255,7 @@ class Workspace:
         item_obj = Item.from_dict(item_dict, auth=self.auth)
         return item_obj
 
-    def create_item(self, display_name, type, definition = None, description = None):
+    def create_item(self, display_name, type, definition = None, description = None, **kwargs):
         """Create an item in a workspace"""
 
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/items"
@@ -271,7 +271,9 @@ class Workspace:
 
         if type in ["dataPipelines",
                     "environments",
-                    "eventstreams", 
+                    "eventhouses",
+                    "eventstreams",
+                    "kqlDatabases",
                     "lakehouses",
                     "mlExperiments", 
                     "mlModels", 
@@ -281,6 +283,11 @@ class Workspace:
                     "sparkJobDefinitions", 
                     "warehouses"]:
             
+            if type == "kqlDatabases":
+                if "creation_payload" not in kwargs:
+                    raise Exception("creation_payload is required for KQLDatabase")
+                body["creationPayload"] = kwargs["creation_payload"]
+            
             url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/{type}"
             body.pop('type')
 
@@ -307,7 +314,9 @@ class Workspace:
 
             type_mapping = {"dataPipelines": "DataPipeline",
                             "environments": "Environment",
+                            "eventhouses": "Eventhouse",
                             "eventstreams": "Eventstream",
+                            "kqlDatabases": "KQLDatabase",
                             "lakehouses": "Lakehouse", 
                             "mlExperiments": "MLExperiment",
                             "mlModels": "MLModel", 
@@ -693,7 +702,7 @@ class Workspace:
 
     def list_data_pipelines(self, with_properties = False):
         """List data pipelines in a workspace"""
-        return self.list_items(with_properties = with_properties, type="dataPipelines")
+        return self.list_items(type="dataPipelines", with_properties=with_properties)
     
     def get_data_pipeline(self, data_pipeline_id = None, data_pipeline_name = None):
         """Get a data pipeline from a workspace"""
@@ -721,7 +730,7 @@ class Workspace:
 
     def list_environments(self, with_properties = False):
         """List environments in a workspace"""
-        return self.list_items(type="environments", with_properties=with_properties)
+        return self.list_items(type="environments", with_properties = with_properties)
     
     def create_environment(self, display_name, description = None):
         """Create an environment in a workspace"""
@@ -741,10 +750,6 @@ class Workspace:
 
         item_dict = self.get_item_internal(url)
         env = Environment.from_dict(item_dict, auth=self.auth)
-        #env.get_staging_settings()
-        #env.get_published_settings()
-        #env.get_staging_libraries()
-        #env.get_published_libraries()
         return env
     
     def delete_environment(self, environment_id):
@@ -765,13 +770,18 @@ class Workspace:
     def get_staging_settings(self, environment_id):
         return self.get_environment(environment_id).get_staging_settings()
     
-    def update_staging_settings(self, environment_id, instance_pool, driver_cores, driver_memory, executor_cores, executor_memory,
-                                dynamic_executor_allocation, spark_properties, runtime_version):
-        return self.get_environment(environment_id).update_staging_settings(instance_pool, driver_cores, 
-                                                                            driver_memory, executor_cores, 
-                                                                            executor_memory, 
-                                                                            dynamic_executor_allocation,
-                                                                            spark_properties, runtime_version)
+    def update_staging_settings(self, 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(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)
 
     # environment spark libraries
 
@@ -781,8 +791,8 @@ class Workspace:
     def get_staging_libraries(self, environment_id):
         return self.get_environment(environment_id).get_staging_libraries()
     
-    def update_staging_library(self, environment_id):
-        return self.get_environment(environment_id).update_staging_libraries()
+    def upload_staging_library(self, environment_id, file_path):
+        return self.get_environment(environment_id).upload_staging_library(file_path)
     
     def publish_environment(self, environment_id):
         return self.get_environment(environment_id).publish_environment()
@@ -793,11 +803,45 @@ class Workspace:
     def cancel_publish(self, environment_id):
         return self.get_environment(environment_id).cancel_publish()
     
+    # eventhouses
+    def list_eventhouses(self, with_properties = False):
+        """List eventhouses in a workspace"""
+        return self.list_items(type="eventhouses", with_properties=with_properties)
+    
+    def create_eventhouse(self, display_name, description = None):
+        """Create an eventhouse in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "eventhouses",
+                                definition = None,
+                                description = description)
+    
+    def get_eventhouse(self, eventhouse_id = None, eventhouse_name = None):
+        """Get an eventhouse from a workspace"""
+        if eventhouse_id is None and eventhouse_name is not None:
+            return self.get_item_by_name(eventhouse_name, "Eventhouse")
+        elif eventhouse_id is None:
+            raise Exception("eventhouse_id or the eventhouse_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/eventhouses/{eventhouse_id}"
+
+        item_dict = self.get_item_internal(url)
+        return Eventhouse.from_dict(item_dict, auth=self.auth)
+    
+    def delete_eventhouse(self, eventhouse_id):
+        """Delete an eventhouse from a workspace"""
+        return self.get_item(item_id=eventhouse_id).delete(type="eventhouses")
+    
+    def update_eventhouse(self, eventhouse_id, display_name = None, description = None):
+        """Update an eventhouse in a workspace"""
+        return self.get_item(item_id=eventhouse_id).update(display_name=display_name,
+                                                            description=description,
+                                                            type="eventhouses")
+
     # eventstreams
 
-    def list_eventstreams(self):
+    def list_eventstreams(self, with_properties = False):
         """List eventstreams in a workspace"""
-        return self.list_items(type="eventstreams")
+        return self.list_items(type="eventstreams", with_properties=with_properties)
     
     def create_eventstream(self, display_name, description = None):
         """Create an eventstream in a workspace"""
@@ -830,9 +874,16 @@ class Workspace:
     
     # kqlDatabases
 
-    def list_kql_databases(self):
+    def list_kql_databases(self, with_properties = False):
         """List kql databases in a workspace"""
-        return self.list_items(type="kqlDatabases")
+        return self.list_items(type="kqlDatabases", with_properties = with_properties)
+    
+    def create_kql_database(self, creation_payload, display_name, description = None, ):
+        """Create a kql database in a workspace"""
+        return self.create_item(display_name = display_name,
+                                type = "kqlDatabases",
+                                description = description,
+                                creation_payload = creation_payload)
     
     def get_kql_database(self, kql_database_id = None, kql_database_name = None):
         """Get a kql database from a workspace"""
@@ -859,9 +910,9 @@ class Workspace:
 
     # kqlQuerysets
 
-    def list_kql_querysets(self):
+    def list_kql_querysets(self, with_properties = False):
         """List kql querysets in a workspace"""
-        return self.list_items(type="kqlQuerysets")
+        return self.list_items(type="kqlQuerysets", with_properties = with_properties)
 
     def get_kql_queryset(self, kql_queryset_id = None, kql_queryset_name = None):
         """Get a kql queryset from a workspace"""
@@ -925,9 +976,9 @@ class Workspace:
     
     # mlExperiments
 
-    def list_ml_experiments(self):
+    def list_ml_experiments(self, with_properties = False):
         """List ml experiments in a workspace"""
-        return self.list_items(type="mlExperiments")
+        return self.list_items(type="mlExperiments", with_properties = with_properties)
     
     def create_ml_experiment(self, display_name, description = None):
         """Create an ml experiment in a workspace"""
@@ -960,9 +1011,9 @@ class Workspace:
     
     # mlModels
 
-    def list_ml_models(self):
+    def list_ml_models(self, with_properties = False):
         """List ml models in a workspace"""
-        return self.list_items(type="mlModels")
+        return self.list_items(type="mlModels", with_properties = with_properties)
 
     def create_ml_model(self, display_name, description = None):
         """Create an ml model in a workspace"""

{msfabricpysdkcore-0.0.10.dist-info → msfabricpysdkcore-0.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: msfabricpysdkcore
-Version: 0.0.10
+Version: 0.0.11
 Summary: A Python SDK for Microsoft Fabric
 Author: Andreas Rederer
 Project-URL: Homepage, https://github.com/DaSenf1860/ms-fabric-sdk-core

{msfabricpysdkcore-0.0.10.dist-info → msfabricpysdkcore-0.0.11.dist-info}/RECORD

@@ -2,34 +2,37 @@ msfabricpysdkcore/__init__.py,sha256=nh8-lxdMBWYSbQpbRxWkn3ZRpGipmQplTudjskN2l88
 msfabricpysdkcore/admin_item.py,sha256=OGVfMMqAKy80Ukp8TJnpXoRq8WbWX7Qq1hz7tmfiUBU,4020
 msfabricpysdkcore/admin_workspace.py,sha256=RctVsXZ57ppiybua69BW_yVpUbrGic6fYOjFPZFPAzA,4862
 msfabricpysdkcore/adminapi.py,sha256=uithaYq_HWDU-9Et_EFBNQfrjcjnI-NW6OCmWoAsZxk,25649
-msfabricpysdkcore/auth.py,sha256=zOU3viJwwYZMefS2yWJZ_LaOePJY8mRRrACIlp0yRkw,2430
+msfabricpysdkcore/auth.py,sha256=v5YkI4jA6T7lv5rjqTK-GEPx2ATDPKQ1LVcaCg98oLM,2562
 msfabricpysdkcore/capacity.py,sha256=Q_2-XrZtdf9F67fY0qU3D0ocEOGQq4KtIXAv9dXjQhI,1761
-msfabricpysdkcore/client.py,sha256=W8J5VR19e6N__ycLvFALo-IHWDznGr5s7YD6e9jC4bE,1197
-msfabricpysdkcore/coreapi.py,sha256=TKnxpki4gKmySF4LP8qwveZcZXvbeVWkt0lTcg8hXDI,46168
+msfabricpysdkcore/client.py,sha256=yOZ1CW2ilL8a7J_SRNa-EQbG8xNlJKW3ygniIrsADsw,1300
+msfabricpysdkcore/coreapi.py,sha256=Mjs_YoCISmQXhG7mO4KDWd-4GKZJ7M4hsgis3cee-no,48590
 msfabricpysdkcore/deployment_pipeline.py,sha256=RFI86rtG-eTpV-_tVl3cXtcTl9ekRvOI5fLsXo9CMVA,9739
 msfabricpysdkcore/domain.py,sha256=i8jMJEutDRL5XuQ69woCVQEzLS_lm9uUxl4Kp3xtxHc,14722
-msfabricpysdkcore/environment.py,sha256=nvBNvmgqQMGWRUhZ9oX0z5Xf8IfPqyRr7ufgsiYt6dY,10271
-msfabricpysdkcore/item.py,sha256=Ac24M--C5N5Q0Rny70DVMctRSd8kG3qI-RcvlIWCNrw,11516
+msfabricpysdkcore/environment.py,sha256=ENgy7URz_gJ4E5-OH355QF6vqawBoHjHMbjnoEJfGwM,10072
+msfabricpysdkcore/item.py,sha256=HIr32drqNtlIKKXkXCcWI2H_TZMDalCxvikTyDHNprA,11428
 msfabricpysdkcore/job_instance.py,sha256=C9kKsV-BIJSeU6DfoTnLlg4DLp-8RYpovs0A-mKwi4o,2745
 msfabricpysdkcore/lakehouse.py,sha256=nv95SBz_jsssT5dEw622WqtDHUyh5bFFsVTwiqo8s-c,6055
 msfabricpysdkcore/long_running_operation.py,sha256=gcGVTgA0NToPItrl42Zy1M2eVZtx-vx-SdUryNAm53E,2731
 msfabricpysdkcore/onelakeshortcut.py,sha256=EYZfP-rl60HdCqJD1O1NXrQTgrYTIw-EWisF4hs4bTU,2102
-msfabricpysdkcore/otheritems.py,sha256=6A9PC5ObENeTKE3Pc8klYRxSrx-TwQUMq_P1eLFPF2A,9314
+msfabricpysdkcore/otheritems.py,sha256=TsRZHcqYHw1t6tqKMa3yC0LF9uBj3a1Uzc_lLKZ6LVY,10967
 msfabricpysdkcore/spark_custom_pool.py,sha256=2H-GkGcDsiKxSpXFSf8Zi7xJI5_krb_8sGdF5vDjEy8,4635
-msfabricpysdkcore/workspace.py,sha256=4ZRyRm5pm9aKedURiGhRsh-gm63NxNxmvjDGg0cA0go,61716
+msfabricpysdkcore/workspace.py,sha256=IeT0W0vitc_jH6d9OhRd-SjgDsKYFayQ_g8m9DD0pts,65050
 msfabricpysdkcore/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 msfabricpysdkcore/tests/test_admin_apis.py,sha256=HTXt72p9FiEf3q9SXyq9aImR6zZo_xIREfB0xPaYazU,2586
+msfabricpysdkcore/tests/test_datapipelines.py,sha256=rIeZfv-MGewYYscb36jmjL8DLZ3Z1dJWv09foR9z_y8,1812
 msfabricpysdkcore/tests/test_deployment_pipeline.py,sha256=XmqKZXbwBY3P-4O_ce9Wupz9qXHaKxWERwS-RZt38Bs,2024
 msfabricpysdkcore/tests/test_domains.py,sha256=KFGQyl0G2v4JjX_xYHY-vPSjYxeLEx3AcXMdiRZzClc,4620
-msfabricpysdkcore/tests/test_environments.py,sha256=kuEXk9uKOYOQ5YWrlk6hWQWHm176zFP0AoDz3EOV6Oo,1592
+msfabricpysdkcore/tests/test_environments.py,sha256=zSIMhkQscMB7doJEQRBRMvAEBxO1Kl1N85MKXP3yeYI,3120
+msfabricpysdkcore/tests/test_evenstreams.py,sha256=i6hhsOnDJ-BN7kStg7gQhZVPMVaB73K7KJez6pEKlv0,1628
 msfabricpysdkcore/tests/test_git.py,sha256=IZfWggCyZtHpUbYyacNTyIRfy6rofz-fBEmco_8gMZ4,2415
-msfabricpysdkcore/tests/test_items_incl_lakehouse.py,sha256=5fJZf3qqx9yyPsZ-lv5iaTJWnEuJHL39YdFos4ThEoA,23303
+msfabricpysdkcore/tests/test_items_incl_lakehouse.py,sha256=6to6S9ZcRT6Ain7U3LxCpjkKmL7-Uk3VvJ4xfSkrnKg,19910
 msfabricpysdkcore/tests/test_jobs.py,sha256=DC1nQTav_Re7uunRA07wD_56giLqe9KOsgm56Il8Zr4,1632
+msfabricpysdkcore/tests/test_kqldatabases.py,sha256=Oc2ZzpQAVbiJeZ5ytwlP2Jb-tKe-2e9-1oA-upwRKBQ,1921
 msfabricpysdkcore/tests/test_shortcuts.py,sha256=TqGLzEWsDyiQ0Gf6JpT_qBHUCgcvYXfVwpXxOay7Qz4,2407
 msfabricpysdkcore/tests/test_spark.py,sha256=5BCAgHRiuXjIRnGrbvNNh9emq0VyZXlvIWgWAEir5ZQ,3437
-msfabricpysdkcore/tests/test_workspaces_capacities.py,sha256=2VHPvZ8GnpFStgUoZ-Al3kVVVimjkAs9YG47NsFl-zo,6563
-msfabricpysdkcore-0.0.10.dist-info/LICENSE,sha256=1NrGuF-zOmzbwzk3iI6lsP9koyDeKO1B0-8OD_tTvOQ,1156
-msfabricpysdkcore-0.0.10.dist-info/METADATA,sha256=7EPpvWLRc5tXpMQIdAByGXRkT4dF592UEhwoPqruPXY,17455
-msfabricpysdkcore-0.0.10.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-msfabricpysdkcore-0.0.10.dist-info/top_level.txt,sha256=3iRonu6ptDGQN4Yl6G76XGM7xbFNsskiEHW-P2gMQGY,18
-msfabricpysdkcore-0.0.10.dist-info/RECORD,,
+msfabricpysdkcore/tests/test_workspaces_capacities.py,sha256=X00zIuADhY_7jORIzXrWiXfPBJUhbXUckF-gZJ3m1bQ,6547
+msfabricpysdkcore-0.0.11.dist-info/LICENSE,sha256=1NrGuF-zOmzbwzk3iI6lsP9koyDeKO1B0-8OD_tTvOQ,1156
+msfabricpysdkcore-0.0.11.dist-info/METADATA,sha256=56ie3TOUCJjsXDapUag0-i5-YmcluBQqgRFIgJODj2A,17455
+msfabricpysdkcore-0.0.11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+msfabricpysdkcore-0.0.11.dist-info/top_level.txt,sha256=3iRonu6ptDGQN4Yl6G76XGM7xbFNsskiEHW-P2gMQGY,18
+msfabricpysdkcore-0.0.11.dist-info/RECORD,,