msdev-kit 0.1.0__py3-none-any.whl

msdev_kit/__init__.py

@@ -0,0 +1,3 @@
+from .auth import Auth
+
+__version__ = "0.1.0"

msdev_kit/auth.py

@@ -0,0 +1,35 @@
+from azure.identity import ClientSecretCredential, InteractiveBrowserCredential, TokenCachePersistenceOptions
+
+_SCOPES = {
+    'pbi':    'https://analysis.windows.net/powerbi/api/.default',
+    'fabric': 'https://api.fabric.microsoft.com/.default',
+    'azure':  'https://management.azure.com/.default',
+    'graph':  'https://graph.microsoft.com/.default',
+}
+
+
+class Auth:
+
+    def __init__(self, tenant_id: str, client_id: str, client_secret: str):
+        self.tenant_id = tenant_id
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self._credential = ClientSecretCredential(
+            authority='https://login.microsoftonline.com/',
+            tenant_id=tenant_id,
+            client_id=client_id,
+            client_secret=client_secret,
+        )
+
+    def get_token(self, service: str = 'pbi') -> str:
+        scope = _SCOPES.get(service)
+        if not scope:
+            raise ValueError(f"Invalid service specified. Choose one of: {', '.join(_SCOPES)}")
+        return self._credential.get_token(scope).token
+
+    def get_token_for_user(self, service: str = 'pbi') -> str:
+        scope = _SCOPES.get(service)
+        if not scope:
+            raise ValueError(f"Invalid service specified. Choose one of: {', '.join(_SCOPES)}")
+        auth = InteractiveBrowserCredential(cache_persistence_options=TokenCachePersistenceOptions())
+        return auth.get_token(scope).token

msdev_kit/fabric/__init__.py

@@ -0,0 +1,11 @@
+from .workspace import Workspace
+from .dataset import Dataset
+from .report import Report
+from .dataflow import Dataflow
+from .capacity import Capacity
+from .admin import Admin
+from .operations import Operations
+from .kql import KQLDatabase
+from .database import Database
+from .pipeline import Pipeline
+from .notebook import Notebook

msdev_kit/fabric/admin.py

@@ -0,0 +1,42 @@
+import requests
+import json
+from typing import Dict
+
+class Admin:
+
+    def __init__(self, token: str):
+        """
+        Initialize variables for Power BI Admin API interactions.
+
+        Args:
+            token (str): The bearer token for authorization.
+        """
+        self.main_url = 'https://api.powerbi.com/v1.0/myorg/admin'
+        self.token = token
+        self.headers = {'Authorization': f'Bearer {self.token}'}
+        
+
+    def get_report_users_as_admin(self, report_id: str) -> Dict:
+        """
+        Retrieves a list of users with access to a specific report as an administrator.
+
+        Args:
+            report_id (str): The ID of the report to get users for.
+
+        Returns:
+            Dict: A dictionary containing the status message and content (list of users).
+        """
+        request_url = f'{self.main_url}/reports/{report_id}/users'
+        
+        r = requests.get(url=request_url, headers=self.headers)
+
+        status = r.status_code
+        response = json.loads(r.content)
+
+        if status == 200:
+            return {'message': 'Success', 'content': response.get('value', [])}
+        else:
+            error_message = response.get('error', {}).get('message', 'Unknown error')
+            return {'message': {'error': error_message, 'status_code': status}, 'content': ''}
+
+

msdev_kit/fabric/capacity.py

@@ -0,0 +1,186 @@
+import os
+import json
+import requests
+import pandas as pd
+from typing import Dict
+from .utilities import create_directory
+from .workspace import Workspace
+
+
+class Capacity:
+
+    def __init__(self, pbi_token: str, fabric_token: str = None, azure_token: str = None):
+        """
+        Initialize variables.
+        """
+        # Power BI Capacity parameters
+        self.main_url = 'https://api.powerbi.com/v1.0/myorg'
+
+        # Fabric Capacity parameters
+        self.fabric_api_base_url = 'https://management.azure.com'
+        self.azure_subscription_id = None
+        self.azure_resource_group = None
+
+        # General parameters
+        self.token = pbi_token
+        self.headers = {'Authorization': f'Bearer {self.token}'}
+        self.workspace = Workspace(self.token)
+
+        # Directories
+        self.capacities_dir = './data/capacities'
+        self.directories = [self.capacities_dir]
+
+        for dir in self.directories:
+            create_directory(dir)
+
+
+    def list_powerbi_capacities(self) -> Dict:
+        """
+        List all Power BI capacities that the user has access to.
+
+        Args:
+            None.
+
+        Returns:
+            Dict: status message and content.
+        """
+        
+        # Main URL
+        request_url = f'{self.main_url}/capacities'
+
+        filename = f'capacities_powerbi.xlsx'
+
+        # Make the request
+        r = requests.get(url=request_url, headers=self.headers)
+
+        # Get HTTP status and content
+        status = r.status_code
+        response = json.loads(r.content).get('value', '')
+
+        # If success...
+        if status == 200:
+            if type == 'fabric':
+                df = pd.json_normalize(response)
+                df['name'] = df['displayName']
+                df.drop(columns=['displayName'], inplace=True)
+            else:
+                df = pd.DataFrame(response)
+            df.to_excel(f'{self.capacities_dir}/{filename}', index=False)
+            result = json.loads(df.to_json(orient='records'))
+
+            return {'message': 'Success', 'content': result}
+
+        else:                
+            # If any error happens, return message.
+            response = json.loads(r.content)
+            error_message = response['error']['message']
+
+            return {'message': {'error': error_message, 'content': response}}
+
+
+    def list_fabric_capacities(self, azure_subscription_id: str, azure_resource_group: str = None) -> Dict:
+        """
+        List all Fabric capacities that the user has access to, to a given subscription.
+        
+        If a resource group is provided, only capacities within that resource group will be listed.
+
+        Args:
+            azure_subscription_id (str): Azure subscription ID.
+            azure_resource_group (str, optional): Azure resource group. Defaults to None.
+
+        Returns:
+            Dict: status message and content.
+        """
+        
+        # Main URL
+        if azure_resource_group:
+            request_url = f'{self.fabric_api_base_url}/subscriptions/{azure_subscription_id}/resourceGroups/{azure_resource_group}/providers/Microsoft.Fabric/capacities?api-version=2023-11-01'
+        else:
+            request_url = f'{self.fabric_api_base_url}/subscriptions/{azure_subscription_id}/providers/Microsoft.Fabric/capacities?api-version=2023-11-01'
+
+        filename = f'capacities_powerbi.xlsx'
+
+        # Make the request
+        r = requests.get(url=request_url, headers=self.headers)
+
+        # Get HTTP status and content
+        status = r.status_code
+        response = json.loads(r.content).get('value', '')
+
+        # If success...
+        if status == 200:
+            if type == 'fabric':
+                df = pd.json_normalize(response)
+                df['name'] = df['displayName']
+                df.drop(columns=['displayName'], inplace=True)
+            else:
+                df = pd.DataFrame(response)
+            df.to_excel(f'{self.capacities_dir}/{filename}', index=False)
+            result = json.loads(df.to_json(orient='records'))
+
+            return {'message': 'Success', 'content': result}
+
+        else:                
+            # If any error happens, return message.
+            response = json.loads(r.content)
+            error_message = response['error']['message']
+
+            return {'message': {'error': error_message, 'content': response}}
+
+
+    def assign_workspace_to_capacity(
+                self, 
+                workspace_id: str = '',
+                capacity_id: str = '') -> Dict:
+        """
+        Assign a workspace to a specific capacity.
+
+        Args:
+            workspace_id (str): workspace id to add the user to.
+            capacity_id (str): capacity id to assign the workspace to.
+
+        Returns:
+            Dict: status message.
+        """
+
+        # If both workspace and capacity were provided...
+        if (workspace_id != '') & (capacity_id != ''):
+
+            ws = self.workspace.get_worspace_details(workspace_id)
+            workspace_name = ws.get('content', {}).get('name', None)
+            current_capacity_id = ws.get('content', {}).get('capacityId', None)
+
+            if current_capacity_id.lower() == capacity_id.lower():
+                return {'message': 'Workspace is already assigned to the specified capacity.'}
+
+            request_url = self.main_url + f'/groups/{workspace_id}/AssignToCapacity'
+
+            headers = {'Authorization': f'Bearer {self.token}'}
+
+            # https://learn.microsoft.com/en-us/rest/api/power-bi/capacities/groups-assign-to-capacity
+            data = {
+                "capacityId": capacity_id
+            }
+
+            # Make the request
+            r = requests.post(url=request_url, headers=headers, json=data)
+
+            # Get HTTP status and content
+            status = r.status_code
+
+            # If success...
+            if status == 200:
+                return {'message': 'Success'}
+            
+            elif status == 401:
+                return {'message': 'Unauthorized. Please check your access level. Workspace administration rights are required to perform this action.'}
+            
+            else:                
+                # If any error happens, return message.
+                response = json.loads(r.content)
+                error_message = response['error']['code']
+
+                return {'message': {'error': {'status': status, 'description': ''}, 'content': response.content}}
+
+        else:
+            return {'message': 'Missing parameters, please check.', 'content': ''}

msdev_kit/fabric/database.py

@@ -0,0 +1,94 @@
+import os
+import pandas as pd
+from typing import Literal
+from sqlalchemy import create_engine
+from sqlalchemy.exc import SQLAlchemyError
+
+
+class Database:
+
+    def __init__(self, server: str, database: str, client_id: str, client_secret: str):
+        self.server = server
+        self.database = database
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.data_dir = f'./data/lakehouse/{database}'
+
+    
+    def __create_sqlalchemy_engine(self):
+        """
+        Creates a SQLAlchemy engine for a SQL Server database using Active Directory Service Principal authentication.
+        """
+        connection_string = (
+            f"mssql+pyodbc:///?odbc_connect="
+            f"DRIVER={{ODBC Driver 18 for SQL Server}};"
+            f"SERVER={self.server};"
+            f"DATABASE={self.database};"
+            f"Authentication=ActiveDirectoryServicePrincipal;"
+            f"UID={self.client_id};"
+            f"PWD={self.client_secret}"
+        )
+        
+        try:
+            # Create the SQLAlchemy engine
+            engine = create_engine(connection_string)
+            return engine
+        except SQLAlchemyError as e:
+            print("Error while creating the SQLAlchemy engine:", e)
+            raise
+
+
+    def execute_query(self, query: str):
+
+        # Create the SQLAlchemy engine
+        engine = self.__create_sqlalchemy_engine()
+
+        try:
+            # Use a 'with' block to ensure the connection is closed
+            with engine.connect() as connection:
+                df = pd.read_sql(query, connection)
+
+                current_timestamp = pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')
+
+                os.makedirs(f'{self.data_dir}/{self.database}', exist_ok=True)
+                df.to_csv(f'{self.data_dir}/{self.database}/query_result_{current_timestamp}.csv', index=False, encoding='utf-8-sig')
+                list_of_dicts = df.to_dict(orient='records')
+
+                return {'message': 'Success', 'content': {'rows': list_of_dicts}}
+
+        except (SQLAlchemyError, ConnectionError) as e:
+            return {'message': 'Error', 'content': str(e)}
+        
+
+    def write_dataframe(
+        self,
+        df: pd.DataFrame,
+        table_name: str,
+        schema: str = "dbo",
+        if_exists: Literal["fail", "replace", "append", "delete_rows"] = "append",
+        chunksize: int = 10000
+    ):
+        if df.empty:
+            return {'message': 'Skipped', 'content': 'DataFrame is empty'}
+
+        engine = self.__create_sqlalchemy_engine()
+
+        try:
+            with engine.begin() as connection:
+                df.to_sql(
+                    name=table_name,
+                    con=connection,
+                    schema=schema,
+                    if_exists=if_exists,
+                    index=False,
+                    chunksize=chunksize,
+                    method=None  # required for fast_executemany
+                )
+
+            return {
+                'message': 'Success',
+                'content': f'{len(df)} rows written to {schema}.{table_name}'
+            }
+
+        except SQLAlchemyError as e:
+            return {'message': 'Error', 'content': str(e)}