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

msfabricpysdkcore/environment.py

@@ -1,9 +1,4 @@
-import json 
-import requests
-from time import sleep
-
 from msfabricpysdkcore.item import Item
-from msfabricpysdkcore.long_running_operation import check_long_running_operation
 
 class Environment(Item):
     """Class to represent a item in Microsoft Fabric"""
@@ -11,48 +6,19 @@ class Environment(Item):
     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 from_dict(item_dict, auth):
+    def from_dict(item_dict, core_client):
         return Environment(id=item_dict['id'], display_name=item_dict['displayName'], type=item_dict['type'], workspace_id=item_dict['workspaceId'],
             properties=item_dict.get('properties', None),
             definition=item_dict.get('definition', None), description=item_dict.get('description', ""),
-            auth=auth)
+            auth=core_client)
 
-    # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/sparkcompute
     def get_published_settings(self):
         """Get the published settings of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/sparkcompute"
-
-        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):
-                raise Exception(f"Error getting published settings: {response.status_code}, {response.text}")
-            break
-
-        resp_json = json.loads(response.text)        
-        return resp_json
+        return self.core_client.get_published_settings(self.workspace_id, self.id)
     
-    # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/sparkcompute
-
     def get_staging_settings(self):
         """Get the staging settings of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/sparkcompute"
-
-        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):
-                raise Exception(f"Error getting staging settings: {response.status_code}, {response.text}")
-            break
-
-        resp_json = json.loads(response.text)        
-        return resp_json
+        return self.core_client.get_staging_settings(self.workspace_id, self.id)
 
 
     def update_staging_settings(self,
@@ -60,151 +26,26 @@ class Environment(Item):
                                 executor_cores = None, executor_memory = None, instance_pool = None,
                                 runtime_version = None, spark_properties = None):
         """Update the staging settings of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/sparkcompute"
-        body = {}
-        if driver_cores is not None:
-            body['driverCores'] = driver_cores
-        if driver_memory is not None:
-            body['driverMemory'] = driver_memory
-        if dynamic_executor_allocation is not None:
-            body['dynamicExecutorAllocation'] = dynamic_executor_allocation
-        if executor_cores is not None:
-            body['executorCores'] = executor_cores
-        if executor_memory is not None:
-            body['executorMemory'] = executor_memory
-        if instance_pool is not None:
-            body['instancePool'] = instance_pool
-        if runtime_version is not None:
-            body['runtimeVersion'] = runtime_version
-        if spark_properties is not None:
-            body['sparkProperties'] = spark_properties
-
-        
-        for _ in range(10):
-            response = requests.patch(url=url, headers=self.auth.get_headers(), json=body)
-            if response.status_code == 429:
-                print("Too many requests, waiting 10 seconds")
-                sleep(10)
-                continue
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error updating staging settings: {response.status_code}, {response.text}")
-            break
-
-        return json.loads(response.text)
-
-#  GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/libraries
+        return self.core_client.update_staging_settings(self.workspace_id, self.id, driver_cores, driver_memory,
+                                                        dynamic_executor_allocation, executor_cores, executor_memory,
+                                                        instance_pool, runtime_version, spark_properties)
 
     def get_published_libraries(self):
         """Get the published libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/libraries"
-
-        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):
-                raise Exception(f"Error getting published libraries: {response.status_code}, {response.text}")
-            break
-
-        resp_json = json.loads(response.text)
-        return resp_json
+        return self.core_client.get_published_libraries(self.workspace_id, self.id)
     
-# GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries
-
     def get_staging_libraries(self):
         """Get the staging libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/libraries"
-
-        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):
-                raise Exception(f"Error getting staging libraries: {response.status_code}, {response.text}")
-            break
-
-        resp_json = json.loads(response.text)
-        return resp_json
+        return self.core_client.get_staging_libraries(self.workspace_id, self.id)
     
-
     def upload_staging_library(self, file_path):
-        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries
-        raise NotImplementedError("Not implemented yet")
-        # url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/libraries"
-        # with open(file_path, 'rb') as f:
-        #     files = {"upload_file.whl": f}
-        #     for _ in range(10):
-        #         response = requests.post(url=url, files=files, headers=self.auth.get_headers())
-        #         if response.status_code == 429:
-        #             print("Too many requests, waiting 10 seconds")
-        #             sleep(10)
-        #             continue
-        #         if response.status_code not in (200, 429):
-        #             raise Exception(f"Error uploading staging libraries: {response.status_code}, {response.text}")
-        #         break
-
-        # return json.loads(response.text)
+        return self.core_client.upload_staging_library(self.workspace_id, self.id, file_path)
     
-# DELETE https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/libraries?libraryToDelete={libraryToDelete}
-
     def delete_staging_library(self, library_to_delete):
-        """Delete a library from the staging libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/libraries?libraryToDelete={library_to_delete}"
-
-        for _ in range(10):
-            response = requests.delete(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):
-                raise Exception(f"Error deleting staging libraries: {response.status_code}, {response.text}")
-            break
-
-        return response.text
+        return self.core_client.delete_staging_library(self.workspace_id, self.id, library_to_delete)
     
-# POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/publish
-
     def publish_environment(self):
-        """Publish the staging settings and libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/publish"
-
-        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:
-                publish_info = check_long_running_operation(response.headers, self.auth)
-                return publish_info
-            if response.status_code not in (200, 429):
-                raise Exception(f"Error publishing staging: {response.status_code}, {response.text}")
-            break
-
-        resp_dict = json.loads(response.text)
-        return resp_dict
-
-
-# POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/environments/{environmentId}/staging/cancelPublish
+        return self.core_client.publish_environment(self.workspace_id, self.id) 
 
     def cancel_publish(self):
-        """Cancel the publishing of the staging settings and libraries of the environment"""
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/environments/{self.id}/staging/cancelPublish"
-
-        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 not in (200, 429):
-                raise Exception(f"Error canceling publishing: {response.status_code}, {response.text}")
-            break
-
-        resp_dict = json.loads(response.text)
-        return resp_dict
+        return self.core_client.cancel_publish(self.workspace_id, self.id)

msfabricpysdkcore/fabric_azure_capacity.py

@@ -0,0 +1,77 @@
+import json 
+
+from msfabricpysdkcore.fabric_azure_client import FabricAzureClient
+
+class FabricAzureCapacity:
+    """Class to represent a item in Microsoft Fabric"""
+
+    def __init__(self, id, name, subscription_id, resource_group_name, type, location, properties, sku, azure_client: FabricAzureClient, tags=None) -> None:
+        
+        self.id = id
+        self.name = name
+        self.subscription_id = subscription_id
+        self.resource_group_name = resource_group_name
+        self.type = type
+        self.location = location
+        self.properties = properties
+        self.sku = sku
+        self.tags = tags
+
+        self.azure_client = azure_client
+
+    def __str__(self) -> str:
+        """Return a string representation of the fabric azure capacity object"""
+        dict_ = {
+            'id': self.id,
+            'name': self.name,
+            'subscription_id': self.subscription_id,
+            'resource_group_name': self.resource_group_name,
+            'type': self.type,
+            'location': self.location,
+            'properties': self.properties,
+            'sku': self.sku,
+            'tags': self.tags
+        }
+        return json.dumps(dict_, indent=2)
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def from_dict(dict, azure_client):
+        """Create FabricAzureCapacity object from dictionary"""
+            
+        return FabricAzureCapacity(id=dict['id'], name=dict['name'], subscription_id=dict['subscription_id'],
+                                   resource_group_name=dict['resource_group_name'],
+                                   type=dict['type'],
+                                   location=dict['location'],
+                                   properties=dict['properties'], sku=dict['sku'],
+                                   tags=dict.get('tags', None), azure_client=azure_client)
+    
+    # Delete
+
+    def delete(self):
+        """Delete the capacity"""
+
+        return self.azure_client.delete_capacity(self.subscription_id, self.resource_group_name, self.name)
+    
+    # Resume
+
+    def resume(self):
+        """Resume the capacity"""
+
+        return self.azure_client.resume_capacity(self.subscription_id, self.resource_group_name, self.name)
+    
+    # Suspend
+
+    def suspend(self):
+        """Suspend the capacity"""
+
+        return self.azure_client.suspend_capacity(self.subscription_id, self.resource_group_name, self.name)
+    
+    # Update
+
+    def update(self, properties_administration=None, sku=None, tags=None):
+        """Update the capacity"""
+
+        return self.azure_client.update_capacity(self.subscription_id, self.resource_group_name, self.name, properties_administration=properties_administration, sku=sku, tags=tags)
+

msfabricpysdkcore/fabric_azure_client.py

@@ -0,0 +1,228 @@
+from msfabricpysdkcore.client import FabricClient
+
+
+class FabricAzureClient(FabricClient):
+
+    def __init__(self, tenant_id=None, client_id=None, client_secret=None, silent=False) -> None:
+        super().__init__(scope = "https://management.azure.com/",
+                         tenant_id = tenant_id,
+                         client_id = client_id,
+                         client_secret = client_secret,
+                         silent = silent)
+
+
+    def check_name_availability(self, subscription_id, location, name, type = "Microsoft.Fabric/capacities"):
+        """Check name availability
+        Args:
+            subscription_id (str): The subscription ID
+            location (str): The location
+            name (str): The name
+            type (str): The type
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/providers/Microsoft.Fabric/locations/{location}/checkNameAvailability?api-version=2023-11-01"
+
+        body = {
+            "name": name,
+            "type": type
+        }
+
+        response = self.calling_routine(url=url, operation="POST", body=body, response_codes=[200], return_format="json", error_message="Failed to check name availability")
+        return response
+
+    def create_or_update_capacity(self, subscription_id, resource_group_name, capacity_name, location, properties_administration, sku, tags = None):
+        """Create or update capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+            location (str): The location
+            properties_administration (dict): The administration properties
+            sku (dict): The sku
+            tags (dict): The tags
+        Returns:
+            FabricAzureCapacity: The capacity
+        """
+        from msfabricpysdkcore.fabric_azure_capacity import FabricAzureCapacity
+
+        if sku and "name" in sku:
+            sku = sku["name"]
+
+        body = {
+            "location": location,
+            "properties": {
+                "administration": properties_administration
+            },
+            "sku": {"name": sku,
+                    "tier": "Fabric"}
+        }
+
+        if tags is not None:
+            body["tags"] = tags
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="PUT", body=body, response_codes=[200, 201], return_format="json", error_message="Failed to create or update capacity")
+        response["subscription_id"] = subscription_id
+        response["resource_group_name"] = resource_group_name
+
+        return FabricAzureCapacity.from_dict(response, self)
+
+
+    def delete_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """Delete capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="DELETE", response_codes=[202], return_format="response", error_message="Failed to delete capacity")
+        return response
+
+
+    def get_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """Get capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            FabricAzureCapacity: The capacity
+        """
+        from msfabricpysdkcore.fabric_azure_capacity import FabricAzureCapacity
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="json", error_message="Failed to get capacity")
+        response["subscription_id"] = subscription_id
+        response["resource_group_name"] = resource_group_name
+
+        return FabricAzureCapacity.from_dict(response, self)
+
+    def list_by_resource_group(self, subscription_id, resource_group_name):
+        """List capacities by resource group
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="value_json", error_message="Failed to list capacities by resource group")
+        return response
+
+
+    def list_by_subscription(self, subscription_id):
+        """List capacities by subscription
+        Args:
+            subscription_id (str): The subscription ID
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="value_json", error_message="Failed to list capacities by subscription")
+        return response
+
+    def list_skus(self, subscription_id):
+        """List skus
+        Args:
+            subscription_id (str): The subscription ID
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/providers/Microsoft.Fabric/skus?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="value_json", error_message="Failed to list skus")
+        return response
+    
+    def list_skus_for_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """List skus for capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}/skus?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="GET", response_codes=[200], return_format="value_json", error_message="Failed to list skus for capacity")
+        return response
+
+    def resume_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """Resume capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}/resume?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="POST", response_codes=[202], return_format="response", error_message="Failed to resume capacity")
+        return response
+
+    def suspend_capacity(self, subscription_id, resource_group_name, capacity_name):
+        """Suspend capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+        Returns:
+            dict: The response
+        """
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}/suspend?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="POST", response_codes=[202], return_format="response", error_message="Failed to suspend capacity")
+        return response
+    
+    def update_capacity(self, subscription_id, resource_group_name, capacity_name, properties_administration = None, sku = None, tags = None):
+        """Update capacity
+        Args:
+            subscription_id (str): The subscription ID
+            resource_group_name (str): The resource group name
+            capacity_name (str): The capacity name
+            body (dict): The body of the request
+        Returns:
+            FabricAzureCapacity: The capacity
+        """
+        from msfabricpysdkcore.fabric_azure_capacity import FabricAzureCapacity
+
+        body = {}
+        if sku and "name" in sku:
+            sku = sku["name"]
+
+        if properties_administration is not None:
+            body["properties"] = {}
+            body["properties"]["administration"] = properties_administration
+
+        if sku is not None:
+            body["sku"] = {"name": sku,
+                           "tier": "Fabric"}
+        
+        if tags is not None:
+            body["tags"] = tags
+
+        url = f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Fabric/capacities/{capacity_name}?api-version=2023-11-01"
+
+        response = self.calling_routine(url=url, operation="PATCH", body=body, response_codes=[200, 202],
+                                        return_format="json", error_message="Failed to update capacity")
+        response["subscription_id"] = subscription_id
+        response["resource_group_name"] = resource_group_name
+
+        return FabricAzureCapacity.from_dict(response, self)