brynq-sdk-brynq 4.2.6.dev0__py3-none-any.whl

brynq_sdk_brynq/__init__.py

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

brynq_sdk_brynq/brynq.py

@@ -0,0 +1,289 @@
+import os
+import requests
+import pandas as pd
+import warnings
+from typing import Union, Literal, Optional, List, Dict, Any
+from .users import Users
+from .organization_chart import OrganizationChart
+from .source_systems import SourceSystems
+from .customers import Customers
+from .interfaces import Interfaces
+from .roles import Roles
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+
+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)
+        self.timeout = 3600
+        self.data_interface_id = os.getenv("DATA_INTERFACE_ID")
+        if self.data_interface_id is None:
+            raise ValueError("BRYNQ_DATA_INTERFACE_ID environment variable is not set, you should use this class via the TaskScheduler or set the variable in your code with:"
+                             "os.environ['DATA_INTERFACE_ID'] = str(self.data_interface_id). This is better than setting it in your .env where you will have to change it when switching between interfaces.")
+
+        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/'
+
+        # Initialize session with retry strategy. This is called brynq_session and not session as to not conflict with other SDKs that use self.session
+        self.brynq_session = requests.Session()
+        retry_strategy = Retry(
+            total=3,  # number of retries
+            backoff_factor=0.5,  # wait 0.5s * (2 ** (retry - 1)) between retries
+            status_forcelist=[500, 502, 503, 504]  # HTTP status codes to retry on
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.brynq_session.mount("http://", adapter)
+        self.brynq_session.mount("https://", adapter)
+        self.brynq_session.headers.update(self._get_headers())
+
+        # Initialize components
+        self.users = Users(self)
+        self.organization_chart = OrganizationChart(self)
+        self.source_systems = SourceSystems(self)
+        self.customers = Customers(self)
+        self.interfaces = Interfaces(self)
+        self.roles = Roles(self)
+
+    def _get_headers(self):
+        return {
+            'Authorization': f'Bearer {self.api_token}',
+            'Domain': self.subdomain
+        }
+
+    def get_mapping(self, mapping: str, return_format: Literal['input_as_key', 'columns_names_as_keys', 'nested_input_output'] = 'input_as_key') -> dict:
+        """
+        DEPRECATED: Use brynq.mappings.get_mapping() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.interfaces.mappings.get() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        """
+        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.interfaces.mappings._get_mappings()
+        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
+                    if output_values:
+                        final_mapping[input_values[0]] = output_values[0]
+
+        return final_mapping
+
+    def get_mapping_as_dataframe(self, mapping: str, prefix: bool = False) -> pd.DataFrame:
+        """
+        DEPRECATED: Use brynq.mappings.get_mapping_as_dataframe() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.interfaces.mappings.get(as_df = True) instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        """
+        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.interfaces.mappings._get_mappings()
+        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) -> dict:
+        """
+        DEPRECATED: Use brynq.credentials.get() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.credentials.get() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.interfaces.credentials.get_system_credential(system, label, test_environment)
+
+    def get_interface_credential(self, system: str, system_type: Optional[str] = None,
+                                 test_environment: bool = False) -> Union[dict, List[dict]]:
+        """
+        DEPRECATED: Use brynq.credentials.get_interface_credential() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.credentials.get() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.interfaces.credentials.get(self.data_interface_id, system, system_type, test_environment)
+
+    def get_user_data(self):
+        """
+        DEPRECATED: Use brynq.users.get_user_data() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.users.get_user_data() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.users.get()
+
+    def get_user_authorization_qlik_app(self, dashboard_id):
+        """
+        DEPRECATED: Use brynq.users.get_user_authorization_qlik_app() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.users.get_user_authorization_qlik_app() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.users.get_user_authorization_qlik_app(dashboard_id)
+
+    def get_role_data(self):
+        """
+        DEPRECATED: Use brynq.users.get_role_data() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.users.get_role_data() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.roles.get()
+
+    def create_user(self, user_data: dict) -> requests.Response:
+        """
+        DEPRECATED: Use brynq.users.create_user() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.users.create_user() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.users.invite(user_data)
+
+    def update_user(self, user_id: str, user_data: dict) -> requests.Response:
+        """
+        DEPRECATED: Use brynq.users.update_user() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.users.update_user() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.users.update(user_id, user_data)
+
+    def delete_user(self, user_id: str) -> requests.Response:
+        """
+        DEPRECATED: Use brynq.users.delete_user() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.users.delete_user() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.users.delete(user_id)
+
+    def overwrite_user_roles(self, roles: dict) -> requests.Response:
+        """
+        DEPRECATED: Use brynq.users.overwrite_user_roles() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.users.overwrite_user_roles() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.roles.update(roles)
+
+    def get_source_system_entities(self, system: int) -> requests.Response:
+        """
+        DEPRECATED: Use brynq.source_systems.get_entities() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.source_systems.get_entities() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.source_systems.get_entities(system)
+
+    def get_layers(self) -> List[Dict[str, Any]]:
+        """
+        DEPRECATED: Use brynq.organization_chart.get_layers() instead
+        """
+        warnings.warn(
+            "This method is deprecated. Use brynq.organization_chart.get_layers() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.organization_chart.get_layers()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        """Close the session and cleanup resources"""
+        if hasattr(self, 'session'):
+            self.brynq_session.close()

brynq_sdk_brynq/credentials.py

@@ -0,0 +1,157 @@
+import os
+import requests
+from typing import Optional, Union, List, Dict, Any
+import warnings
+from .schemas.credentials import CredentialsConfig
+from brynq_sdk_functions import Functions
+
+
+class Credentials:
+    """
+    Handles all credential-related operations for BrynQ SDK.
+    """
+    def __init__(self, brynq_instance):
+        """
+        Initialize Credentials manager.
+        
+        Args:
+            brynq_instance: The parent BrynQ instance
+        """
+        self._brynq = brynq_instance
+
+    def get_system_credential(self, system: str, label: Union[str, list], test_environment: bool = False) -> dict:
+        """
+        DEPRECATED: Use brynq.interfaces.credentials.get() instead
+        """
+        warnings.warn("This function is deprecated and will be removed in a future version.", DeprecationWarning, stacklevel=2)
+        response = self._brynq.brynq_session.get(
+            url=f'{self._brynq.url}apps/{system}',
+            timeout=self._brynq.timeout
+        )
+        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 get(self, system: str, system_type: Optional[str] = None, test_environment: bool = False) -> Union[dict, List[dict]]:
+        """
+        This method retrieves authentication credentials from BrynQ for a specific interface and system.
+        
+        :param interface_id: ID of the interface to get credentials for
+        :param system: The app name to search for in credentials (e.g., 'bob', 'profit')
+        :param system_type: Optional parameter to specify 'source' or 'target'. If not provided,
+                            searches in both lists
+        :param test_environment: boolean indicating if the test environment is used (only for 'profit' system)
+        :return: Credential dictionary or list of credential dictionaries for the specified system
+        """
+        
+        # Fetch the config using a separate method
+        config = self._fetch_config()
+
+        matching_credentials = []
+
+        # If system_type is provided, only search in that list
+        if system_type:
+            if system_type not in ['source', 'target']:
+                raise ValueError("system_type must be either 'source' or 'target'")
+            credentials_list = config.get(f'{system_type}s', [])
+            for cred in credentials_list:
+                if cred.get('app') == system:
+                    # Check test environment for 'profit'
+                    if system == 'profit':
+                        is_test = cred.get('data', {}).get('isTestEnvironment', False)
+                        if is_test == test_environment:
+                            matching_credentials.append({'credential': cred, 'type': system_type})
+                    else:
+                        matching_credentials.append({'credential': cred, 'type': system_type})
+
+        # If no system_type provided, search both lists
+        else:
+            source_credentials = []
+            target_credentials = []
+
+            # Check sources
+            for source in config.get('sources', []):
+                if source.get('app') == system:
+                    if system == 'profit':
+                        is_test = source.get('data', {}).get('isTestEnvironment', False)
+                        if is_test == test_environment:
+                            source_credentials.append({'credential': source, 'type': 'source'})
+                    else:
+                        source_credentials.append({'credential': source, 'type': 'source'})
+
+            # Check targets
+            for target in config.get('targets', []):
+                if target.get('app') == system:
+                    if system == 'profit':
+                        is_test = target.get('data', {}).get('isTestEnvironment', False)
+                        if is_test == test_environment:
+                            target_credentials.append({'credential': target, 'type': 'target'})
+                    else:
+                        target_credentials.append({'credential': target, 'type': 'target'})
+
+            # Combine matching credentials based on type
+            if source_credentials and target_credentials:
+                raise ValueError(
+                    f'Multiple credentials found for system {system} in both source and target. '
+                    f'Please specify system_type as "source" or "target"'
+                )
+            matching_credentials = source_credentials or target_credentials
+
+        # Handle results
+        if len(matching_credentials) == 0:
+            if system == 'profit':
+                raise ValueError(f'No credentials found for system {system} with test_environment={test_environment}')
+            else:
+                raise ValueError(f'No credentials found for system {system}')
+
+        if len(matching_credentials) == 1:
+            return matching_credentials[0]['credential']
+
+        if len(matching_credentials) > 1:
+            warning_msg = f'Multiple credentials found for system {system}'
+            if system_type:
+                warning_msg += f' in {system_type}'
+            warnings.warn(warning_msg)
+            return [cred['credential'] for cred in matching_credentials]
+
+    def _fetch_config(self) -> Dict[str, Any]:
+        """
+        Fetch configuration from BrynQ for a given interface ID.
+
+        Args:
+            interface_id (str): The ID of the interface to fetch configuration for.
+
+        Returns:
+            Dict[str, Any]: Validated credentials configuration.
+
+        Raises:
+            ValueError: If the response data is invalid.
+            requests.exceptions.RequestException: If the API request fails.
+        """
+        response = self._brynq.brynq_session.get(
+            url=f'{self._brynq.url}interfaces/{self._brynq.data_interface_id}/config/auth',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        
+        try:
+            config_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(config_data, CredentialsConfig, debug=False)
+            return valid_data[0]
+        except ValueError as e:
+            raise ValueError(f"Invalid credentials configuration received from API: {str(e)}")

brynq_sdk_brynq/customers.py

@@ -0,0 +1,88 @@
+from typing import List, Dict, Any, Optional
+import requests
+from requests import Response
+from .schemas.customers import CustomerSchema, CustomerContractDetailsSchema
+from brynq_sdk_functions import Functions
+
+class Customers:
+    """Class for interacting with BrynQ customer endpoints"""
+
+    def __init__(self, brynq):
+        """Initialize Customers class
+        
+        Args:
+            brynq: Parent BrynQ instance for authentication and configuration
+        """
+        self.brynq = brynq
+
+    def get(self) -> List[Dict[str, Any]]:
+        """Get all customers this token has access to.
+        
+        Returns:
+            List[Dict[str, Any]]: List of customer objects with validated data
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the response data doesn't match the expected schema
+        """
+        response = self.brynq.brynq_session.get(
+            url=f"{self.brynq.url}customers",
+            timeout=self.brynq.timeout
+        )
+        response.raise_for_status()
+        
+        try:
+            customers_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(customers_data, CustomerSchema, debug=False)
+            return valid_data
+        except ValueError as e:
+            raise ValueError(f"Invalid customer data received from API: {str(e)}")
+
+    def get_all_contract_details(self) -> List[Dict[str, Any]]:
+        """Get all customers contract details.
+        
+        Returns:
+            List[Dict[str, Any]]: List of customer contract details with validated data
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the response data doesn't match the expected schema
+        """
+        response = self.brynq.brynq_session.get(
+            f"{self.brynq.url}customers/contract-details",
+            timeout=self.brynq.timeout
+        )
+        response.raise_for_status()
+        
+        try:
+            contract_details = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(contract_details, CustomerContractDetailsSchema, debug=False)
+            return valid_data
+        except ValueError as e:
+            raise ValueError(f"Invalid contract details received from API: {str(e)}")
+
+    def get_contract_details_by_id(self, customer_id: int) -> Dict[str, Any]:
+        """Get contract details for a specific customer.
+        
+        Args:
+            customer_id (int): The ID of the customer to get contract details for.
+
+        Returns:
+            Dict[str, Any]: Contract details for the specified customer.
+
+        Raises:
+            ValueError: If the response data is invalid.
+            requests.exceptions.RequestException: If the API request fails.
+        """
+        response = self.brynq.brynq_session.get(
+            f"{self.brynq.url}customers/{customer_id}/contract-details",
+            timeout=self.brynq.timeout
+        )
+        response.raise_for_status()
+
+        try:
+            contract_details = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(contract_details, CustomerContractDetailsSchema, debug=False)
+            return valid_data[0]
+        except ValueError as e:
+            raise ValueError(f"Invalid contract details received from API: {str(e)}")