msfabricpysdkcore 0.2.9__py3-none-any.whl → 0.2.10__py3-none-any.whl

msfabricpysdkcore/domain.py

@@ -4,7 +4,7 @@ from msfabricpysdkcore.adminapi import FabricClientAdmin
 class Domain:
     """Class to represent a domain in Microsoft Fabric"""
 
-    def __init__(self, id, display_name, description, parent_domain_id, contributors_scope, core_client: FabricClientAdmin):
+    def __init__(self, id, display_name, description, parent_domain_id, default_label_id, contributors_scope, core_client: FabricClientAdmin):
         """Constructor for the Domain class
         
         Args:
@@ -12,6 +12,7 @@ class Domain:
             display_name (str): The display name of the domain
             description (str): The description of the domain
             parent_domain_id (str): The parent domain ID of the domain
+            default_label_id (str): The default label ID of the domain
             contributors_scope (str): The contributors scope of the domain
         Returns:
             Domain: The Domain object created"""
@@ -20,6 +21,7 @@ class Domain:
         self.display_name = display_name
         self.description = description
         self.parent_domain_id = parent_domain_id
+        self.default_label_id = default_label_id
         self.contributors_scope = contributors_scope
 
         self.core_client = core_client
@@ -35,6 +37,7 @@ class Domain:
             'display_name': self.display_name,
             'description': self.description,
             'parent_domain_id': self.parent_domain_id,
+            'default_label_id': self.default_label_id,
             'contributors_scope': self.contributors_scope
         }
         return json.dumps(dic, indent=2)
@@ -59,10 +62,20 @@ class Domain:
             else:
                 dic["parent_domain_id"] = None
         if "contributors_scope" not in dic:
-            dic["contributors_scope"] = dic["contributorsScope"]
+            if "contributorsScope" in dic:
+                dic["contributors_scope"] = dic["contributorsScope"]
+            else:
+                dic["contributors_scope"] = None
+        
+        if "default_label_id" not in dic:
+            if "defaultLabelId" in dic:
+                dic["default_label_id"] = dic["defaultLabelId"]
+            else:
+                dic["default_label_id"] = None
+        
         return Domain(id=dic['id'], display_name=dic['display_name'],
-                      description=dic['description'], parent_domain_id=dic['parent_domain_id'], 
-                      contributors_scope=dic['contributors_scope'], core_client=core_client)
+                      description=dic['description'], parent_domain_id=dic['parent_domain_id'], default_label_id=dic.get('default_label_id', None),
+                      contributors_scope=dic.get('contributors_scope', None), core_client=core_client)
 
     def list_domain_workspaces(self, workspace_objects = False):
         """Method to list the workspaces in the domain
@@ -179,4 +192,22 @@ class Domain:
         Returns:
             int: The status code of the response
         """
-        return self.core_client.unassign_domain_workspaces_by_ids(self.id, workspace_ids)
+        return self.core_client.unassign_domain_workspaces_by_ids(self.id, workspace_ids)
+    
+    def list_role_assignments(self):
+        """Method to list role assignments in the domain
+        
+        Returns:
+            list: The list of role assignments in the domain
+        """
+        return self.core_client.list_role_assignments(domain_id=self.id)
+    
+    def sync_role_assignments_to_subdomains(self, role):
+        """Method to sync role assignments to subdomains
+        
+        Args:
+            role (str): The role to sync
+        Returns:
+            int: The status code of the response
+        """
+        return self.core_client.sync_role_assignments_to_subdomains(self.id, role)

msfabricpysdkcore/lakehouse.py

@@ -32,4 +32,48 @@ class Lakehouse(Item):
 
     def get_livy_session(self, livy_id):
         """Get a livy session in the lakehouse"""
-        return self.core_client.get_lakehouse_livy_session(self.workspace_id, self.id, livy_id)
+        return self.core_client.get_lakehouse_livy_session(self.workspace_id, self.id, livy_id)
+    
+    def create_refresh_materialized_lake_view_schedule(self, enabled, configuration):
+        """Create a refresh materialized lake view schedule
+        Args:
+            enabled (bool): Whether the schedule is enabled
+            configuration (dict): The configuration of the schedule
+        Returns:
+            dict: The created schedule
+        """
+        return self.core_client.create_refresh_materialized_lake_view_schedule(workspace_id=self.workspace_id, lakehouse_id=self.id,
+                                                                               enabled=enabled, configuration=configuration)
+    
+    def delete_refresh_materialized_lake_view_schedule(self, schedule_id):
+        """Delete a refresh materialized lake view schedule
+        Args:
+            schedule_id (str): The ID of the schedule
+        Returns:
+            int: The status code of the response
+        """
+        return self.core_client.delete_refresh_materialized_lake_view_schedule(workspace_id=self.workspace_id, lakehouse_id=self.id,
+                                                                               schedule_id=schedule_id)
+
+    def run_on_demand_refresh_materialized_lake_view(self, job_type="RefreshMaterializedLakeViews"):
+        """Run refresh materialized lake view
+        Args:
+            job_type (str): The job type
+        Returns:
+            dict: The operation result or response value
+        """
+        return self.core_client.run_on_demand_refresh_materialized_lake_view(workspace_id=self.workspace_id, lakehouse_id=self.id, job_type=job_type)
+
+    def update_refresh_materialized_lake_view_schedule(self, schedule_id, enabled, configuration):
+        """Update a refresh materialized lake view schedule
+        Args:
+            schedule_id (str): The ID of the schedule
+            schedule_id (str): The ID of the schedule
+            enabled (bool): Whether the schedule is enabled
+            configuration (dict): The configuration of the schedule
+        Returns:
+            dict: The updated schedule
+        """
+        return self.core_client.update_refresh_materialized_lake_view_schedule(workspace_id=self.workspace_id, lakehouse_id=self.id,
+                                                                               schedule_id=schedule_id, enabled=enabled,
+                                                                               configuration=configuration)

msfabricpysdkcore/otheritems.py

@@ -1,5 +1,25 @@
 from msfabricpysdkcore.item import Item
 
+class AnomalyDetector(Item):
+    """Class to represent an anomaly detector in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return AnomalyDetector(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+            properties=item_dict.get('properties', None),
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
+    
+    def get_definition(self, format=None):
+        """Method to get the definition of the anomaly detector"""
+        return super().get_definition(type="anomalydetectors", format=format)
+    
+    def update_definition(self, definition, update_metadata=None):
+        """Method to update the definition of the anomaly detector"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="anomalydetectors",
+                                                       update_metadata=update_metadata)
+
 class ApacheAirflowJob(Item):
     """Class to represent a ApacheAirflowJob in Microsoft Fabric"""
      
@@ -32,7 +52,10 @@ class Dataflow(Item):
         return Dataflow(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
-    
+
+    def discover_parameters(self):
+        return self.core_client.discover_dataflow_parameters(workspace_id=self.workspace_id, dataflow_id=self.id)
+
 class DataPipeline(Item):
     """Class to represent a spark job definition in Microsoft Fabric"""
      
@@ -158,6 +181,66 @@ class Warehouse(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
+    def get_connection_string(self, guest_tenant_id = None, private_link_type = None):
+        return self.core_client.get_warehouse_connection_string(workspace_id=self.workspace_id, warehouse_id=self.id,
+                                                               guest_tenant_id=guest_tenant_id, private_link_type=private_link_type)
+    
+    def create_restore_point(self, display_name = None, description = None):
+        return self.core_client.create_warehouse_restore_point(workspace_id=self.workspace_id, warehouse_id=self.id,
+                                                               display_name=display_name, description=description)
+    
+    def delete_restore_point(self, restore_point_id):
+        return self.core_client.delete_warehouse_restore_point(workspace_id=self.workspace_id, warehouse_id=self.id,
+                                                               restore_point_id=restore_point_id)
+    
+    def get_restore_point(self, restore_point_id):
+        return self.core_client.get_warehouse_restore_point(workspace_id=self.workspace_id, warehouse_id=self.id,
+                                                            restore_point_id=restore_point_id)
+    
+    def list_restore_points(self):
+        return self.core_client.list_warehouse_restore_points(workspace_id=self.workspace_id, warehouse_id=self.id)
+    
+    def restore_to_restore_point(self, restore_point_id, wait_for_completion = False):
+        return self.core_client.restore_warehouse_to_restore_point(workspace_id=self.workspace_id, warehouse_id=self.id,
+                                                                  restore_point_id=restore_point_id,
+                                                                  wait_for_completion=wait_for_completion)
+    
+    def update_restore_point(self, restore_point_id, display_name = None, description = None):
+        return self.core_client.update_warehouse_restore_point(workspace_id=self.workspace_id, warehouse_id=self.id,
+                                                               restore_point_id=restore_point_id,
+                                                               display_name=display_name, description=description)
+
+    def get_sql_audit_settings(self):
+        """Get the audit settings of a warehouse
+        Returns:
+            dict: The audit settings of the warehouse
+        """
+
+        return self.core_client.get_warehouse_sql_audit_settings(self.workspace_id, self.id)
+
+    def set_warehouse_audit_actions_and_groups(self, set_audit_actions_and_groups_request):
+        """Set the audit actions and groups of a warehouse
+        Args:
+            set_audit_actions_and_groups_request (list): The list of audit actions and groups
+        Returns:
+            dict: The updated audit settings of the warehouse
+        """
+        return self.core_client.set_warehouse_audit_actions_and_groups(workspace_id=self.workspace_id,
+                                                                       warehouse_id=self.id,
+                                                                       set_audit_actions_and_groups_request=set_audit_actions_and_groups_request)
+
+    def update_warehouse_sql_audit_settings(self, retention_days, state):
+        """Update the audit settings of a warehouse
+        Args:
+            retention_days (int): The number of days to retain the audit logs
+            state (str): The state of the audit settings
+        Returns:
+            dict: The updated audit settings of the warehouse
+        """
+        return self.core_client.update_warehouse_sql_audit_settings(self.workspace_id, self.id,
+                                                                    retention_days, state)
+
+
 class WarehouseSnapshot(Item):
     """Class to represent a warehouse snapshot in Microsoft Fabric"""
      
@@ -296,6 +379,133 @@ class MLModel(Item):
         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', ""), core_client=core_client)
+    
+        
+    def activate_ml_model_endpoint_version(self, name, wait_for_completion = False):
+        """Activate an ml model endpoint version
+        Args:
+            name (str): The name of the endpoint version    
+            wait_for_completion (bool): Whether to wait for the operation to complete
+        Returns:
+            dict: The activated endpoint version
+        """
+
+        return self.core_client.activate_ml_model_endpoint_version(workspace_id=self.workspace_id, model_id=self.id,
+                                                                   name=name, wait_for_completion=wait_for_completion)
+
+    def deactivate_all_ml_model_endpoint_versions(self, wait_for_completion = False):
+        """Deactivate all ml model endpoint versions
+        Args:
+            wait_for_completion (bool): Whether to wait for the operation to complete
+        Returns:
+            Response: The operation result
+        """
+        return self.core_client.deactivate_all_ml_model_endpoint_versions(workspace_id=self.workspace_id, model_id=self.id,
+                                                                          wait_for_completion=wait_for_completion)
+
+    def deactivate_ml_model_endpoint_version(self, name, wait_for_completion = False):
+        """Deactivate an ml model endpoint version
+        Args:
+            name (str): The name of the endpoint version
+            wait_for_completion (bool): Whether to wait for the operation to complete
+        Returns:
+            Response: The operation result
+        """
+        return self.core_client.deactivate_ml_model_endpoint_version(workspace_id=self.workspace_id, model_id=self.id,
+                                                                     name=name, wait_for_completion=wait_for_completion)
+
+    def get_ml_model_endpoint(self):
+        """Get the ml model endpoint
+        Returns:
+            dict: The ml model endpoint
+        """
+        return self.core_client.get_ml_model_endpoint(workspace_id=self.workspace_id, model_id=self.id)
+
+    def get_ml_model_endpoint_version(self, name):
+        """Get an ml model endpoint version
+        Args:
+            name (str): The name of the endpoint version
+        Returns:
+            dict: The ml model endpoint version
+        """
+        return self.core_client.get_ml_model_endpoint_version(workspace_id=self.workspace_id, model_id=self.id, name=name)
+
+    def list_ml_model_endpoint_versions(self):
+        """List all ml model endpoint versions
+        
+        Returns:
+            list: The list of ml model endpoint versions
+        """
+        return self.core_client.list_ml_model_endpoint_versions(workspace_id=self.workspace_id, model_id=self.id)
+
+    def score_ml_model_endpoint(self, inputs, format_type = None, orientation = None):
+        """Score an ml model endpoint
+        Args:
+            inputs (list): The inputs to score
+            format_type (str): The format type
+            orientation (str): The orientation
+        Returns:
+            dict: The scoring result
+        """
+        return self.core_client.score_ml_model_endpoint(workspace_id=self.workspace_id, model_id=self.id, inputs=inputs,
+                                                        format_type=format_type, orientation=orientation)
+
+    def score_ml_model_endpoint_version(self, name, inputs, format_type = None, orientation = None):
+        """Score an ml model endpoint version
+        Args:
+            name (str): The name of the endpoint version    
+            inputs (list): The inputs to score
+            format_type (str): The format type
+            orientation (str): The orientation
+        Returns:
+            dict: The scoring result
+        """
+        return self.core_client.score_ml_model_endpoint_version(workspace_id=self.workspace_id, model_id=self.id, name=name,
+                                                               inputs=inputs, format_type=format_type, orientation=orientation)                                
+
+    def update_ml_model_endpoint(self, default_version_assignment_behavior, default_version_name):
+        """Update an ml model endpoint
+        Args:
+            default_version_assignment_behavior (str): The default version assignment behavior
+            default_version_name (str): The default version name
+        Returns:
+            dict: The updated endpoint
+        """
+        return self.core_client.update_ml_model_endpoint(workspace_id=self.workspace_id, model_id=self.id,
+                                                        default_version_assignment_behavior=default_version_assignment_behavior,
+                                                        default_version_name=default_version_name)
+
+    def update_ml_model_endpoint_version(self, name, scale_rule):
+        """Update an ml model endpoint version
+        Args:
+            name (str): The name of the endpoint version
+            scale_rule (str): The scale rule
+        Returns:
+            dict: The updated endpoint version
+        """
+        return self.core_client.update_ml_model_endpoint_version(workspace_id=self.workspace_id, model_id=self.id,
+                                                                 name=name, scale_rule=scale_rule)
+
+
+class Map(Item):
+    """Class to represent a map in Microsoft Fabric"""
+     
+    def __init__(self, id, display_name, type, workspace_id, core_client, properties = None, definition=None, description=""):
+        super().__init__(id, display_name, type, workspace_id, core_client, properties, definition, description)
+
+    def from_dict(item_dict, core_client):
+        return Map(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
+            properties=item_dict.get('properties', None),
+            definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
+    
+    def get_definition(self, format=None):
+        """Method to get the definition of the map"""
+        return super().get_definition(type="Maps", format=format)
+    
+    def update_definition(self, definition, update_metadata=None):
+        """Method to update the definition of the map"""
+        return self.core_client.update_item_definition(self.workspace_id, self.id, definition, type="Maps",
+                                                       update_metadata=update_metadata)
 
 class MountedDataFactory(Item):
     """Class to represent a mounted data factory in Microsoft Fabric"""
@@ -392,6 +602,11 @@ class SemanticModel(Item):
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""), core_client=core_client)
     
+    def bind_connection(self, connection_binding):
+        """Bind a connection to the semantic model"""
+        return self.core_client.bind_semantic_model_connection(workspace_id=self.workspace_id, semantic_model_id=self.id,
+                                                               connection_binding=connection_binding)
+
     def get_definition(self, format=None):
         """Method to get the definition of the semantic model"""
         return super().get_definition(type="semanticModels", format=format)

msfabricpysdkcore/tests/test_anomaly_detector.py

@@ -0,0 +1,60 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+from datetime import datetime
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_anomaly_detectors(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "9d47b06e-d7c3-40a3-8e6d-6263fb1779a2"
+
+        anomaly_detectors = fcc.list_anomaly_detectors(workspace_id=workspace_id)
+        for anomaly_detector in anomaly_detectors:
+            if anomaly_detector.id != item_id:
+                resp = fcc.delete_anomaly_detector(workspace_id=workspace_id, anomaly_detector_id=anomaly_detector.id)
+                self.assertEqual(resp, 200)
+
+        anomaly_detector_definition = fcc.get_anomaly_detector_definition(workspace_id=workspace_id, anomaly_detector_id=item_id)
+        self.assertIn("definition", anomaly_detector_definition)
+        definition = anomaly_detector_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"anomalydetector{date_str}"
+
+        anomaly_detector_new = fcc.create_anomaly_detector(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(anomaly_detector_new.display_name, date_str)
+
+        anomaly_detector_get = fcc.get_anomaly_detector(workspace_id=workspace_id, anomaly_detector_id=anomaly_detector_new.id)
+        self.assertEqual(anomaly_detector_get.display_name, date_str)
+
+        anomaly_detectors = fcc.list_anomaly_detectors(workspace_id=workspace_id)
+        self.assertEqual(len(anomaly_detectors), 2)
+
+        date_str_updated = date_str + "_updated"
+        anomaly_detector_updated = fcc.update_anomaly_detector(workspace_id=workspace_id, anomaly_detector_id=anomaly_detector_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(anomaly_detector_updated.display_name, date_str_updated)
+
+        anomaly_detector_updated = fcc.update_anomaly_detector_definition(workspace_id=workspace_id, anomaly_detector_id=anomaly_detector_new.id, definition=definition)
+        self.assertEqual(anomaly_detector_updated.status_code, 200)
+
+        for anomaly_detector in anomaly_detectors:
+            if anomaly_detector.id != item_id:
+                resp = fcc.delete_anomaly_detector(workspace_id=workspace_id, anomaly_detector_id=anomaly_detector.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+

msfabricpysdkcore/tests/test_dataflows.py

@@ -16,6 +16,19 @@ class TestFabricClientCore(unittest.TestCase):
         workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
         item_id = "8bc6f2f1-2ef9-4dc1-ab47-f55aa90e4088"
 
+
+        resp = fcc.discover_dataflow_parameters(workspace_id, item_id)
+
+        self.assertIsInstance(resp, list)
+        self.assertGreater(len(resp), 0)
+
+        for param in resp:
+            self.assertIn("type", param)
+            self.assertIn("name", param)
+            self.assertIn("description", param)
+            self.assertIn("isRequired", param)
+            self.assertIn("defaultValue", param)
+
         dataflows = fcc.list_dataflows(workspace_id=workspace_id)
         for dataflow in dataflows:
             if dataflow.id != item_id:

msfabricpysdkcore/tests/test_maps.py

@@ -0,0 +1,60 @@
+import unittest
+from dotenv import load_dotenv
+from msfabricpysdkcore import FabricClientCore
+from datetime import datetime
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        self.fcc = FabricClientCore()
+                  
+    def test_maps(self):
+        fcc = self.fcc
+
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "9dcf0419-0f08-4cf4-b282-7a0272d02ff0"
+
+        maps = fcc.list_maps(workspace_id=workspace_id)
+        for map in maps:
+            if map.id != item_id:
+                resp = fcc.delete_map(workspace_id=workspace_id, map_id=map.id)
+                self.assertEqual(resp, 200)
+
+        map_definition = fcc.get_map_definition(workspace_id=workspace_id, map_id=item_id)
+        self.assertIn("definition", map_definition)
+        definition = map_definition["definition"]
+
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        date_str = date_str.replace(" ", "T").replace(":", "").replace("-", "")
+        date_str = f"map{date_str}"
+
+        map_new = fcc.create_map(workspace_id=workspace_id, display_name=date_str, definition=definition)
+
+        self.assertEqual(map_new.display_name, date_str)
+
+        map_get = fcc.get_map(workspace_id=workspace_id, map_id=map_new.id)
+        self.assertEqual(map_get.display_name, date_str)
+
+        maps = fcc.list_maps(workspace_id=workspace_id)
+        self.assertEqual(len(maps), 2)
+
+        date_str_updated = date_str + "_updated"
+        map_updated = fcc.update_map(workspace_id=workspace_id, map_id=map_new.id, display_name=date_str_updated, return_item=True)
+        self.assertEqual(map_updated.display_name, date_str_updated)
+
+        map_updated = fcc.update_map_definition(workspace_id=workspace_id, map_id=map_new.id, definition=definition)
+        self.assertEqual(map_updated.status_code, 200)
+
+        for map in maps:
+            if map.id != item_id:
+                resp = fcc.delete_map(workspace_id=workspace_id, map_id=map.id)
+                self.assertEqual(resp, 200)
+
+
+
+
+
+
+

msfabricpysdkcore/tests/test_sql_endpoint.py

@@ -16,13 +16,19 @@ class TestFabricClientCore(unittest.TestCase):
         workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
         item_id = "d21012a1-f306-4cf1-a21b-f8ae55c17642"
 
-        response = fcc.refresh_sql_endpoint_metadata(workspace_id=workspace_id, sql_endpoint_id=item_id, wait_for_completion=False)
-        self.assertIn(response.status_code, [200, 202])
-
-
-
-
+        audit_settings = fcc.get_sql_endpoint_audit_settings(workspace_id=workspace_id, sql_endpoint_id=item_id)
 
+        self.assertIn("state", audit_settings)
+        self.assertIn("retentionDays", audit_settings)
+        self.assertIn("auditActionsAndGroups", audit_settings)
 
+        respo = fcc.update_sql_endpoint_audit_settings(workspace_id=workspace_id, sql_endpoint_id=item_id,
+                                               state="Enabled", retention_days=10)
+        self.assertEqual(respo.status_code, 200)
 
+        actionsandgroups = ["SUCCESSFUL_DATABASE_AUTHENTICATION_GROUP",  "FAILED_DATABASE_AUTHENTICATION_GROUP",  "BATCH_COMPLETED_GROUP"]
 
+        respo = fcc.set_sql_endpoint_audit_actions_and_groups(workspace_id=workspace_id, sql_endpoint_id=item_id,
+                                                      set_audit_actions_and_groups_request=actionsandgroups)
+        self.assertEqual(respo.status_code, 200)
+        

msfabricpysdkcore/tests/test_warehouses.py

@@ -44,6 +44,61 @@ class TestFabricClientCore(unittest.TestCase):
 
         status_code = fc.delete_warehouse(workspace_id, warehouse.id)
         self.assertEqual(status_code, 200)
+    
+    def test_other_warehouse_stuff(self):
+        fcc = self.fc
+        workspace_id = "05bc5baa-ef02-4a31-ab20-158a478151d3"
+        item_id = "e4655180-815b-4339-984b-213a23524685"
+
+        resp = fcc.get_warehouse_connection_string(workspace_id, item_id)
+
+        self.assertIn('connectionString', resp)
+        self.assertIsInstance(resp['connectionString'], str)
+
+
+        resp = fcc.list_warehouse_restore_points(workspace_id, item_id)
+        self.assertGreater(len(resp), 0)
+        for rp in resp:
+            if rp['id'] != "1760452482000" and rp['creationMode'] != 'SystemCreated':
+                rp_to_delete = rp['id']
+                break
+
+        resp = fcc.create_warehouse_restore_point(workspace_id, item_id, "my second restore point", wait_for_completion=False)
+        
+        self.assertIn(resp.status_code, [200, 201, 202])
+
+        resp = fcc.get_warehouse_restore_point(workspace_id, item_id, "1760452482000")
+        self.assertEqual(resp, {
+            'id': '1760452482000',
+            'displayName': 'my first restore point',
+            'description': '',
+        })
+
+        resp = fcc.update_warehouse_restore_point(workspace_id, item_id, rp_to_delete, description="updated description")
+
+        self.assertEqual(resp['description'], "updated description")
+        resp = fcc.delete_warehouse_restore_point(workspace_id, item_id, rp_to_delete)
+        self.assertEqual(resp.status_code, 200)
+
+        resp = fcc.restore_warehouse_to_restore_point(workspace_id, item_id, "1760452482000")
+        self.assertIn(resp.status_code, [200, 201, 202])
+
+        audit_settings = fcc.get_warehouse_sql_audit_settings(workspace_id=workspace_id, warehouse_id=item_id)
+
+        self.assertIn("state", audit_settings)
+        self.assertIn("retentionDays", audit_settings)
+        self.assertIn("auditActionsAndGroups", audit_settings)
+
+        respo = fcc.update_warehouse_sql_audit_settings(workspace_id=workspace_id, warehouse_id=item_id,
+                                               state="Enabled", retention_days=10)
+        self.assertEqual(respo.status_code, 200)
+
+        actionsandgroups = ["SUCCESSFUL_DATABASE_AUTHENTICATION_GROUP",  "FAILED_DATABASE_AUTHENTICATION_GROUP",  "BATCH_COMPLETED_GROUP"]
+
+        respo = fcc.set_warehouse_audit_actions_and_groups(workspace_id=workspace_id, warehouse_id=item_id,
+                                                      set_audit_actions_and_groups_request=actionsandgroups)
+        self.assertEqual(respo.status_code, 200)
+        
 
 
 if __name__ == "__main__":

msfabricpysdkcore/tests/test_workspaces_capacities.py

@@ -154,6 +154,18 @@ class TestFabricClientCore(unittest.TestCase):
         self.assertIsNotNone(cap.sku)
         self.assertIsNotNone(cap.region)
 
+    def test_network_communication_policy(self):
+        fcc = self.fc
+        workspace_id = "5902cade-5261-4afa-96f4-266167ac81a1"
+        policy = fcc.get_network_communication_policy(workspace_id=workspace_id)
+        self.assertIn('inbound', policy)
+        self.assertIn('outbound', policy)
+        
+        inbound = {'publicAccessRules': {'defaultAction': 'Allow'}}
+        outbound = {'publicAccessRules': {'defaultAction': 'Allow'}}
+
+        resp = fcc.set_network_communication_policy(workspace_id=workspace_id, inbound=inbound, outbound=outbound)
+        self.assertEqual(resp.status_code, 200)
 
 if __name__ == "__main__":
     unittest.main()