msfabricpysdkcore 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

msfabricpysdkcore/capacity.py

@@ -0,0 +1,53 @@
+import json 
+
+class Capacity:
+    """Class to represent a capacity in Microsoft Fabric"""
+
+
+    def __init__(self, id, display_name, sku, region, state):
+        """Constructor for the Capacity class
+        
+        Args:
+            id (str): The ID of the capacity
+            display_name (str): The display name of the capacity
+            sku (str): The SKU of the capacity
+            region (str): The region of the capacity
+            state (str): The state of the capacity
+        
+        Returns:
+            Capacity: The Capacity object created
+        """
+        self.id = id
+        self.display_name = display_name
+        self.sku = sku
+        self.region = region
+        self.state = state
+
+    def __str__(self):
+        """Method to return a string representation of the Capacity object
+        
+        Returns:
+            str: The string representation of the Capacity object
+        """
+        dic = {
+            'id': self.id,
+            'display_name': self.display_name,
+            'sku': self.sku,
+            'region': self.region,
+            'state': self.state
+        }
+        return json.dumps(dic, indent=2)
+
+    def from_dict(dic):
+        """Method to create a Capacity object from a dictionary
+        
+        Args:
+            dic (dict): The dictionary containing the capacity information
+        Returns:
+            Capacity: The Capacity object created from the dictionary
+        
+        """
+        if "display_name" not in dic:
+            dic["display_name"] = dic["displayName"]
+        return Capacity(dic['id'], dic['display_name'], dic['sku'], dic['region'], dic['state'])
+        

msfabricpysdkcore/client.py

@@ -3,6 +3,7 @@ import json
 import os
 from time import sleep
 
+from msfabricpysdkcore.capacity import Capacity
 from msfabricpysdkcore.workspace import Workspace
 from msfabricpysdkcore.auth import FabricAuthClient, FabricServicePrincipal
 
@@ -25,10 +26,12 @@ class FabricClientCore():
         self.scope = "https://api.fabric.microsoft.com/.default"
 
 
-    def list_workspaces(self):
+    def list_workspaces(self, continuationToken = None):
         """List all workspaces in the tenant"""
 
         url = "https://api.fabric.microsoft.com/v1/workspaces"
+        if continuationToken:
+            url = f"{url}?continuationToken={continuationToken}"
 
         for _ in range(10):
             response = requests.get(url=url, headers=self.auth.get_headers())
@@ -39,13 +42,16 @@ class FabricClientCore():
             if response.status_code not in (200, 429):
                 print(response.status_code)
                 print(response.text)
-            items = json.loads(response.text)["value"]
+                raise Exception(f"Error listing workspaces: {response.status_code},  {response.text}")
             break
+        resp_dict = json.loads(response.text)
+        ws_list = resp_dict["value"]
+        ws_list = [Workspace.from_dict(ws, auth=self.auth) for ws in ws_list]
+      
+        if "continuationToken" in resp_dict:
+            ws_list_next = self.list_workspaces(continuationToken=resp_dict["continuationToken"])
+            ws_list.extend(ws_list_next)
 
-        ws_list = []
-        for i in items:
-            ws = Workspace.from_dict(i, auth=self.auth)
-            ws_list.append(ws)
         return ws_list
     
     def get_workspace_by_name(self, name):
@@ -69,12 +75,12 @@ class FabricClientCore():
             if response.status_code not in (200, 429):
                 print(response.status_code)
                 print(response.text)
-            ws_dict = json.loads(response.text)
-            if "id" not in ws_dict:
                 raise Exception(f"Error getting workspace: {response.status_code} {response.text}")
-            ws = Workspace.from_dict(json.loads(response.text), auth=self.auth)
+            break
+        ws_dict = json.loads(response.text)
+        ws = Workspace.from_dict(ws_dict, auth=self.auth)
 
-            return ws
+        return ws
 
     
     def get_workspace(self, id = None, name = None):
@@ -158,10 +164,13 @@ class FabricClientCore():
         ws = self.get_workspace_by_id(workspace_id)
         return ws.unassign_from_capacity()
  
-    def list_capacities(self):
+    def list_capacities(self, continuationToken = None):
         """List all capacities in the tenant"""
         url = "https://api.fabric.microsoft.com/v1/capacities"
 
+        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:
@@ -174,9 +183,17 @@ class FabricClientCore():
                 raise Exception(f"Error listing capacities: {response.text}")
             break
 
-        items = json.loads(response.text)["value"]
+        resp_dict = json.loads(response.text)
+        items = resp_dict["value"]
+
+        if "continuationToken" in resp_dict:
+            cap_list_next = self.list_capacities(continuationToken=resp_dict["continuationToken"])
+            items.extend(cap_list_next)
 
+        items = json.loads(response.text)["value"]
+        items = [Capacity.from_dict(i) for i in items]
         return items
+
     
     def create_item(self, workspace_id, display_name, type, definition = None, description = None):
         """Create an item in a workspace"""
@@ -187,10 +204,11 @@ class FabricClientCore():
                               definition = definition,
                               description = description)
 
-    def get_item(self, workspace_id, item_id):
+    def get_item(self, workspace_id = None, 
+                  item_id = None, workspace_name = None, item_name = None, item_type = None):
         """Get an item from a workspace"""
-        ws = self.get_workspace_by_id(workspace_id)
-        return ws.get_item(item_id)
+        ws = self.get_workspace(id = workspace_id, name = workspace_name)
+        return ws.get_item(item_id = item_id, item_name = item_name, item_type = item_type)
 
     def delete_item(self, workspace_id, item_id):
         """Delete an item from a workspace"""
@@ -280,4 +298,39 @@ class FabricClientCore():
         return ws.update_from_git(remote_commit_hash=remote_commit_hash,
                                   conflict_resolution=conflict_resolution, 
                                   options=options, 
-                                  workspace_head=workspace_head)
+                                  workspace_head=workspace_head)
+    
+    def get_capacity(self, capacity_id = None, capacity_name = None):
+        """Get a capacity
+        
+        Args:
+            capacity_id (str): The ID of the capacity
+            capacity_name (str): The name of the capacity
+            
+        Returns:
+            Capacity: The capacity object
+            
+        Raises:
+            ValueError: If no capacity is found
+        """
+        if capacity_id is None and capacity_name is None:
+            raise ValueError("Either capacity_id or capacity_name must be provided")
+        caps = self.list_capacities()
+        for cap in caps:
+            if capacity_id and cap.id == capacity_id:
+                return cap
+            if capacity_name and cap.display_name == capacity_name:
+                return cap
+        raise ValueError("No capacity found") 
+    
+    def list_tables(self, workspace_id, item_id):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.list_tables(item_id=item_id)
+    
+    def load_table(self, workspace_id, item_id, table_name, path_type, relative_path,
+                    file_extension = None, format_options = None,
+                    mode = None, recursive = None, wait_for_completion = True):
+        ws = self.get_workspace_by_id(workspace_id)
+        return ws.load_table(item_id, table_name, path_type, relative_path,
+                    file_extension, format_options,
+                    mode, recursive, wait_for_completion)

msfabricpysdkcore/item.py

@@ -6,6 +6,7 @@ from msfabricpysdkcore.onelakeshortcut import OneLakeShortcut
 from msfabricpysdkcore.job_instance import JobInstance
 from msfabricpysdkcore.long_running_operation import check_long_running_operation
 
+
 class Item:
     """Class to represent a item in Microsoft Fabric"""
 
@@ -36,6 +37,12 @@ class Item:
     
     def from_dict(item_dict, auth):
         """Create Item object from dictionary"""
+        
+        if item_dict['type'] == "Lakehouse":
+            from msfabricpysdkcore.lakehouse import Lakehouse
+            return Lakehouse(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', ""), auth=auth)
         return Item(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', ""), auth=auth)
@@ -52,6 +59,7 @@ class Item:
             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}")
             break
 
@@ -243,4 +251,11 @@ class Item:
     def cancel_item_job_instance(self, job_instance_id):
         """Cancel a job instance ofjob the item"""
         return self.get_item_job_instance(job_instance_id=job_instance_id).cancel()
-        
+        
+    def list_tables(self):
+        raise NotImplementedError("List tables only works on Lakehouse Items")
+    
+    def load_table(self, table_name, path_type, relative_path,
+                    file_extension = None, format_options = None,
+                    mode = None, recursive = None, wait_for_completion = True):
+        raise NotImplementedError("Load table only works on Lakehouse Items")

msfabricpysdkcore/lakehouse.py

@@ -0,0 +1,96 @@
+import json 
+import requests
+from time import sleep
+
+from msfabricpysdkcore.long_running_operation import check_long_running_operation
+from msfabricpysdkcore.item import Item
+
+class Lakehouse(Item):
+    """Class to represent a item in Microsoft Fabric"""
+
+    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)
+
+
+    def list_tables(self, continuationToken = None):
+        """List all tables in the lakehouse"""
+        # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/lakehouses/{lakehouseId}/tables
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/lakehouses/{self.id}/tables"
+
+        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:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code not in (200, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error listing tables: {response.status_code},  {response.text}")
+            break
+        resp_dict = json.loads(response.text)
+
+        table_list = resp_dict["data"]
+
+        if "continuationToken" in resp_dict and resp_dict["continuationToken"] is not None:
+            table_list_next = self.list_tables(continuationToken=resp_dict["continuationToken"])
+            table_list.extend(table_list_next)
+
+        return table_list
+    
+    def load_table(self, table_name, path_type, relative_path,
+                    file_extension = None, format_options = None,
+                    mode = None, recursive = None, wait_for_completion = True):
+        """Load a table in the lakehouse"""
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/lakehouses/{lakehouseId}/tables/{tableName}/load
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/lakehouses/{self.id}/tables/{table_name}/load"
+
+        body = {
+                "relativePath": relative_path,
+                "pathType": path_type,
+              }
+
+        if file_extension:
+            body["fileExtension"] = file_extension
+        if format_options:
+            body["formatOptions"] = format_options
+        if mode:
+            body["mode"] = mode
+        if recursive:
+            body["recursive"] = recursive
+
+        for _ in range(10):
+            response = requests.post(url=url, headers=self.auth.get_headers(), json=body)
+            if response.status_code == 429:
+                print("Too many requests, waiting 10 seconds")
+                sleep(10)
+                continue
+            if response.status_code == 202:
+                if wait_for_completion:
+                    success = self.check_if_table_is_created(table_name)
+                    
+                if not success:
+                    print("Warning: Table not created after 3 minutes")
+                else:
+                    print("Table created")
+            if response.status_code not in (202, 429):
+                print(response.status_code)
+                print(response.text)
+                raise Exception(f"Error loading table: {response.status_code},  {response.text}")
+            break
+
+        return response.status_code
+    
+    def check_if_table_is_created(self, table_name):
+        """Check if the table is created"""
+        for _ in range(60):
+            table_names = [table["name"] for table in self.list_tables()]
+            if table_name in table_names:
+                return True
+            
+            sleep(3)
+        return False
+    

msfabricpysdkcore/tests/test_git.py

@@ -0,0 +1,62 @@
+import unittest
+from msfabricpysdkcore.client 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.client 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,41 @@
+import unittest
+from msfabricpysdkcore.client 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.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.client 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.client 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

@@ -240,14 +240,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 +274,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 +283,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 +303,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 +505,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)

{msfabricpysdkcore-0.0.1.dist-info → msfabricpysdkcore-0.0.3.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: msfabricpysdkcore
-Version: 0.0.1
-Summary: A Microsoft Fabric SDK for Python
+Version: 0.0.3
+Summary: A Python SDK for Microsoft Fabric
 Author: Andreas Rederer
 Project-URL: Homepage, https://github.com/DaSenf1860/ms-fabric-sdk-core
 Classifier: Programming Language :: Python :: 3
@@ -13,9 +13,9 @@ License-File: LICENSE
 Requires-Dist: requests >=2.30.0
 Requires-Dist: azure-identity >=1.15.0
 
-# A Microsoft Fabric SDK for Python
+# A Python SDK for Microsoft Fabric
 
-This is a Python SDK for Microsoft Fabric. It is a wrapper around the REST APIs of Fabric*.
+This is a Python SDK for Microsoft Fabric. It is a wrapper around the REST APIs (v1) of Fabric*.
 
 ![Python hugging a F](assets/fabricpythontransparent.png)
 
@@ -24,15 +24,17 @@ They are designed to automate your Fabric processes.
 
 This SDK helps to interact with the Fabric APIs in a more Pythonic way.
 Additionally it brings some extra features like:
-- Authentication is handled for you (currently Azure CLI Authentification and Service Principal Authentification are supported)
+- Authentication is handled for you (currently Azure CLI Authentication  and Service Principal Authentication are supported)
 - Waiting for completion of long running operations
 - Retry logic when hitting the API rate limits
 - Referencing objects by name instead of ID
-- More granular objects, e.g. a Workpace and Item object instead of referencing IDs all the time
-- Do bulk operations**
-- Pagination support**
+- More granular objects, e.g. a Workspace and Item object instead of referencing IDs all the time
+- Do bulk operations (see [Usage Patterns](usage_patterns.md))
+- Pagination support
 
-Currently it supports all Core APIs, i.e.:
+See the latest release notes [here](releasenotes/release_notes.md).
+
+Currently it supports all Core APIs and Lakehouse APIs, i.e.:
 - [Capacities](#working-with-capacities)
 - [Git](#working-with-git)
 - [Items](#working-with-items)
@@ -40,13 +42,13 @@ Currently it supports all Core APIs, i.e.:
 - Long Running Operations
 - [OneLakeShortcuts](#working-with-one-lake-shortcuts)
 - [Workspaces](#working-with-workspaces)
+- [Lakehouse APIs](#lakehouse-apis)
 
-It is planned to support also the Admin and Lakehouse APIs and new APIs which are not released yet.
+It is planned to support also the Admin APIs and new APIs which are not released yet.
 Eventually Power BI APIs like the Scanner API will be covered as well.
 
 *Because this SDK uses the API in the background, all limitations and restrictions of the API apply to this SDK as well. This includes rate limits, permissions, etc.
 
-**These features are not yet implemented but are planned for the near future.
 
 
 
@@ -160,11 +162,16 @@ ws.delete_role_assignment(principal_id = "abadfbafb")
 
 ```python
 
+
+capacity_object = fc.get_capacity(capacity_id = "0129389012u8938491") 
+#or 
+capacity_object = fc.get_capacity(capacity_name = "sandboxcapacitygermanywc") 
+
 # Assign a capaycity to a workspace
 fc.assign_to_capacity(workspace_id=workspace_id,
-                      capacity_id="capacityid123123")
+                      capacity_id=capacity_object.id)
 # or
-ws.assign_to_capacity(capacity_id="capacityid123123")      
+ws.assign_to_capacity(capacity_id=capacity_object.id)      
 
 # Unassign from capacity
 fc.unassign_from_capacity(workspace_id=ws.id)
@@ -359,7 +366,34 @@ item.cancel_item_job_instance(job_instance_id="job_instance_id")
 
 ```
 
+## Lakehouse APIs
 
+# List tables in a Lakehouse
+
+```python
+from msfabricpysdkcore import FabricClientCore
+
+fc = FabricClientCore()
+ws = fc.get_workspace_by_name("testworkspace")
+lakehouse = ws.get_item_by_name(item_name="lakehouse1", item_type="Lakehouse")
+table_list = lakehouse.list_tables()
+# or
+table_list = ws.list_tables(item_id = "someitemid")
+# or
+table_list = fc.list_tables(workspace_id = "someworkspaceid", item_id = "someitemid")
+
+
+# Load a file (like a csv) into a Lakehouse table
+
+lakehouse.load_table(table_name="testtable", path_type= "File", relative_path="Files/folder1/titanic.csv")
+# or
+ws.load_table(item_id = "someitemid", table_name="testtable",
+              path_type= "File", relative_path="Files/folder1/titanic.csv")
+# or
+fc.load_table(workspace_id = "someworkspaceid", item_id = "someitemid", table_name="testtable",
+              path_type= "File", relative_path="Files/folder1/titanic.csv")
+
+```
 
 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.

msfabricpysdkcore-0.0.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+msfabricpysdkcore/__init__.py,sha256=HJeyM1aLgf9AvUGkU4Olky90YyySletA281VbSa0Q2c,36
+msfabricpysdkcore/auth.py,sha256=1t5prgSg2hK7vMutif2lxHOQk_qTo3152h3FMof3y_4,1929
+msfabricpysdkcore/capacity.py,sha256=PD089m34I0BEXGTzLsF0VfLVDp6sixyDR_uUfQvwV8k,1696
+msfabricpysdkcore/client.py,sha256=j2X3VO44mbB2YW0UNPHoArHl6GE54KS7LsFWFD_F0o0,15047
+msfabricpysdkcore/item.py,sha256=654cssmSKmhCF-scNH8J8TQLB_fVP2oRU8aAAU7zJF0,11086
+msfabricpysdkcore/job_instance.py,sha256=Rjv2u1XXMPVew-9gGFQLrnhzXmYfzlO9SeUvA19DDTI,2759
+msfabricpysdkcore/lakehouse.py,sha256=phXIuKdW0khJMJx_BK2X3TJRPXSJ_9B1QKFnt2k7WH4,4011
+msfabricpysdkcore/long_running_operation.py,sha256=PvrVEuasD9lwdJZ6ElsNwBE1G8xW5uDQ8zXcKqpOpXc,3021
+msfabricpysdkcore/onelakeshortcut.py,sha256=20AZJ79v7FvgKLYbJi0BIaawi6qMjnhqUTIlniwnVBI,2033
+msfabricpysdkcore/workspace.py,sha256=8LJeKwKetm9ASsN19a5C5AU3O2cjR1kWtigxdBKGu0E,21475
+msfabricpysdkcore/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+msfabricpysdkcore/tests/test_git.py,sha256=jrbPu5CNdwbnnbLIQv7Z7hdwXzsZuv3tYG92qBy6_U4,2397
+msfabricpysdkcore/tests/test_items_incl_lakehouse.py,sha256=QT-4saUpIN5AXhY3_A1uIGytlQ6yLcTzPoT11L6IhyE,2940
+msfabricpysdkcore/tests/test_jobs.py,sha256=ee6Dsi1YsBQpF0jESY6yNBbjwB-5OOhIcBGG_d4rId4,1643
+msfabricpysdkcore/tests/test_shortcuts.py,sha256=A7KxKXIRVVavzz9CPcNMJg3SWlnfozYOBZuI1u4GVIg,2389
+msfabricpysdkcore/tests/test_workspaces_capacities.py,sha256=-IeQ6trY2lkgfzuQhoTGtrj07tFlxkStJKN_xaHCJT0,6562
+msfabricpysdkcore-0.0.3.dist-info/LICENSE,sha256=1NrGuF-zOmzbwzk3iI6lsP9koyDeKO1B0-8OD_tTvOQ,1156
+msfabricpysdkcore-0.0.3.dist-info/METADATA,sha256=WsTSN8Gd8zVGsrBiN5CI9VWx-SWOLBIutvuOSuUMZJg,12513
+msfabricpysdkcore-0.0.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+msfabricpysdkcore-0.0.3.dist-info/top_level.txt,sha256=3iRonu6ptDGQN4Yl6G76XGM7xbFNsskiEHW-P2gMQGY,18
+msfabricpysdkcore-0.0.3.dist-info/RECORD,,

msfabricpysdkcore-0.0.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-msfabricpysdkcore/__init__.py,sha256=HJeyM1aLgf9AvUGkU4Olky90YyySletA281VbSa0Q2c,36
-msfabricpysdkcore/auth.py,sha256=1t5prgSg2hK7vMutif2lxHOQk_qTo3152h3FMof3y_4,1929
-msfabricpysdkcore/client.py,sha256=NutMuFGVHUU8CMj2mSJT5Zw1A_vQ-PRJ_yH0nqwk9aI,12536
-msfabricpysdkcore/item.py,sha256=lQODVPxqMLKUwhit7KMDFu3GahW5o7wiWA6KHxMbqu0,10188
-msfabricpysdkcore/job_instance.py,sha256=Rjv2u1XXMPVew-9gGFQLrnhzXmYfzlO9SeUvA19DDTI,2759
-msfabricpysdkcore/long_running_operation.py,sha256=PvrVEuasD9lwdJZ6ElsNwBE1G8xW5uDQ8zXcKqpOpXc,3021
-msfabricpysdkcore/onelakeshortcut.py,sha256=20AZJ79v7FvgKLYbJi0BIaawi6qMjnhqUTIlniwnVBI,2033
-msfabricpysdkcore/workspace.py,sha256=mweliwZup5XKy5yx-BGIvhZboRrtvwFYzQ4JFEICv4E,19796
-msfabricpysdkcore-0.0.1.dist-info/LICENSE,sha256=1NrGuF-zOmzbwzk3iI6lsP9koyDeKO1B0-8OD_tTvOQ,1156
-msfabricpysdkcore-0.0.1.dist-info/METADATA,sha256=-N1T5JesALc6RZ7gJofCmr60ZCjtE8hUV0mEvmqfbyQ,11323
-msfabricpysdkcore-0.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-msfabricpysdkcore-0.0.1.dist-info/top_level.txt,sha256=3iRonu6ptDGQN4Yl6G76XGM7xbFNsskiEHW-P2gMQGY,18
-msfabricpysdkcore-0.0.1.dist-info/RECORD,,