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

msfabricpysdkcore/tests/test_one_lake_data_access_security.py

@@ -0,0 +1,65 @@
+import unittest
+from dotenv import load_dotenv
+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_one_lake_data_access_security(self):
+
+        fc = self.fc
+
+        workspace_id = "d8a5abe0-9eed-406d-ab46-343bc57ddbe5"
+        item_id = "50368cf3-29e7-4a09-aaf0-289fb5748364"
+
+        resp = fc.list_data_access_roles(workspace_id=workspace_id, item_id=item_id)
+        self.assertEqual(len(resp), 2)
+
+        roles = resp[0]
+        etag = resp[1]
+
+        role1 = roles[1]
+
+        self.assertIn('members', role1)
+        self.assertIn('fabricItemMembers', role1['members'])
+        self.assertGreater(len(role1['members']['fabricItemMembers']), 0)
+        self.assertIn('itemAccess', role1['members']['fabricItemMembers'][0])
+
+
+
+        item_access = role1["members"]["fabricItemMembers"][0]['itemAccess']
+        item_access_old = list(item_access)
+        if 'ReadAll' in item_access:
+            item_access = ['Read', 'Write', 'Execute']
+        else:
+            item_access.append('ReadAll')
+
+        role1["members"]["fabricItemMembers"][0]['itemAccess'] = item_access
+        roles[1] = role1
+
+        resp = fc.create_or_update_data_access_roles(workspace_id=workspace_id, 
+                                                     item_id=item_id, 
+                                                     data_access_roles=roles, 
+                                                     etag_match={"If-Match":etag})
+
+
+        resp = fc.list_data_access_roles(workspace_id=workspace_id, item_id=item_id)
+        self.assertEqual(len(resp), 2)
+
+        roles = resp[0]
+        etag = resp[1]
+
+        role1 = roles[1]
+
+        self.assertIn('members', role1)
+        self.assertIn('fabricItemMembers', role1['members'])
+        self.assertGreater(len(role1['members']['fabricItemMembers']), 0)
+        self.assertIn('itemAccess', role1['members']['fabricItemMembers'][0])
+
+        item_access = role1["members"]["fabricItemMembers"][0]['itemAccess']
+        self.assertNotEqual(item_access, item_access_old)

msfabricpysdkcore/tests/test_sparkjobdefinition.py

@@ -0,0 +1,55 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+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_spark_job_definitions(self):
+        
+        fc = self.fc
+        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}"
+
+        spark_job_definition_w_content = fc.get_spark_job_definition(workspace_id, spark_job_definition_name="helloworld")
+
+        result = fc.run_on_demand_spark_job_definition(workspace_id=workspace_id, 
+                                                        spark_job_definition_id=spark_job_definition_w_content.id,
+                                                        job_type="sparkjob")
+        self.assertIsNotNone(result)
+        self.assertEqual(result.job_type, "sparkjob")
+        definition = fc.get_spark_job_definition_definition(workspace_id, spark_job_definition_w_content.id)
+        
+        self.assertIsNotNone(definition)
+        self.assertIn("definition", definition)
+        definition = definition["definition"]
+
+        spark_job_definition = fc.create_spark_job_definition(workspace_id, display_name=spark_job_definition_name)
+        fc.update_spark_job_definition_definition(workspace_id, spark_job_definition.id, definition=definition)
+        spark_job_definition = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=spark_job_definition.id)
+        self.assertEqual(spark_job_definition.display_name, spark_job_definition_name)
+        self.assertIsNotNone(spark_job_definition.definition)
+
+        spark_job_definitions = fc.list_spark_job_definitions(workspace_id)
+        spark_job_definition_names = [sjd.display_name for sjd in spark_job_definitions]
+        self.assertGreater(len(spark_job_definitions), 0)
+        self.assertIn(spark_job_definition_name, spark_job_definition_names)
+
+        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_name=spark_job_definition_name)
+        self.assertIsNotNone(sjd.id)
+        self.assertEqual(sjd.display_name, spark_job_definition_name)
+
+        sjd = fc.update_spark_job_definition(workspace_id, sjd.id, display_name=f"{spark_job_definition_name}2")
+        sjd = fc.get_spark_job_definition(workspace_id, spark_job_definition_id=sjd.id)
+        self.assertEqual(sjd.display_name, f"{spark_job_definition_name}2")
+
+        status_code = fc.delete_spark_job_definition(workspace_id, sjd.id)
+        self.assertEqual(status_code, 200)

msfabricpysdkcore/tests/test_workspaces_capacities.py

@@ -10,118 +10,128 @@ class TestFabricClientCore(unittest.TestCase):
     def __init__(self, *args, **kwargs):
         super(TestFabricClientCore, self).__init__(*args, **kwargs)
         self.fc = FabricClientCore()
-        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        self.display_name = "testws" + datetime_str
-        self.workspace_id = None
+        
     
     def test_end_to_end_workspace(self):
-
-        ws_created = self.fc.create_workspace(display_name=self.display_name,
+        fc = self.fc
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        display_name = "testws" + datetime_str
+        ws_created = fc.create_workspace(display_name=display_name,
                                               description="test workspace", 
                                               exists_ok=False)
         # Add assertions here to verify the result
-        self.assertEqual(ws_created.display_name, self.display_name)
-        self.workspace_id = ws_created.id
-        ws = self.fc.get_workspace_by_id(id = self.workspace_id)
-        self.assertEqual(ws.display_name, self.display_name)
+        self.assertEqual(ws_created.display_name, display_name)
+        workspace_id = ws_created.id
+        ws = fc.get_workspace_by_id(id = workspace_id)
+        self.assertEqual(ws.display_name, display_name)
         self.assertEqual(ws.description, "test workspace")
 
 #   def test_assign_to_capacity(self):
         
-        result_status_code = self.fc.assign_to_capacity(workspace_id=ws.id, 
+        result_status_code = fc.assign_to_capacity(workspace_id=ws.id, 
                                                         capacity_id="41cb829c-c231-4e9f-b4fc-f9042a6f9840")
         self.assertEqual(result_status_code, 202)
       
 
 #    def test_list_workspaces(self):
         
-        result = self.fc.list_workspaces()
+        result = fc.list_workspaces()
         display_names = [ws.display_name for ws in result]
-        self.assertIn(self.display_name, display_names)
+        self.assertIn(display_name, display_names)
 
         for ws in result:
-            if ws.display_name == self.display_name:
+            if ws.display_name == display_name:
                 self.assertEqual(ws.capacity_id, "41cb829c-c231-4e9f-b4fc-f9042a6f9840")
 
 
   #  def test_get_workspace_by_name(self):
 
-        workspace_name = self.display_name
-        ws = self.fc.get_workspace_by_name(name = workspace_name)
-        self.assertEqual(ws.display_name, self.display_name)
+        workspace_name = display_name
+        ws = fc.get_workspace_by_name(name = workspace_name)
+        self.assertEqual(ws.display_name, display_name)
 
  #   def test_get_workspace_by_id(self):
-        ws = self.fc.get_workspace_by_id(id = self.workspace_id)
-        self.assertEqual(self.display_name, ws.display_name)
+        ws = fc.get_workspace_by_id(id = workspace_id)
+        self.assertEqual(display_name, ws.display_name)
 
 
 #    def test_get_workspace(self):
-        result = self.fc.get_workspace_by_id(id = self.workspace_id)
-        self.assertEqual(result.display_name, self.display_name)
+        result = fc.get_workspace_by_id(id = workspace_id)
+        self.assertEqual(result.display_name, display_name)
     
  #   def test_add_role_assignment(self):
-        result_status = self.fc.add_workspace_role_assignment(workspace_id = ws.id,
-                                                              principal = {"id" : "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69",
-                                                                           "type" : "ServicePrincipal"},
-                                                              role = 'Member')
+        result_status = fc.add_workspace_role_assignment(workspace_id = ws.id,
+                                                         principal = {"id" : "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69",
+                                                                        "type" : "ServicePrincipal"},
+                                                         role = 'Member')
         
-        self.assertEqual(result_status, 200)
+        self.assertEqual(result_status, 201)
 
  #   def test_get_workspace_role_assignments(self):
-        result = self.fc.get_workspace_role_assignments(workspace_id = ws.id)
-        self.assertTrue("value" in result)
-        self.assertTrue(len(result["value"]) == 2)
-        for user in result["value"]:
+        result = fc.list_workspace_role_assignments(workspace_id = ws.id)
+        self.assertTrue(len(result) == 2)
+        for user in result:
             if user["principal"]["displayName"] == "fabrictestuser":
-                self.assertTrue(user["role"] == "Member")
+                self.assertEqual(user["role"], "Member")
+
+        # Get get_workspace_role_assignment
+
+        result = fc.get_workspace_role_assignment(workspace_id = ws.id, 
+                                                  workspace_role_assignment_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
+        
+        self.assertEqual(result["role"], "Member")
 
 #    def test_update_workspace_role_assignment(self):
 
-        result_status_code = self.fc.update_workspace_role_assignment(workspace_id = ws.id, 
+        result_status_code = fc.update_workspace_role_assignment(workspace_id = ws.id, 
                                                                       role = "Contributor", 
-                                                                      principal_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
+                                                                      workspace_role_assignment_id= "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
         
         self.assertEqual(result_status_code, 200)
 
-        result = self.fc.get_workspace_role_assignments(workspace_id = ws.id)
-        self.assertTrue("value" in result)
-        self.assertTrue(len(result["value"]) == 2)
-        for user in result["value"]:
+        result = fc.list_workspace_role_assignments(workspace_id = ws.id)
+        self.assertTrue(len(result) == 2)
+        for user in result:
             if user["principal"]["displayName"] == "fabrictestuser":
                 self.assertTrue(user["role"] == "Contributor")
 
 #   def test_delete_role_assignment(self):
-        result_status_code = self.fc.delete_workspace_role_assignment(workspace_id = ws.id,
-                                                                      principal_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
+        result_status_code = fc.delete_workspace_role_assignment(workspace_id = ws.id,
+                                                                 workspace_role_assignment_id = "fe9dee5d-d244-4c93-8ea1-d5e6a2225c69")
         self.assertEqual(result_status_code, 200)
 
  #   def test_get_workspace_role_assignments(self):
-        result = self.fc.get_workspace_role_assignments(workspace_id = ws.id)
-        self.assertTrue("value" in result)
-        self.assertTrue(len(result["value"]) == 1)
-        user = result["value"][0]
+        result = fc.list_workspace_role_assignments(workspace_id = ws.id)
+        self.assertTrue(len(result) == 1)
+        user = result[0]
 #        self.assertTrue(user["principal"]["displayName"] == "fabricapi")
         self.assertTrue(user["role"] == "Admin")
 
 #    def test_update_workspace(self):
-        ws_updated = self.fc.update_workspace(workspace_id=ws.id, 
+        ws_updated = fc.update_workspace(workspace_id=ws.id, 
                                               display_name="newn912389u8293", 
                                               description="new description")
         self.assertEqual(ws_updated.display_name, "newn912389u8293")
         self.assertEqual(ws_updated.description, "new description")
-        ws = self.fc.get_workspace_by_id(id = ws.id)
+        ws = fc.get_workspace_by_id(id = ws.id)
         self.assertEqual(ws.display_name, "newn912389u8293")
         self.assertEqual(ws.description, "new description")
 
 #    def test_unassign_from_capacity(self):
 
-        result_status_code = self.fc.unassign_from_capacity(workspace_id=ws.id)
+        result_status_code = fc.unassign_from_capacity(workspace_id=ws.id)
         self.assertEqual(result_status_code, 202)
-        ws = self.fc.get_workspace_by_id(ws.id)
+        ws = fc.get_workspace_by_id(ws.id)
         self.assertEqual(ws.capacity_id, None)
 
+        # result = fc.provision_identity(workspace_id=ws.id)
+        # self.assertIsNotNone(result["applicationId"])
+        # fc.deprovision_identity(workspace_id=ws.id)
+
+
+
 #    def test_delete_workspace(self):
-        result_status = self.fc.delete_workspace(display_name="newn912389u8293")
+        result_status = fc.delete_workspace(display_name="newn912389u8293")
         self.assertEqual(result_status, 200)
 
     def test_list_capacities(self):

msfabricpysdkcore/workspace.py

@@ -42,10 +42,13 @@ class Workspace:
     def __repr__(self) -> str:
         return self.__str__()
     
-    def get_role_assignments(self):
-        """Get role assignments for the workspace"""
+    def list_role_assignments(self, continuationToken = None):
+        """List role assignments for the workspace"""
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments"
 
+        if continuationToken:
+            url = f"{url}?continuationToken={continuationToken}"
+        
         for _ in range(10):
             response = requests.get(url=url, headers=self.auth.get_headers())
             if response.status_code == 429:
@@ -58,7 +61,14 @@ class Workspace:
                 raise Exception(f"Error getting role assignments: {response.text}")
             break
 
-        return json.loads(response.text)
+        resp_dict = json.loads(response.text)
+        role_assignments = resp_dict["value"]
+
+        if "continuationToken" in resp_dict:
+            role_assignments_next = self.list_role_assignments(continuationToken=resp_dict["continuationToken"])
+            role_assignments.extend(role_assignments_next)
+
+        return role_assignments
     
     def delete(self):
         """Delete the workspace"""
@@ -94,7 +104,7 @@ class Workspace:
                 print("Too many requests, waiting 10 seconds")
                 sleep(10)
                 continue
-            if response.status_code not in (200, 429):
+            if response.status_code not in (201, 429):
                 print(response.status_code)
                 print(response.text)
                 raise Exception(f"Error adding role assignments: {response.text}")
@@ -103,9 +113,9 @@ class Workspace:
         return response.status_code
     
 
-    def delete_role_assignment(self, principal_id):
+    def delete_role_assignment(self, workspace_role_assignment_id):
         """Delete a role assignment from the workspace"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{principal_id}"
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{workspace_role_assignment_id}"
 
         for _ in range(10):
             response = requests.delete(url=url, headers=self.auth.get_headers())
@@ -150,10 +160,29 @@ class Workspace:
             self.description = description
 
         return self
+    
+    def get_role_assignment(self, workspace_role_assignment_id):
+        # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/roleAssignments/{workspaceRoleAssignmentId}
+
+        """Get a role assignment from the workspace"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{workspace_role_assignment_id}"
+
+        for _ in range(10):
+            response = requests.get(url=url, headers=self.auth.get_headers())
 
-    def update_role_assignment(self, role, principal_id):
+            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 getting role assignments: {response.status_code}, {response.text}")
+            break
+
+        return json.loads(response.text)
+
+    def update_role_assignment(self, role, workspace_role_assignment_id):
         """Update a role assignment in the workspace"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{principal_id}"
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments/{workspace_role_assignment_id}"
         body = {
             'role': role
         }
@@ -222,6 +251,45 @@ class Workspace:
         self.capacity_id = None
         return response.status_code
     
+    def provision_identity(self):
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/provisionIdentity
+        """Provision identity for the workspace"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/provisionIdentity"
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers())
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code == 202:
+                return check_long_running_operation( response.headers, self.auth)
+            if response.status_code not in (200, 201, 202, 429):
+                raise Exception(f"Error provisioning identity: {response.status_code}, {response.text}")
+            break
+
+        return response
+    
+    def deprovision_identity(self):
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/deprovisionIdentity
+        """Deprovision identity for the workspace"""
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/deprovisionIdentity"
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers())
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code == 202:
+                return check_long_running_operation( response.headers, self.auth)
+            if response.status_code not in (200, 201, 202, 429):
+                raise Exception(f"Error deprovisioning identity: {response.status_code}, {response.text}")
+            break
+
+        return response
+
+    
     def get_item_specific(self, item_dict):
         if item_dict["type"] == "DataPipeline":
             return self.get_data_pipeline(item_dict["id"])
@@ -1218,6 +1286,11 @@ class Workspace:
         """Update the definition of a spark job definition in a workspace"""
         return self.get_spark_job_definition(spark_job_definition_id=spark_job_definition_id).update_definition(definition=definition)
 
+    def run_on_demand_spark_job_definition(self, spark_job_definition_id, job_type = "sparkjob"):
+        """Run on demand spark job definition"""
+        sjd = self.get_spark_job_definition(spark_job_definition_id=spark_job_definition_id)
+        return sjd.run_on_demand_spark_job_definition(job_type=job_type)
+
     # warehouses
 
     def list_warehouses(self, with_properties = False):
@@ -1399,3 +1472,45 @@ class Workspace:
 
         return json.loads(response.text)
 
+    # External Data Shares
+
+    # create
+
+    def create_external_data_share(self, item_id, paths, recipient):
+        item = self.get_item(item_id=item_id)
+        return item.create_external_data_share(paths = paths, recipient = recipient)
+
+    # get
+
+    def get_external_data_share(self, item_id, external_data_share_id):
+        item = self.get_item(item_id=item_id)
+        return item.get_external_data_share(external_data_share_id=external_data_share_id)
+
+
+    # list
+
+    def list_external_data_shares_in_item(self, item_id):
+        item = self.get_item(item_id=item_id)
+        return item.list_external_data_shares_in_item()
+
+    # revoke
+
+    def revoke_external_data_share(self, item_id, external_data_share_id):
+        item = self.get_item(item_id=item_id)
+        return item.revoke_external_data_share(external_data_share_id=external_data_share_id)
+    
+
+    # One Lake Data Access Security
+
+    # create and update
+
+    def create_or_update_data_access_roles(self, item_id, data_access_roles, dryrun = False, etag_match = None):
+        item =  self.get_item(item_id=item_id).create_or_update_data_access_roles(data_access_roles = data_access_roles,
+                                                                                  dryrun = dryrun, etag_match = etag_match)
+        return item
+    
+    # list 
+
+    def list_data_access_roles(self, item_id):
+        item = self.get_item(item_id=item_id)
+        return item.list_data_access_roles()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: msfabricpysdkcore
-Version: 0.0.11
+Version: 0.0.13
 Summary: A Python SDK for Microsoft Fabric
 Author: Andreas Rederer
 Project-URL: Homepage, https://github.com/DaSenf1860/ms-fabric-sdk-core
@@ -38,14 +38,17 @@ Currently it supports all Core APIs, Admin APIs, Lakehouse APIs and all other it
 - Core APIs
   - [Capacities](#working-with-capacities)
   - [Deployment Pipelines](#deployment-pipelines)
+  - [External Data Shares](#external-data-shares)
   - [Git](#working-with-git)
   - [Items](#working-with-items)
   - [Job Scheduler](#working-with-job-scheduler)
   - [Long Running Operations](#long-running-operations)
+  - [OneLakeDataAccessSecurity](#one-lake-data-access-security)
   - [OneLakeShortcuts](#working-with-one-lake-shortcuts)
   - [Workspaces](#working-with-workspaces)
 - Admin APIs
   - [Domains](#admin-api-for-domains)
+  - [External Data Shares](#admin-api-for-external-data-shares)
   - [Items](#admin-api-for-items)
   - [Labels](#admin-api-for-labels)
   - [Tenants](#admin-api-for-tenants)
@@ -148,26 +151,40 @@ ws.add_role_assignment(principal = {"id" : "abadfbafb",
                        role = 'Member')
 
  
- # Get workspace role assignments
-fc.get_workspace_role_assignments(workspace_id = ws.id)
+ # List workspace role assignments
+fc.list_workspace_role_assignments(workspace_id = ws.id)
 # or
-ws.get_role_assignments()
+ws.list_role_assignments()
 
 
+# Get workspace role assignment
+fc.get_workspace_role_assignment(workspace_id = ws.id, 
+                                 workspace_role_assignment_id = "dagdasf")  
+# or
+ws.get_role_assignment(workspace_role_assignment_id = "fsgdg")
+
 # Update workspace role assignment
 fc.update_workspace_role_assignment(workspace_id = ws.id, 
                                     role = "Contributor", 
-                                    principal_id = "abadfbafb")
+                                    workspace_role_assignment_id = "abadfbafb")
 # or
 ws.update_role_assignment(role = "Contributor", 
-                          principal_id = "abadfbafb")
+                          workspace_role_assignment_id = "abadfbafb")
 
 
 # Delete workspace role assignment
 fc.delete_workspace_role_assignment(workspace_id = ws.id,
-                                    principal_id = "abadfbafb")
+                                    workspace_role_assignment_id = "abadfbafb")
 # or
-ws.delete_role_assignment(principal_id = "abadfbafb")
+ws.delete_role_assignment(workspace_role_assignment_id = "abadfbafb")
+
+
+# Provision Identity
+result = fc.provision_identity(workspace_id=ws.id)
+print(result["applicationId"]))
+
+# Deprovision Identity
+fc.deprovision_identity(workspace_id=ws.id)
 
 ```
 
@@ -235,6 +252,43 @@ response = pipe.deploy(source_stage_id=dev_stage.id,target_stage_id=prod_stage.i
 
 ```
 
+### External Data Shares
+
+```python
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+fc = FabricClientCore()
+
+workspace_id = 'yxcvyxcvyxcv'
+item_id = 'sdfsdfsdfsf'
+
+
+# Create
+
+recipient = {
+    "userPrincipalName": "lisa4@fabrikam.com"
+}
+paths=["Files/external"]
+
+data_share = fc.create_external_data_share(workspace_id, item_id, paths, recipient)
+
+# Get
+
+data_share2 = fc.get_external_data_share(workspace_id, item_id, data_share['id'])
+
+# List
+
+data_share_list = fc.list_external_data_shares_in_item(workspace_id, item_id)
+
+data_share_ids = [ds['id'] for ds in data_share_list]
+
+# Revoke
+
+response_code = fc.revoke_external_data_share(workspace_id, item_id, data_share['id'])
+
+```
+
+
 ### Working with items
 
 ```python
@@ -438,6 +492,44 @@ results = fc.get_operation_results(operation_id)
 
 ```
 
+### One Lake Data Access Security
+
+```python
+from msfabricpysdkcore import FabricClientCore
+
+fc = FabricClientCore() 
+
+workspace_id = "d8aafgasdsdbe5"
+item_id = "503hsdfhs48364"
+
+# List 
+
+resp = fc.list_data_access_roles(workspace_id=workspace_id, item_id=item_id)
+
+roles = resp[0]
+etag = resp[1]
+
+
+# Create or Update
+
+role1 = roles[1]
+
+item_access = role1["members"]["fabricItemMembers"][0]['itemAccess']
++
+if 'ReadAll' in item_access:
+    item_access = ['Read', 'Write', 'Execute']
+else:
+    item_access.append('ReadAll')
+
+role1["members"]["fabricItemMembers"][0]['itemAccess'] = item_access
+roles[1] = role1
+
+resp = fc.create_or_update_data_access_roles(workspace_id=workspace_id, 
+                                              item_id=item_id, 
+                                              data_access_roles=roles, 
+                                              etag_match={"If-Match":etag})
+
+```
 
 ### Admin API for Workspaces
 
@@ -597,6 +689,29 @@ status_code = fca.role_assignments_bulk_unassign(domain.id, "Contributors", [pri
 status_code = fca.delete_domain(domain.id)
 ```
 
+### Admin API for External Data Shares
+
+```python
+from msfabricpysdkcore import FabricClientAdmin
+
+fca = FabricClientAdmin()
+
+# List external data shares
+
+data_shares = fca.list_external_data_shares()
+ws = fca.list_workspaces(name="testworkspace")[0]
+
+data_shares = [d for d in data_shares if d['workspaceId'] == ws.id]
+
+# Revoke external data share
+
+fca.revoke_external_data_share(external_data_share_id = data_shares[0]['id'], 
+                                item_id = data_shares[0]['itemId'], 
+                                workspace_id = data_shares[0]['workspaceId'])
+
+
+```
+
 
 Note: This SDK is not an official SDK from Microsoft. It is a community project and not supported by Microsoft. Use it at your own risk.
 Also the API is still in preview and might change. This SDK is not yet feature complete and might not cover all APIs yet. Feel free to contribute to this project to make it better.