brynq-sdk-azure 2.0.1__tar.gz → 2.0.2__tar.gz

{brynq_sdk_azure-2.0.1 → brynq_sdk_azure-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq_sdk_azure
-Version: 2.0.1
+Version: 2.0.2
 Summary: Azure wrapper from BrynQ
 Home-page: UNKNOWN
 Author: BrynQ

brynq_sdk_azure-2.0.2/brynq_sdk_azure/__init__.py

@@ -0,0 +1,3 @@
+from .entra import Entra
+from .azure_connection import AzureConnection
+from .blob_storage import BlobStorage

brynq_sdk_azure-2.0.2/brynq_sdk_azure/azure_connection.py

@@ -0,0 +1,104 @@
+"""
+See how-to on our confluence page for more details.
+Use Azure python sdk to sync the files with Azure Files Share service.
+The config file shall have a settings in a format like:
+    azure_config = {
+            'azure_connection_string' : r'{the azure connection string}'
+            'share_name' : "/sharename/",
+            'parent_dir_path' : r"volume/data/" : ALAWAYS start with a test file, to make sure you don't mess up the other folders/files
+        }
+"""
+
+import os
+import sys
+from azure.storage.fileshare import ShareClient
+
+basedir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(basedir)
+
+
+class AzureConnection:
+    """
+    connection_string: the connection_string which functions as a token for the Azure connection
+    share_name: the share name in Azure
+    """
+    def __init__(self):
+        # This ugly fix is needed so the other packages can run without a config.py file
+        import config
+        self.connection_string = config.azure_config['azure_connection_string']
+        self.share_name = config.azure_config['share_name']
+        self.share_client = ShareClient.from_connection_string(self.connection_string, share_name=self.share_name)
+
+    def list_files_and_dirs(self, dir_client):
+        """
+        List all the files and folders under this directory_path.
+        :param dir_client: The connection to a specified directory
+        :return: two lists consist of files and subfolders separately
+        """
+        my_list = list(dir_client.list_directories_and_files())
+        subdir_list = [x['name'] for x in my_list if x['is_directory'] is True]
+        file_list = [x['name'] for x in my_list if x['is_directory'] is False]
+        return file_list, subdir_list
+
+    def create_directory(self, dir_path):
+        """
+        Create a ShareDirectoryClient from a connection string
+        :param dir_path: The directory_path
+        :return: a share_client which connects with the specified directory,
+                    and a Flag to indicate if this directory exists before
+        """
+        dir_client = self.share_client.get_directory_client(directory_path=dir_path)
+        dir_already_existed = False
+        try:
+            dir_client.create_directory()
+        except:
+            dir_already_existed = True
+        return dir_client, dir_already_existed
+
+
+    def empty_folder(self, dir_client, delete_folder = False):
+        """
+        To empty a folder including all the subfolders and files within.
+        :param dir_client: The share to connect with this directory
+        :param delete_folder: To delete the folder as well. If yes then the whole folder will be removed, otherwise only remove the files.
+        """
+        file_list, subdir_list = self.list_files_and_dirs(dir_client)
+        if len(subdir_list)>0:
+            for subdir in subdir_list:
+                self.empty_folder(dir_client.get_subdirectory_client(subdir), delete_folder=True)
+        for file in file_list:
+            dir_client.delete_file(file)
+        if delete_folder:
+            dir_client.delete_directory()
+
+    def create_subdirectory_and_upload_file(self, parentdir_path, subdir_path, local_file_path, filename):
+        """
+        Create a subfolder and upload files to this folder
+        :param parentdir_path: The parent directory
+        :param subdir_path: the subfolder directory
+        :param local_file_path: local file directory from which to upload the files
+        :param filename: filename to be uploaded
+        :return:
+        """
+        _, _ = self.create_directory(parentdir_path)
+        dir_path = os.path.join(parentdir_path,subdir_path)
+        subdir, dir_already_existed = self.create_directory(dir_path)
+        if dir_already_existed:
+            self.empty_folder(subdir, delete_folder=False)
+        # Upload a file to the subdirectory
+        with open(os.path.join(local_file_path,filename), "rb") as source:
+            subdir.upload_file(file_name=filename, data=source)
+
+    def create_directory_and_upload_file(self, parentdir_path, local_file_path, filename):
+        """
+        Create a folder and upload files to this folder
+        :param parentdir_path: The parent directory
+        :param local_file_path: local file directory from which to upload the files
+        :param filename: filename to be uploaded
+        :return:
+        """
+        # Get the directory client
+        parentdir_dir, _ = self.create_directory(parentdir_path)
+        # Upload a file to the subdirectory
+        with open(os.path.join(local_file_path, filename), "rb") as source:
+            parentdir_dir.upload_file(file_name=filename, data=source)

brynq_sdk_azure-2.0.2/brynq_sdk_azure/blob_storage.py

@@ -0,0 +1,175 @@
+from brynq_sdk_brynq import BrynQ
+from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient, generate_account_sas, ResourceTypes, AccountSasPermissions
+from typing import Union, List, Tuple
+from datetime import datetime, timedelta
+
+
+class BlobStorage(BrynQ):
+    def __init__(self, label: Union[str, List]):
+        super().__init__()
+        self.blob_service_client = self.__get_authentication(label=label)
+
+    def __get_authentication(self, label):
+        credentials = self.get_system_credential(system='azure-blob-storage', label=label)
+        storage_account_name = credentials['storage_account_name']
+        storage_account_key = credentials['storage_account_key']
+        sas_token = generate_account_sas(
+            account_name=storage_account_name,
+            account_key=storage_account_key,
+            resource_types=ResourceTypes(service=True, container=True, object=True),
+            permission=AccountSasPermissions(read=True, write=True, list=True, delete=True, add=True, create=True, update=True, process=True),
+            expiry=datetime.utcnow() + timedelta(hours=1)
+        )
+        blob_service_client = BlobServiceClient(
+            account_url=f"https://{storage_account_name}.blob.core.windows.net",
+            credential=sas_token
+        )
+
+        return blob_service_client
+
+    def get_containers(self):
+        all_containers = self.blob_service_client.list_containers(include_metadata=True)
+        container_list = []
+        for container in all_containers:
+            container_info = {
+                'name': container.name,
+                'last_modified': container.last_modified,
+                'etag': container.etag,
+                'lease_state': container.lease,
+                'has_immutability_policy': container.has_immutability_policy,
+                'has_legal_hold': container.has_legal_hold,
+                'metadata': container.metadata
+            }
+            container_list.append(container_info)
+
+        return container_list
+
+    def get_container(self, container_name: str):
+        """
+        Get a container from the blob storage
+        """
+        container = self.blob_service_client.get_container_client(container_name)
+        return container
+
+    def create_container(self, container_name: str):
+        """
+        Create a container in the blob storage
+        """
+        response = self.blob_service_client.create_container(container_name)
+        return response
+
+    def update_container(self):
+        pass
+
+    def delete_container(self):
+        pass
+
+    def get_folders(self, container_name: str):
+        """
+        Retrieves a list of 'folders' in the specified container.
+        Since Azure Blob Storage uses a flat namespace, folders are simulated using prefixes.
+
+        :param container_name: The name of the container.
+        :return: A list of folder names.
+        """
+        container_client = self.get_container(container_name)
+        blobs_list = container_client.list_blobs()
+
+        folder_set = set()
+        for blob in blobs_list:
+            if '/' in blob.name:
+                folder = blob.name.split('/')[0]
+                folder_set.add(folder)
+        folders = list(folder_set)
+        return folders
+
+    def create_folder(self, container_name: str, folder_name: str):
+        """
+        Create a file with a 0 as content. Because the file is created, the folder is also created. After that the file and the folder are created,
+        delete the file so the folder will stay. According to the azure docs, it should be possible to create empty files, but this is not working.
+        """
+        # Split the url and add the container and folder name in between the url
+        original_url = self.blob_service_client.url.split('?')
+        url = f"{original_url[0]}/{container_name}/{folder_name}/empty_file?{original_url[1]}"
+        blob = BlobClient.from_blob_url(blob_url=url)
+
+        # Now create the file and delete it so the folder will stay
+        response = blob.upload_blob(b"0", blob_type='AppendBlob')
+        blob.delete_blob()
+        return response
+
+    def delete_folder(self, container_name: str, folder_name: str):
+        """
+        Deletes all the blobs (files) within a folder, effectively deleting the folder.
+        :param container_name: The name of the container.
+        :param folder_name: The name of the folder to delete.
+        """
+        container_client = self.get_container(container_name)
+        blobs = container_client.list_blobs(name_starts_with=f"{folder_name}/")
+        for blob in blobs:
+            blob_client = container_client.get_blob_client(blob)
+            blob_client.delete_blob()
+        return f"Deleted folder {folder_name} and all its contents."
+
+    def get_files(self, container_name: str, folder_name: str = ""):
+        """
+        Retrieves all files in a container, optionally filtered by folder.
+        :param container_name: The name of the container.
+        :param folder_name: The name of the folder (optional). If provided, only files in this folder will be listed.
+        :return: A list of file names in the container or folder.
+        """
+        container_client = self.get_container(container_name)
+        blobs_list = container_client.list_blobs(name_starts_with=f"{folder_name}/" if folder_name else "")
+
+        file_list = []
+        for blob in blobs_list:
+            if not blob.name.endswith('/'):  # Exclude folder markers
+                file_list.append(blob.name)
+
+        return file_list
+
+    def upload_file(self, container_name: str, blob_name: str, file_path: str, overwrite: bool = False):
+        """
+        Uploads a single file to Azure Blob Storage.
+        :param container_name: The name of the container to upload to.
+        :param blob_name: The name of the blob (the file name in blob storage).
+        :param file_path: The local path to the file to upload.
+        :param overwrite: Whether to overwrite an existing blob. Default is False.
+        """
+        # Get the container client
+        container_client = self.get_container(container_name)
+
+        # Get the blob client
+        blob_client = container_client.get_blob_client(blob_name)
+
+        # Open the file and upload
+        with open(file_path, "rb") as data:
+            blob_client.upload_blob(data, overwrite=overwrite)
+
+        print(f"Successfully uploaded {file_path} to {blob_client.url}")
+        return blob_client.url
+
+    def upload_files(self, container_name: str, files: List[Tuple[str, str]], overwrite: bool = False):
+        """
+        Uploads multiple files to Azure Blob Storage.
+        :param container_name: The name of the container to upload to.
+        :param files: A list of tuples (blob_name, file_path), where blob_name is the name of the blob in storage, and file_path is the local file path.
+        :param overwrite: Whether to overwrite existing blobs. Default is False.
+        """
+        success = True
+        for blob_name, file_path in files:
+            result = self.upload_file(container_name, blob_name, file_path, overwrite=overwrite)
+            if result is None:
+                success = False
+        return success
+
+    def delete_file(self, container_name: str, blob_name: str):
+        """
+        Deletes a specific file from Azure Blob Storage.
+        :param container_name: The name of the container.
+        :param blob_name: The name of the blob (the file) to delete.
+        """
+        container_client = self.get_container(container_name)
+        blob_client = container_client.get_blob_client(blob_name)
+        blob_client.delete_blob()
+        return f"Deleted file {blob_name} from container {container_name}."

brynq_sdk_azure-2.0.2/brynq_sdk_azure/entra.py

@@ -0,0 +1,339 @@
+from brynq_sdk_brynq import BrynQ
+import urllib.parse
+import warnings
+import requests
+import random
+import string
+import json
+import pandas as pd
+from pandas import json_normalize
+from msal import ConfidentialClientApplication
+from typing import Union, List
+import os
+
+class Entra(BrynQ):
+
+    def __init__(self, label: Union[str, List], debug: bool = False):
+        super().__init__()
+        self.headers = self.__get_headers(label=label)
+        self.endpoint = "https://graph.microsoft.com/v1.0"
+
+    def __get_headers(self, label):
+        credentials = self.get_system_credential(system='azure-entra-token', label=label)
+        tenant_id = credentials['tenant_id']
+        client_id = credentials['client_id']
+        client_secret = credentials['client_secret']
+        authority = f"https://login.microsoftonline.com/{tenant_id}"
+
+        # Create a ConfidentialClientApplication for authentication
+        app = ConfidentialClientApplication(
+            client_id,
+            authority=authority,
+            client_credential=client_secret,
+        )
+
+        # Get an access token for the Graph API
+        result = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
+        headers = {
+            'Authorization': f"Bearer {result['access_token']}",
+            'Content-Type': 'application/json'
+        }
+
+        return headers
+
+    def __add_attribute_information(self, payload, custom_attributes):
+        # First get the official name of the custom attribute and all the other information
+        payload.update({"customSecurityAttributes": {}})
+        metadata = requests.get('https://graph.microsoft.com/v1.0/directory/customSecurityAttributeDefinitions', headers=self.headers).json()
+        # Now loop through the given metadata and add the corresponding metadata and the values itself to the payload
+        for attr, value in custom_attributes.items():
+            for meta in metadata["value"]:
+                if meta["name"] == attr:
+                    attr_set = meta["attributeSet"]
+                    attr_type = meta["type"]
+                    is_collection = meta["isCollection"]
+                    if attr_set not in payload["customSecurityAttributes"]:
+                        payload["customSecurityAttributes"][attr_set] = {"@odata.type": "#microsoft.graph.customSecurityAttributeValue"}
+                    # In case of an integer, the field type should be given as well
+                    if attr_type == "Integer":
+                        if is_collection:
+                            payload["customSecurityAttributes"][attr_set][f"{attr}@odata.type"] = "#Collection(Int32)"
+                        else:
+                            payload["customSecurityAttributes"][attr_set][f"{attr}@odata.type"] = "#Int32"
+                        payload["customSecurityAttributes"][attr_set][attr] = value
+                    # In case of a boolean, only the value should be given, the field type itself is not relevant
+                    elif attr_type == "Boolean":
+                        payload["customSecurityAttributes"][attr_set][attr] = value
+                    # In case of a string, the field type should be given if the field is a collection of values. If it's a single value, the field type is not relevant
+                    else:
+                        if is_collection:
+                            payload["customSecurityAttributes"][attr_set][f"{attr}@odata.type"] = "#Collection(String)"
+                        payload["customSecurityAttributes"][attr_set][attr] = value
+        return payload
+
+    def __generate_password(self):
+        special_characters = string.punctuation
+        digits = string.digits
+        uppercase_letters = string.ascii_uppercase
+        lowercase_letters = string.ascii_lowercase
+
+        # Create a pool of characters
+        pool = special_characters + digits + uppercase_letters + lowercase_letters
+
+        # Ensure at least one character of each type
+        password = random.choice(special_characters)
+        password += random.choice(digits)
+        password += random.choice(uppercase_letters)
+        password += random.choice(lowercase_letters)
+
+        # Fill the remaining length with random characters
+        password += ''.join(random.choice(pool) for _ in range(20 - 4))
+
+        # Shuffle the characters to make the password more random
+        password_list = list(password)
+        random.shuffle(password_list)
+        password = ''.join(password_list)
+
+        return password
+
+    def get_groups(self) -> pd.DataFrame:
+        """
+        Get all groups from Azure Entra
+        :return: pd.DataFrame with the groups
+        """
+        endpoint = "https://graph.microsoft.com/v1.0"
+        df = pd.DataFrame()
+        loop = True
+        url = f"{endpoint}/groups"
+        while loop:
+            response = requests.get(url, headers=self.headers)
+            groups = response.json()['value']
+            df_temp = pd.json_normalize(groups)
+            df = pd.concat([df, df_temp], ignore_index=True)
+            if '@odata.nextLink' in response.json():
+                url = response.json()['@odata.nextLink']
+            else:
+                loop = False
+        df = df.reset_index(drop=True)
+        return df
+
+    def get_group_members(self, group_id: str = '') -> pd.DataFrame:
+        """
+        Get all users from a group in Azure Entra
+        :param group_id: ID of the group. If no ID is given, all possible groups will be returned
+        :return: pd.DataFrame with the users
+        """
+        group_url = "https://graph.microsoft.com/v1.0/groups/"
+        df = pd.DataFrame()
+        while group_url:
+            graph_r = requests.get(group_url, headers=self.headers)
+            graph_json = graph_r.json()
+            groups = graph_json.get('value')
+            for group in groups:
+                print(f"Group ID: {group['id']}, Group Name: {group['displayName']}")
+                # Get users in each group
+                next_url_members = f"https://graph.microsoft.com/v1.0/groups/{group['id']}/members"
+                while next_url_members:
+                    members_r = requests.get(next_url_members, headers=self.headers)
+                    members_json = members_r.json()
+                    members = members_json.get('value')
+                    df_temp = pd.json_normalize(members)
+                    if len(df_temp) > 0:
+                        df_temp['group_id'] = group['id']
+                        df_temp['group'] = group['displayName']
+                        df_temp.rename(columns={'id': 'user_id'}, inplace=True)
+                        df = pd.concat([df, df_temp], ignore_index=True)
+                    next_url_members = members_json.get('@odata.nextLink')
+            group_url = graph_json.get('@odata.nextLink')
+
+        df = df.reset_index(drop=True)
+        return df
+
+    def create_group(self, name: str = '', description: str = '', mail_enabled: bool = False, mail_nickname: str = '', security_enabled: bool = True):
+        """
+        Create a new group in Azure Entra
+        :param name: Name of the group
+        :param description: Description of the group
+        :param mail_enabled: Is the group mail enabled?
+        :param mail_nickname: Mail nickname of the group
+        :param security_enabled: Is the group security enabled?
+        :return: Response of the request
+        """
+        endpoint = "https://graph.microsoft.com/v1.0/groups"
+        payload = {
+            "displayName": f"{name}",
+            "description": f"{description}",
+            "mailEnabled": mail_enabled,
+            "mailNickname": f"{mail_nickname}",
+            "securityEnabled": security_enabled
+        }
+        response = requests.post(endpoint, headers=self.headers, json=payload)
+        return response
+
+    def update_group(self, id: int, name: str = '', description: str = '', mail_enabled: bool = False, mail_nickname: str = '', security_enabled: bool = True):
+        """
+        Create a new group in Azure Entra
+        :param id: ID of the group
+        :param name: Name of the group
+        :param description: Description of the group
+        :param mail_enabled: Is the group mail enabled?
+        :param mail_nickname: Mail nickname of the group
+        :param security_enabled: Is the group security enabled?
+        :return: Response of the request
+        """
+        endpoint = f"https://graph.microsoft.com/v1.0/groups/{id}"
+        payload = {
+            "displayName": f"{name}",
+            "description": f"{description}",
+            "mailEnabled": mail_enabled,
+            "mailNickname": f"{mail_nickname}",
+            "securityEnabled": security_enabled
+        }
+        response = requests.patch(endpoint, headers=self.headers, json=payload)
+        return response
+
+    def delete_group(self, group_id):
+        """
+        Delete a group in Azure Entra
+        :param group_id: ID of the group
+        :return: Response of the request
+        """
+        endpoint = f"https://graph.microsoft.com/v1.0/groups/{group_id}"
+        response = requests.delete(endpoint, headers=self.headers)
+        return response
+
+    def get_users(self, extra_fields: list = [], custom_attributes: bool = False, expand: str = '', expand_select: str = '') -> pd.DataFrame:
+        """
+        Get all users from Azure Entra
+        :param extra_fields: Besided the default fields, you can add extra fields to the request. Put them in a list
+        :param custom_attributes: Get the custom attributes of the users. If True, all the custom attributes will be returned
+        :return: pd.DataFrame with the users
+        """
+        fields = ['businessPhones', 'displayName', 'givenName', 'id', 'jobTitle', 'mail', 'mobilePhone',
+                  'officeLocation', 'preferredLanguage', 'surname', 'userPrincipalName'] + extra_fields
+        fields = ','.join(fields)
+        endpoint = f"https://graph.microsoft.com/v1.0/users?$select={fields}"
+        if custom_attributes:
+            endpoint = f"https://graph.microsoft.com/beta/users?$select={fields},customSecurityAttributes"
+            # Adding expand and select parameters if provided
+        if expand:
+            if expand_select:
+                endpoint += f",&$expand={expand}($select={expand_select})"
+            else:
+                endpoint += f",&$expand={expand}"
+
+        df = pd.DataFrame()
+        while endpoint:
+            response = requests.get(endpoint, headers=self.headers)
+            endpoint = response.json().get('@odata.nextLink')
+            data = response.json().get('value')
+            df_temp = json_normalize(data, sep='.')
+            df_temp = df_temp.drop([col for col in df_temp.columns if 'odata.type' in col], axis=1)
+            df = pd.concat([df, df_temp], ignore_index=True)
+        df = df.reset_index(drop=True)
+        return df
+
+    def create_user(self, account_enabled=True, display_name='', mail_nickname='', user_principal_name='', password='', force_change_password_next_sign_in=False, extra_fields={}, custom_attributes={}):
+        """
+        Create a new user in Azure Entra
+        :param account_enabled: Is the account enabled? By default True
+        :param display_name: Display name of the user
+        :param mail_nickname: Mail nickname of the user (the part before the @)
+        :param user_principal_name: User principal name of the user
+        :param password: Password of the user. If no password is given, a random password will be generated
+        :param force_change_password_next_sign_in: Force the user to change the password on the next sign in. By default False
+        :param extra_fields: Extra fields you want to add to the user. Put them in a dictionary
+        :param custom_attributes: A dictionary with the name of the custom attribute and the value. It could be multiple custom attributes
+        """
+        # Custom attributes are only available in the beta version of the API
+        endpoint = 'https://graph.microsoft.com/beta/users' if custom_attributes else 'https://graph.microsoft.com/v1.0/users'
+        if password == '':
+            password = self.__generate_password()
+
+        payload = {
+            "accountEnabled": account_enabled,
+            "displayName": f"{display_name}",
+            "mailNickname": f"{mail_nickname}",
+            "userPrincipalName": user_principal_name,
+            "passwordProfile": {
+                "forceChangePasswordNextSignIn": force_change_password_next_sign_in,
+                "password": f"{password}"
+            },
+        }
+        payload.update(extra_fields)
+
+        # If there are any custom attributes, add them to the payload. But since the endpoint needs extra metadata, we need to do some extra work
+        if len(custom_attributes) > 0:
+            payload = self.__add_attribute_information(payload, custom_attributes)
+        response = requests.post(endpoint, headers=self.headers, json=payload)
+        return response
+
+    def update_user(self, user_id, fields_to_update: dict = {}, custom_attributes: dict = {}, update_password: bool = False):
+        """
+        Update a user in Azure Entra
+        :param user_id: The Azure AD ID of the user
+        :param fields_to_update: A dictionary with the fields you want to update. Don't put the custom attributes in this dictionary
+        :param custom_attributes: A dictionary with the name of the custom attribute and the value. It could be multiple custom attributes
+        :param update_password: If True, the password will be updated with a random value. If False, the password will not be updated
+        """
+        endpoint = f'https://graph.microsoft.com/beta/users/{user_id}' if len(custom_attributes) > 0 else f'https://graph.microsoft.com/v1.0/users/{user_id}'
+        payload = fields_to_update
+        if update_password:
+            password = self.__generate_password()
+            payload.update({"passwordProfile": {
+                "forceChangePasswordNextSignIn": False,
+                "password": f"{password}"
+            }})
+        if len(custom_attributes) > 0:
+            payload = self.__add_attribute_information(payload, custom_attributes)
+        response = requests.patch(endpoint, headers=self.headers, json=payload)
+        return response
+
+    def delete_user(self, user_id, delete=False):
+        """
+        Delete (soft or hard) a user from Azure Entra
+        :param user_id: The Azure AD ID of the user
+        :param delete: If True, the user will be deleted permanently. If False, the user will be soft deleted
+        """
+        endpoint = f"https://graph.microsoft.com/v1.0/users/{user_id}"
+        if delete:
+            response = requests.delete(endpoint, headers=self.headers)
+        else:
+            payload = {"accountEnabled": False}
+            response = requests.patch(endpoint, headers=self.headers, data=json.dumps(payload))
+        return response
+
+    def assign_user_to_group(self, user_id, group_id):
+        """
+        Assign a user to a group
+        :param user_id: The Azure AD ID of the user
+        :param group_id: The Azure AD ID of the group
+        return: response
+        """
+        url = f"https://graph.microsoft.com/v1.0/groups/{group_id}/members/$ref"
+        data = {"@odata.id": f"https://graph.microsoft.com/v1.0/directoryObjects/{user_id}"}
+        response = requests.post(url, headers=self.headers, data=json.dumps(data))
+        return response
+
+    def update_manager(self, user_id, manager_id):
+        """
+        Update the manager of a user
+        :param user_id: The Azure AD ID of the user
+        :param manager_id: The Azure AD ID of the manager
+        return: response
+        """
+        url = f"https://graph.microsoft.com/v1.0/users/{user_id}/manager/$ref"
+        content ={f"@odata.id": f"https://graph.microsoft.com/v1.0/users/{manager_id}"}
+        response = requests.put(url, headers=self.headers, data=json.dumps(content))
+        return response
+
+    def remove_user_from_group(self, user_id, group_id):
+        """
+        Remove a user from a group
+        :param user_id: The Azure AD ID of the user
+        :param group_id: The Azure AD ID of the group
+        return: response
+        """
+        url = f"https://graph.microsoft.com/v1.0/groups/{group_id}/members/{user_id}/$ref"
+        response = requests.delete(url, headers=self.headers)
+        return response

{brynq_sdk_azure-2.0.1 → brynq_sdk_azure-2.0.2}/brynq_sdk_azure.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq-sdk-azure
-Version: 2.0.1
+Version: 2.0.2
 Summary: Azure wrapper from BrynQ
 Home-page: UNKNOWN
 Author: BrynQ

{brynq_sdk_azure-2.0.1 → brynq_sdk_azure-2.0.2}/brynq_sdk_azure.egg-info/SOURCES.txt

@@ -1,4 +1,8 @@
 setup.py
+brynq_sdk_azure/__init__.py
+brynq_sdk_azure/azure_connection.py
+brynq_sdk_azure/blob_storage.py
+brynq_sdk_azure/entra.py
 brynq_sdk_azure.egg-info/PKG-INFO
 brynq_sdk_azure.egg-info/SOURCES.txt
 brynq_sdk_azure.egg-info/dependency_links.txt

brynq_sdk_azure-2.0.2/brynq_sdk_azure.egg-info/top_level.txt

@@ -0,0 +1 @@
+brynq_sdk_azure

{brynq_sdk_azure-2.0.1 → brynq_sdk_azure-2.0.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_namespace_packages
 
 setup(
     name='brynq_sdk_azure',
-    version='2.0.1',
+    version='2.0.2',
     description='Azure wrapper from BrynQ',
     long_description='Azure wrapper from BrynQ',
     author='BrynQ',

brynq_sdk_azure-2.0.1/brynq_sdk_azure.egg-info/top_level.txt

@@ -1 +0,0 @@
-