brynq-sdk-brynq 1.1.0__tar.gz → 2.0.1__tar.gz

{brynq_sdk_brynq-1.1.0 → brynq_sdk_brynq-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq_sdk_brynq
-Version: 1.1.0
+Version: 2.0.1
 Summary: BrynQ SDK for the BrynQ.com platform
 Home-page: UNKNOWN
 Author: BrynQ

brynq_sdk_brynq-2.0.1/brynq_sdk/brynq/__init__.py

@@ -0,0 +1 @@
+from brynq_sdk_brynq.brynq import *

{brynq_sdk_brynq-1.1.0 → brynq_sdk_brynq-2.0.1}/brynq_sdk_brynq.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq-sdk-brynq
-Version: 1.1.0
+Version: 2.0.1
 Summary: BrynQ SDK for the BrynQ.com platform
 Home-page: UNKNOWN
 Author: BrynQ

{brynq_sdk_brynq-1.1.0 → brynq_sdk_brynq-2.0.1}/brynq_sdk_brynq.egg-info/SOURCES.txt

@@ -1,6 +1,5 @@
 setup.py
 brynq_sdk/brynq/__init__.py
-brynq_sdk/brynq/brynq.py
 brynq_sdk_brynq.egg-info/PKG-INFO
 brynq_sdk_brynq.egg-info/SOURCES.txt
 brynq_sdk_brynq.egg-info/dependency_links.txt

{brynq_sdk_brynq-1.1.0 → brynq_sdk_brynq-2.0.1}/setup.py

@@ -1,14 +1,13 @@
-from setuptools import setup
-
+from setuptools import setup, find_namespace_packages
 
 setup(
     name='brynq_sdk_brynq',
-    version='1.1.0',
+    version='2.0.1',
     description='BrynQ SDK for the BrynQ.com platform',
     long_description='BrynQ SDK for the BrynQ.com platform',
     author='BrynQ',
     author_email='support@brynq.com',
-    packages=["brynq_sdk.brynq"],
+    packages=find_namespace_packages(include=['brynq_sdk*']),
     license='BrynQ License',
     install_requires=[
         'requests>=2,<=3'

brynq_sdk_brynq-1.1.0/brynq_sdk/brynq/__init__.py

@@ -1 +0,0 @@
-from brynq_sdk.brynq.brynq import BrynQ

brynq_sdk_brynq-1.1.0/brynq_sdk/brynq/brynq.py

@@ -1,273 +0,0 @@
-import os
-import requests
-import json
-import pandas as pd
-from typing import Union, Literal
-
-
-class BrynQ:
-    def __init__(self, subdomain: str = None, api_token: str = None, staging: str = 'prod'):
-        self.subdomain = os.getenv("BRYNQ_SUBDOMAIN", subdomain)
-        self.api_token = os.getenv("BRYNQ_API_TOKEN", api_token)
-        self.environment = os.getenv("BRYNQ_ENVIRONMENT", staging)
-
-        if any([self.subdomain is None, self.api_token is None]):
-            raise ValueError("Set the subdomain, api_token either in your .env file or provide the subdomain and api_token parameters")
-
-        possible_environments = ['dev', 'prod']
-        if self.environment not in possible_environments:
-            raise ValueError(f"Environment should be in {','.join(possible_environments)}")
-
-        self.url = 'https://app.brynq-staging.com/api/v2/' if self.environment == 'dev' else 'https://app.brynq.com/api/v2/'
-
-    def _get_headers(self):
-        return {
-            'Authorization': f'Bearer {self.api_token}',
-            'Domain': self.subdomain
-        }
-
-    def _get_mappings(self, data_interface_id: int) -> dict:
-        """
-        Get the mappings from the task in BrynQ
-        :param data_interface_id: The id of the data_interface in BrynQ. this does not have to be the task id of the current task
-        :return: A dictionary with the following structure: {mapping_title: {tuple(input): output}}
-        """
-        response = requests.get(url=f'{self.url}interfaces/{data_interface_id}/data-mapping', headers=self._get_headers())
-        if response.status_code != 200:
-            raise ValueError(f'Error occurred while fetching mappings: {response.text}. Please always check if you have added BRYNQ_SUBDOMAIN to your .env file')
-
-        return response.json()
-
-    def get_mapping(self, data_interface_id: int, mapping: str, return_format: Literal['input_as_key', 'columns_names_as_keys', 'nested_input_output'] = 'input_as_key') -> dict:
-        """
-        Get the mapping json from the mappings
-        :param data_interface_id: The id of the task in BrynQ. this does not have to be the task id of the current task
-        :param mapping: The name of the mapping
-        :param return_format: Determines how the mapping should be returned. Options are 'input_as_key' (Default, the input column is the key, the output columns are the values), 'columns_names_as_keys', 'nested_input_output'
-        :return: The json of the mapping
-        """
-        # Find the mapping for the given sheet name
-        mappings = self._get_mappings(data_interface_id=data_interface_id)
-        mapping_data = next((item for item in mappings if item['name'] == mapping), None)
-        if not mapping_data:
-            raise ValueError(f"Mapping named '{mapping}' not found")
-
-        # If the user want to get the column names back as keys, transform the data accordingly and return
-        if return_format == 'columns_names_as_keys':
-            final_mapping = []
-            for row in mapping_data['values']:
-                combined_dict = {}
-                combined_dict.update(row['input'])
-                combined_dict.update(row['output'])
-                final_mapping.append(combined_dict)
-        elif return_format == 'nested_input_output':
-            final_mapping = mapping_data
-        else:
-            final_mapping = {}
-            for value in mapping_data['values']:
-                input_values = []
-                output_values = []
-                for _, val in value['input'].items():
-                    input_values.append(val)
-                for _, val in value['output'].items():
-                    output_values.append(val)
-                # Detect if there are multiple input or output columns and concatenate them
-                if len(value['input'].items()) > 1 or len(value['output'].items()) > 1:
-                    concatenated_input = ','.join(input_values)
-                    concatenated_output = ','.join(output_values)
-                    final_mapping[concatenated_input] = concatenated_output
-                else:  # Default to assuming there's only one key-value pair if not concatenating
-                    final_mapping[input_values[0]] = output_values[0]
-        return final_mapping
-
-    def get_mapping_as_dataframe(self, data_interface_id: int, mapping: str, prefix: bool = False):
-        """
-        Get the mapping dataframe from the mappings
-        :param mapping: The name of the mapping
-        :param prefix: A boolean to indicate if the keys should be prefixed with 'input.' and 'output.'
-        :return: The dataframe of the mapping
-        """
-        # Find the mapping for the given sheet name
-        mappings = self._get_mappings(data_interface_id=data_interface_id)
-        mapping_data = next((item for item in mappings if item['name'] == mapping), None)
-        if not mapping_data:
-            raise ValueError(f"Mapping named '{mapping}' not found")
-
-        # Extract the values which contain the input-output mappings
-        values = mapping_data['values']
-
-        # Create a list to hold all row data
-        rows = []
-        for value in values:
-            # Check if prefix is needed and adjust keys accordingly
-            if prefix:
-                input_data = {f'input.{key}': val for key, val in value['input'].items()}
-                output_data = {f'output.{key}': val for key, val in value['output'].items()}
-            else:
-                input_data = value['input']
-                output_data = value['output']
-
-            # Combine 'input' and 'output' dictionaries
-            row_data = {**input_data, **output_data}
-            rows.append(row_data)
-
-        # Create DataFrame from rows
-        df = pd.DataFrame(rows)
-
-        return df
-
-    def get_system_credential(self, system: str, label: Union[str, list], test_environment: bool = False) -> json:
-        """
-        This method retrieves authentication credentials from BrynQ.
-        It returns the json data if the request does not return an error code
-        :param system: specifies which token is used. (lowercase)
-        :param label: reference to the used label
-        :param test_environment: boolean if the test environment is used
-        :return json response from BrynQ
-        """
-        response = requests.get(url=f'{self.url}apps/{system}', headers=self._get_headers())
-        response.raise_for_status()
-        credentials = response.json()
-        # rename parameter for readability
-        if isinstance(label, str):
-            labels = [label]
-        else:
-            labels = label
-        # filter credentials based on label. All labels specified in label parameter should be present in the credential object
-        credentials = [credential for credential in credentials if all(label in credential['labels'] for label in labels)]
-        if system == 'profit':
-            credentials = [credential for credential in credentials if credential['isTestEnvironment'] is test_environment]
-
-        if len(credentials) == 0:
-            raise ValueError(f'No credentials found for {system}')
-        if len(credentials) != 1:
-            raise ValueError(f'Multiple credentials found for {system} with the specified labels')
-
-        return credentials[0]
-
-    def refresh_system_credential(self, system: str, system_id: int) -> json:
-        """
-        This method refreshes Oauth authentication credentials in BrynQ.
-        It returns the json data if the request does not return an error code
-        :param system: specifies which token is used. (lowercase)
-        :param system_id: system id in BrynQ
-        :return json response from BrynQ
-        """
-        response = requests.post(url=f'{self.url}apps/{system}/{system_id}/refresh', headers=self._get_headers())
-        response.raise_for_status()
-        credentials = response.json()
-
-        return credentials
-
-    def get_user_data(self):
-        """
-        Get all users from BrynQ
-        :return: A list of users
-        """
-        return requests.get(url=f'{self.url}users', headers=self._get_headers())
-
-    def get_user_authorization_qlik_app(self,dashboard_id):
-        """
-        Get all users from BrynQ who have access to a qlik dashboard with their entities
-        :return: A list of users and entities
-        """
-        return requests.get(url=f'{self.url}/qlik/{dashboard_id}/users', headers=self._get_headers())
-
-    def get_role_data(self):
-        """
-        Get all roles from BrynQ
-        :return: A list of roles
-        """
-        return requests.get(url=f'{self.url}roles', headers=self._get_headers())
-
-    def create_user(self, user_data: dict) -> requests.Response:
-        """
-        Create a user in BrynQ
-        :param user_data: A dictionary with the following structure:
-        {
-            "name": "string",
-            "username": "string",
-            "email": "string",
-            "language": "string",
-            "salure_connect": bool,
-            "qlik_sense_analyzer": bool,
-            "qlik_sense_professional": bool
-        }
-        :return: A response object
-        """
-        data = {
-            "name": user_data['name'],
-            "username": user_data['username'],
-            "email": user_data['email'],
-            "language": user_data['language'],
-            "products": {
-                "qlikSenseAnalyzer": user_data['qlik_sense_analyzer'],
-                "qlikSenseProfessional": user_data['qlik_sense_professional']
-            }
-        }
-
-        return requests.post(url=f'{self.url}users', headers=self._get_headers(), json=data)
-
-    def update_user(self, user_id: str, user_data: dict) -> requests.Response:
-        """
-        Update a user in BrynQ
-        :param user_id: The id of the user in BrynQ
-        :param user_data: A dictionary with the following structure:
-        {
-            "id": "string",
-            "name": "string",
-            "language": "string",
-            "salureconnect": bool,
-            "qlik sense analyser": bool,
-            "qlik sense professional": false
-        }
-        :return: A response object
-        """
-        data = {
-            "name": user_data['name'],
-            "username": user_data['username'],
-            "email": user_data['email'],
-            "language": user_data['language'],
-            "products": {
-                "qlikSenseAnalyzer": user_data['qlik_sense_analyzer'],
-                "qlikSenseProfessional": user_data['qlik_sense_professional']
-            }
-        }
-
-        return requests.put(url=f'{self.url}users/{user_id}', headers=self._get_headers(), json=data)
-
-    def delete_user(self, user_id: str) -> requests.Response:
-        """
-        Delete a user in BrynQ
-        :param user_id: The id of the user in BrynQ
-        :return: A response object
-        """
-        return requests.delete(url=f'{self.url}users/{user_id}', headers=self._get_headers())
-
-    def overwrite_user_roles(self, user_id: int, roles: list) -> requests.Response:
-        """
-        Overwrite the roles of a user in BrynQ
-        :param user_id: The id of the user in BrynQ
-        :param roles: A list of role ids
-        :return: A response object
-        """
-        data = {
-            "roles": roles
-        }
-
-        return requests.put(url=f'{self.url}users/{user_id}/roles', headers=self._get_headers(), json=data)
-
-    def get_source_system_entities(self, system: str) -> requests.Response:
-        """
-        Get all entities from a source system in BrynQ
-        :param system: The name of the source system
-        :return: A response object
-        """
-        return requests.get(url=f'{self.url}source-systems/{system}/entities', headers=self._get_headers())
-
-    def get_layers(self) -> requests.Response:
-        """
-        Get all layers from a source system in BrynQ
-        :return: A response object
-        """
-        return requests.get(url=f'{self.url}organization-chart/layers', headers=self._get_headers())