brynq-sdk-azure 3.0.3__py3-none-any.whl

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/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/blob_storage.py

@@ -0,0 +1,176 @@
+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, Literal, Optional
+from datetime import datetime, timedelta
+
+
+class BlobStorage(BrynQ):
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None):
+        super().__init__()
+        self.blob_service_client = self._get_authentication(system_type)
+
+    def _get_authentication(self, system_type):
+        credentials = self.interfaces.credentials.get(system='azure-blob-storage', system_type=system_type)
+        credentials = credentials.get('data')
+        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/entra.py

@@ -0,0 +1,348 @@
+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, Literal, Optional
+import os
+
+
+class Entra(BrynQ):
+
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, debug: bool = False):
+        super().__init__()
+        self.headers = self.__get_headers(system_type)
+        self.endpoint = "https://graph.microsoft.com/v1.0"
+        self.timeout = 3600
+
+    def __get_headers(self, system_type):
+        credentials = self.interfaces.credentials.get(system='azure-entra-o-auth-2', system_type=system_type)
+        credentials_data = credentials.get('data')
+        if credentials.get("type") == 'custom':
+            tenant_id = credentials_data.get('tenant_id')
+            client_id = credentials_data.get('client_id')
+            client_secret = credentials_data.get('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"])
+            access_token = result.get('access_token')
+        elif credentials.get("type") == 'oauth2':
+            access_token = credentials_data.get('access_token')
+        else:
+            raise ValueError("The retrieved credentials are not part of the supported system types, please extend the SDK to support the specified type")
+
+        headers = {
+            'Authorization': f"Bearer {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, timeout=self.timeout).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, timeout=self.timeout)
+            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, timeout=self.timeout)
+            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, timeout=self.timeout)
+                    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, timeout=self.timeout)
+        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, timeout=self.timeout)
+        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, timeout=self.timeout)
+        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, timeout=self.timeout)
+            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, timeout=self.timeout)
+        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, timeout=self.timeout)
+        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, timeout=self.timeout)
+        else:
+            payload = {"accountEnabled": False}
+            response = requests.patch(endpoint, headers=self.headers, data=json.dumps(payload), timeout=self.timeout)
+        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), timeout=self.timeout)
+        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), timeout=self.timeout)
+        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, timeout=self.timeout)
+        return response

brynq_sdk_azure-3.0.3.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: brynq_sdk_azure
+Version: 3.0.3
+Summary: Azure wrapper from BrynQ
+Author: BrynQ
+Author-email: support@brynq.com
+License: BrynQ License
+Requires-Dist: brynq-sdk-brynq<5,>=4
+Requires-Dist: azure-storage-file-share>=12.6.0
+Requires-Dist: azure-storage-blob>=12.16.0
+Requires-Dist: msal==1.22.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+Azure wrapper from BrynQ

brynq_sdk_azure-3.0.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+brynq_sdk_azure/__init__.py,sha256=XYZRt17_SuLmTJo6kGG9s7NvtOTjLbShRuie7Va9C_4,109
+brynq_sdk_azure/azure_connection.py,sha256=PukXpOLCCwbuRO_pDwwezfl_JjSP91oFsC55UO5Gex0,4657
+brynq_sdk_azure/blob_storage.py,sha256=YTe1zDZvdalvCciwW8unwbDZIlGEzcHUZTh__Ub88Hg,7830
+brynq_sdk_azure/entra.py,sha256=5qsvrxuHipYPS2lg42Kyn70pfs7V1LNRDdz2NIpJ1tU,17324
+brynq_sdk_azure-3.0.3.dist-info/METADATA,sha256=4oKuNPdmAWc1cLKPNQmK27I1xpKZEh-ZsTCeUr5OIqE,460
+brynq_sdk_azure-3.0.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+brynq_sdk_azure-3.0.3.dist-info/top_level.txt,sha256=AkGDvcXu0eRp1oApJBx26dzC_CYW8kxXxGgQUSutmAk,16
+brynq_sdk_azure-3.0.3.dist-info/RECORD,,

brynq_sdk_azure-3.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

brynq_sdk_azure-3.0.3.dist-info/top_level.txt

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