msfabricpysdkcore 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

msfabricpysdkcore/tests/test_domains.py

@@ -0,0 +1,125 @@
+import unittest
+from dotenv import load_dotenv
+from datetime import datetime
+from msfabricpysdkcore import FabricClientCore, FabricClientAdmin
+
+load_dotenv()
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+
+                  
+    def test_domains(self):
+        fcc = FabricClientCore()
+        fca = FabricClientAdmin()
+
+        ws = fcc.get_workspace_by_name("sdktestdomains")
+        cap = fcc.get_capacity(capacity_id=ws.capacity_id)
+        principal = {'id': 'b4f4e299-e6e1-4667-886c-57e4a8dde1c2',  'type': 'User'}
+
+        # Delete if exists
+        try:
+            domain = fca.get_domain_by_name("sdktestdomains")
+            domain.delete()
+        except:
+            pass
+        try:
+            domain = fca.get_domain_by_name("sdktestdomains2")
+            domain.delete()
+        except:
+            pass
+
+        # Create domain
+        domain_name = "sdktestdomains"
+        domain = fca.create_domain(display_name=domain_name)
+        self.assertIsNotNone(domain.id)
+        self.assertEqual(domain.display_name, domain_name)
+
+        # Get domain by name
+        domain_clone = fca.get_domain_by_name(domain_name)
+        self.assertIsNotNone(domain_clone.id)
+        self.assertEqual(domain_clone.display_name, domain_name)
+
+        # Get domain by id
+        domain_clone = fca.get_domain_by_id(domain.id)
+        self.assertIsNotNone(domain_clone.id)
+        self.assertEqual(domain_clone.display_name, domain_name)
+
+        # List domains
+        domains = fca.list_domains()
+        self.assertGreater(len(domains), 0)
+        domains_ids = [d.id for d in domains]
+        self.assertIn(domain.id, domains_ids)
+
+        # Update domain
+        domain_new_name = "sdktestdomains2"
+        domain_clone = fca.update_domain(domain.id, display_name=domain_new_name)
+        self.assertEqual(domain_clone.display_name, domain_new_name)
+
+        # Assign domain workspaces by Ids
+        status_code = fca.assign_domain_workspaces_by_ids(domain.id, [ws.id])
+        self.assertEqual(status_code, 200)
+
+        # List domain workspaces
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w.id for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Unassign domain workspaces by ids
+        status_code = fca.unassign_domain_workspaces_by_ids(domain.id, [ws.id])
+        self.assertEqual(status_code, 200)
+
+        workspaces = fca.list_domain_workspaces(domain.id)
+        self.assertEqual(len(workspaces), 0)
+
+        # Assign domain workspaces by capacities
+        status_code = fca.assign_domain_workspaces_by_capacities(domain.id, [cap.id])
+        self.assertEqual(status_code, 202)
+
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w.id for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Unassign all domain workspaces
+        status_code = fca.unassign_all_domain_workspaces(domain.id)
+        self.assertEqual(status_code, 200)
+
+        workspaces = fca.list_domain_workspaces(domain.id)
+        self.assertEqual(len(workspaces), 0)
+
+        # Assign domain workspaces by principals
+        status_code = fca.assign_domains_workspaces_by_principals(domain.id, [principal], wait_for_completion=True)
+
+        self.assertEqual(status_code, 202)
+
+        workspaces = fca.list_domain_workspaces(domain.id, workspace_objects=True)
+        self.assertGreater(len(workspaces), 0)
+        workspaces_ids = [w.id for w in workspaces]
+        self.assertIn(ws.id, workspaces_ids)
+
+        # Role assignments bulk assign
+        
+        principal_2 = {'id': '6edbc444-16cd-43f4-ae48-cbe734b89657', 'type': 'User'}
+        principals = [principal, principal_2]
+
+        status_code = fca.role_assignments_bulk_assign(domain.id, "Contributors", principals)
+
+        self.assertEqual(status_code, 200)
+
+        # Role assignments bulk unassign
+        status_code = fca.role_assignments_bulk_unassign(domain.id, "Contributors", [principal_2])
+
+        self.assertEqual(status_code, 200)
+
+        # Delete domain
+        status_code = fca.delete_domain(domain.id)
+
+        self.assertEqual(status_code, 200)
+
+        domains = fca.list_domains()
+        domains_ids = [d.id for d in domains]
+        self.assertNotIn(domain.id, domains_ids)

msfabricpysdkcore/tests/test_git.py

@@ -0,0 +1,62 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from datetime import datetime
+from dotenv import load_dotenv
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+        self.workspace_id = "fd3ba978-0b94-43e2-9f23-f65761e9ff34"
+        
+    def test_git(self):
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        ws2_name = "git" + datetime_str
+        self.fc.create_workspace(display_name=ws2_name)
+        ws2 = self.fc.get_workspace_by_name(name=ws2_name)
+        self.fc.assign_to_capacity(workspace_id=ws2.id, capacity_id="a089a991-221c-49be-a41e-9020198cf7af")
+
+        git_provider_details = {'organizationName': 'dasenf1860',
+                        'projectName': 'fabrictest',
+                        'gitProviderType': 'AzureDevOps',
+                        'repositoryName': 'fabrictest',
+                        'branchName': 'main',
+                        'directoryName': '/folder1'}
+
+        status_code = self.fc.git_connect(workspace_id=ws2.id, git_provider_details=git_provider_details)
+
+        self.assertEqual(status_code, 204)
+
+        initialization_strategy = "PreferWorkspace"
+
+        status_code = self.fc.git_initialize_connection(workspace_id=ws2.id, initialization_strategy=initialization_strategy)
+        self.assertEqual(status_code, 200)
+
+        connection_details = self.fc.git_get_connection(workspace_id=ws2.id)
+        self.assertEqual(connection_details['gitConnectionState'], 'ConnectedAndInitialized')
+
+        status = self.fc.git_get_status(workspace_id=ws2.id)
+        self.assertTrue(len(status["changes"]) > 0)
+
+        status_code = self.fc.update_from_git(workspace_id=ws2.id, remote_commit_hash=status["remoteCommitHash"])
+
+        self.assertEqual(status_code, 202)
+
+        blubb_lakehouse = False
+        for item in ws2.list_items():
+            if item.type == "Lakehouse" and item.display_name == "blubb":
+                blubb_lakehouse = True
+
+        self.assertTrue(blubb_lakehouse)
+
+        status_code = self.fc.git_disconnect(workspace_id=ws2.id)
+
+        self.assertEqual(status_code, 204)
+
+        ws2.delete()
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/tests/test_items_incl_lakehouse.py

@@ -0,0 +1,69 @@
+import unittest
+from datetime import datetime
+from dotenv import load_dotenv
+from time import sleep
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+        self.workspace_id = "c3352d34-0b54-40f0-b204-cc964b1beb8d"
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        self.item_name = "testitem" + datetime_str
+        self.item_type = "Notebook"
+    
+    def test_item_end_to_end(self):
+
+        item = self.fc.create_item(display_name=self.item_name, type=self.item_type, workspace_id=self.workspace_id) 
+        self.assertEqual(item.display_name, self.item_name)
+        self.assertEqual(item.type, self.item_type)
+        self.assertEqual(item.workspace_id, self.workspace_id)
+        self.assertEqual(item.description, "")
+
+        item = self.fc.get_item(workspace_id=self.workspace_id, item_id=item.id)
+        item_ = self.fc.get_item(workspace_id=self.workspace_id,
+                                  item_name=self.item_name, item_type=self.item_type)
+        self.assertEqual(item.id, item_.id)
+        self.assertEqual(item.display_name, self.item_name)
+        self.assertEqual(item.type, self.item_type)
+        self.assertEqual(item.workspace_id, self.workspace_id)
+        self.assertEqual(item.description, "")
+
+        item_list = self.fc.list_items(workspace_id=self.workspace_id)
+        self.assertTrue(len(item_list) > 0)
+
+        item_ids = [item_.id for item_ in item_list]
+        self.assertIn(item.id, item_ids)
+
+        self.fc.update_item(workspace_id=self.workspace_id, item_id=item.id, display_name=f"u{self.item_name}")
+        item = self.fc.get_item(workspace_id=self.workspace_id, item_id=item.id)
+        self.assertEqual(item.display_name, f"u{self.item_name}")
+
+        status_code = self.fc.delete_item(workspace_id=self.workspace_id, item_id=item.id)
+
+        self.assertAlmostEqual(status_code, 200)
+
+    def test_lakehouse(self):
+
+        lakehouse = self.fc.get_item(workspace_id=self.workspace_id, item_name="lakehouse1", item_type="Lakehouse")
+        item_id = lakehouse.id
+        date_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        table_name = f"table{date_str}"
+
+
+        status_code = self.fc.load_table(workspace_id=self.workspace_id, item_id=item_id, table_name=table_name, 
+                                         path_type="File", relative_path="Files/folder1/titanic.csv")
+
+        self.assertEqual(status_code, 202)
+
+        table_list = self.fc.list_tables(workspace_id=self.workspace_id, item_id=item_id)
+        table_names = [table["name"] for table in table_list]
+
+        self.assertIn(table_name, table_names)
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/tests/test_jobs.py

@@ -0,0 +1,39 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+        self.workspace_id = "c3352d34-0b54-40f0-b204-cc964b1beb8d"
+        self.item_id = "7e38f344-81df-4805-83b6-b9cc16830500"
+
+
+    def test_jobs_end_to_end(self):
+        job = self.fc.run_on_demand_item_job(workspace_id=self.workspace_id,
+                                            item_id=self.item_id,
+                                            job_type="RunNotebook")
+        
+        self.assertEqual(job.item_id, self.item_id)
+        self.assertEqual(job.workspace_id, self.workspace_id)
+        self.assertEqual(job.job_type, "RunNotebook")
+        self.assertIn(job.status, ["NotStarted", "InProgress"])
+        self.assertEqual(job.invoke_type, "Manual")
+
+        job2 = self.fc.get_item_job_instance(workspace_id=self.workspace_id,
+                                        item_id=self.item_id,
+                                        job_instance_id=job.id)
+        
+        self.assertEqual(job.id, job2.id)
+
+        status_code = self.fc.cancel_item_job_instance(workspace_id=self.workspace_id,
+                                                  item_id=self.item_id,
+                                                  job_instance_id=job.id)
+
+        self.assertEqual(status_code, 202)
+
+if __name__ == "__main__":
+    unittest.main()
+

msfabricpysdkcore/tests/test_shortcuts.py

@@ -0,0 +1,53 @@
+import unittest
+from msfabricpysdkcore.coreapi import FabricClientCore
+from datetime import datetime
+from dotenv import load_dotenv
+
+class TestFabricClientCore(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestFabricClientCore, self).__init__(*args, **kwargs)
+        #load_dotenv()
+        self.fc = FabricClientCore()
+        self.workspace_id = "c3352d34-0b54-40f0-b204-cc964b1beb8d"
+
+        self.lakehouse_target = "cb4ca0b5-b53b-4879-b206-a53c35cbff55"
+        self.lakehouse_shortcut = "e2c09c89-bf97-4f71-bdeb-36338795ec36"
+
+        datetime_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        self.shortcutname = "shortcut" + datetime_str
+        self.path_target = "Files/folder1"
+        self.path_shortcut = "Files/shortcutfolder"
+
+        self.target = {'oneLake': {'itemId': self.lakehouse_target,
+                                   'path': self.path_target,        
+                                   'workspaceId': self.workspace_id}}
+
+    def test_shortcut_end_to_end(self):
+
+        item = self.fc.create_shortcut(workspace_id=self.workspace_id,
+                                       item_id=self.lakehouse_shortcut,
+                                       path=self.path_shortcut,
+                                       name=self.shortcutname,
+                                       target=self.target)
+        self.assertEqual(item.name, self.shortcutname)
+        self.assertEqual(item.path, self.path_shortcut)
+        self.assertEqual(item.target, self.target)
+
+        item = self.fc.get_shortcut(workspace_id=self.workspace_id,
+                                    item_id=self.lakehouse_shortcut,
+                                    path=self.path_shortcut,
+                                    name=self.shortcutname)
+        self.assertEqual(item.name, self.shortcutname)
+        self.assertEqual(item.path, self.path_shortcut)
+        self.assertEqual(item.target, self.target)
+
+        status_code = self.fc.delete_shortcut(workspace_id=self.workspace_id,
+                                             item_id=self.lakehouse_shortcut,
+                                             path=self.path_shortcut,
+                                             name=self.shortcutname)
+        
+        self.assertAlmostEqual(status_code, 200)
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/tests/test_workspaces_capacities.py

@@ -0,0 +1,146 @@
+import unittest
+from dotenv import load_dotenv
+from datetime import datetime
+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()
+        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,
+                                              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.description, "test workspace")
+
+#   def test_assign_to_capacity(self):
+        
+        result_status_code = self.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()
+        display_names = [ws.display_name for ws in result]
+        self.assertIn(self.display_name, display_names)
+
+        for ws in result:
+            if ws.display_name == self.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)
+
+ #   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)
+
+
+#    def test_get_workspace(self):
+        result = self.fc.get_workspace_by_id(id = self.workspace_id)
+        self.assertEqual(result.display_name, self.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')
+        
+        self.assertEqual(result_status, 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"]) == 2)
+        for user in result["value"]:
+            if user["principal"]["displayName"] == "fabrictestuser":
+                self.assertTrue(user["role"] == "Member")
+
+#    def test_update_workspace_role_assignment(self):
+
+        result_status_code = self.fc.update_workspace_role_assignment(workspace_id = ws.id, 
+                                                                      role = "Contributor", 
+                                                                      principal_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"]:
+            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")
+        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]
+#        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, 
+                                              display_name="newname8912389u1293", 
+                                              description="new description")
+        self.assertEqual(ws_updated.display_name, "newname8912389u1293")
+        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.description, "new description")
+
+#    def test_unassign_from_capacity(self):
+
+        result_status_code = self.fc.unassign_from_capacity(workspace_id=ws.id)
+        self.assertEqual(result_status_code, 202)
+        ws = self.fc.get_workspace_by_id(ws.id)
+        self.assertEqual(ws.capacity_id, None)
+
+#    def test_delete_workspace(self):
+        result_status = self.fc.delete_workspace(display_name="newname8912389u1293")
+        self.assertEqual(result_status, 200)
+
+    def test_list_capacities(self):
+        result = self.fc.list_capacities()
+        self.assertTrue(len(result) > 0)
+        cap_ids = [cap.id for cap in result]
+        self.assertIn("41cb829c-c231-4e9f-b4fc-f9042a6f9840", cap_ids)
+
+    def test_get_capacity(self):
+        capacity = self.fc.get_capacity(capacity_id = "41cb829c-c231-4e9f-b4fc-f9042a6f9840")
+        self.assertEqual(capacity.id, "41cb829c-c231-4e9f-b4fc-f9042a6f9840")
+
+        cap = self.fc.get_capacity(capacity_name= capacity.display_name)
+
+        self.assertEqual(capacity.id, cap.id)
+        self.assertIsNotNone(cap.state)
+        self.assertIsNotNone(cap.sku)
+        self.assertIsNotNone(cap.region)
+
+
+if __name__ == "__main__":
+    unittest.main()

msfabricpysdkcore/workspace.py

@@ -33,6 +33,9 @@ class Workspace:
         }
         return json.dumps(dict_, indent=2)
     
+    def __repr__(self) -> str:
+        return self.__str__()
+    
     def get_role_assignments(self):
         """Get role assignments for the workspace"""
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/roleAssignments"
@@ -240,14 +243,29 @@ class Workspace:
                 print(response.text)
                 raise Exception(f"Error creating item: {response.text}")
             break
-        
+
         item_dict = json.loads(response.text)
+        if item_dict is None:
+            print("Item not returned by API, trying to get it by name")
+            return self.get_item_by_name(display_name, type)        
         return Item.from_dict(item_dict, auth=self.auth)
         
 
-    def get_item(self, item_id):
+    def get_item_by_name(self, item_name, item_type):
+        """Get an item from a workspace by name"""
+        ws_items = self.list_items()
+        for item in ws_items:
+            if item.display_name == item_name and item.type == item_type:
+                return item    
+
+    def get_item(self, item_id = None, item_name = None, item_type = None):
         # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}
         """Get an item from a workspace"""
+        if item_id is None and item_name is not None and item_type is not None:
+            return self.get_item_by_name(item_name, item_type)
+        elif item_id is None:
+            raise Exception("item_id or the combination item_name + item_type is required")
+        
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/items/{item_id}"
 
         for _ in range(10):
@@ -259,7 +277,7 @@ class Workspace:
             if response.status_code not in (200, 429):
                 print(response.status_code)
                 print(response.text)
-                raise Exception(f"Error getting item capacity: {response.text}")
+                raise Exception(f"Error getting item: {response.text}")
             break
         
         item_dict = json.loads(response.text)
@@ -268,11 +286,15 @@ class Workspace:
     def delete_item(self, item_id):
         """Delete an item from a workspace"""
         return self.get_item(item_id).delete()
+  
 
-    def list_items(self):
+    def list_items(self, continuationToken = None):
         """List items in a workspace"""
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.id}/items"
 
+        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:
@@ -284,8 +306,16 @@ class Workspace:
                 print(response.text)
                 raise Exception(f"Error listing items: {response.text}")
             break
-        items = json.loads(response.text)["value"]
-        return [Item.from_dict(item, auth=self.auth) for item in items]
+        
+        resp_dict = json.loads(response.text)
+        items = resp_dict["value"]
+        items = [Item.from_dict(item, auth=self.auth) for item in items]
+
+        if "continuationToken" in resp_dict:
+            item_list_next = self.list_items(continuationToken=resp_dict["continuationToken"])
+            items.extend(item_list_next)
+
+        return items
     
     def get_item_definition(self, item_id):
         """Get the definition of an item from a workspace"""
@@ -478,4 +508,14 @@ class Workspace:
                 raise Exception(f"Error updating from git: {response.text}")
             break
 
-        return response.status_code
+        return response.status_code
+    
+    def list_tables(self, item_id):
+        return self.get_item(item_id=item_id).list_tables()
+    
+    def load_table(self, item_id, table_name, path_type, relative_path,
+                    file_extension = None, format_options = None,
+                    mode = None, recursive = None, wait_for_completion = True):
+        return self.get_item(item_id).load_table(table_name, path_type, relative_path,
+                    file_extension, format_options,
+                    mode, recursive, wait_for_completion)