msfabricpysdkcore 0.0.10__tar.gz → 0.0.11__tar.gz

{msfabricpysdkcore-0.0.10 → msfabricpysdkcore-0.0.11}/PKG-INFO

@@ -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 → msfabricpysdkcore-0.0.11}/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-0.0.10 → msfabricpysdkcore-0.0.11}/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-0.0.10 → msfabricpysdkcore-0.0.11}/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-0.0.10 → msfabricpysdkcore-0.0.11}/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-0.0.10 → msfabricpysdkcore-0.0.11}/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-0.0.10 → msfabricpysdkcore-0.0.11}/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-0.0.11/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-0.0.11/msfabricpysdkcore/tests/test_environments.py

@@ -0,0 +1,65 @@
+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)
+        self.fc = FabricClientCore()
+
+    def test_environments_crudl(self):
+        fc = self.fc
+        workspace_id = 'd8a5abe0-9eed-406d-ab46-343bc57ddbe5'
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+
+        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-0.0.11/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)