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

brynq_sdk_brynq/interfaces.py

@@ -0,0 +1,234 @@
+from typing import Dict, List, Any, Optional
+from .credentials import Credentials
+from .mappings import Mappings
+from .scenarios import Scenarios
+from .schemas.interfaces import Interface, InterfaceDetail, InterfaceConfig, Schedule, Scope, DevSettings
+from brynq_sdk_functions import Functions
+
+class Interfaces:
+    """
+    Handles all interface-related operations for BrynQ SDK.
+    """
+    def __init__(self, brynq_instance):
+        """
+        Initialize Interfaces manager.
+
+        Args:
+            brynq_instance: The parent BrynQ instance
+        """
+        self._brynq = brynq_instance
+        self.credentials = Credentials(brynq_instance)
+        self.mappings = Mappings(brynq_instance)
+        self.scenarios = Scenarios(brynq_instance)
+
+    def get_all(self) -> List[Dict[str, Any]]:
+        """Get all interfaces this token has access to.
+
+        Returns:
+            List[Dict[str, Any]]: List of interfaces with their details including:
+                - id (int): Interface ID
+                - name (str): Interface name
+                - description (str): Interface description
+                - sourceSystems (List[int]): List of source system IDs
+                - targetSystems (List[int]): List of target system IDs
+                - taskSchedule (Dict): Task schedule details including status, timing, etc.
+
+        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}interfaces",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        try:
+            interfaces_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(interfaces_data, schema=Interface)
+            return valid_data
+        except ValueError as e:
+            raise ValueError(f"Invalid interface data received from API: {str(e)}")
+
+    def get(self) -> Dict[str, Any]:
+        """Get a specific interface by its ID.
+        Returns:
+            Dict[str, Any]: Interface details including:
+                - name (str): Interface name
+                - type (str): Interface type (e.g., 'ADVANCED')
+                - apps (Dict): Application configuration with:
+                    - source (str): Source application name
+                    - target (str): Target application name
+
+        Raises:
+            ValueError: If interface_id is not a positive integer or if the response data is invalid
+            requests.exceptions.RequestException: If the API request fails
+        """
+        # Basic validation
+
+        response = self._brynq.brynq_session.get(
+            f"{self._brynq.url}interfaces/{self._brynq.data_interface_id}",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        try:
+            interface_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(interface_data, schema=InterfaceDetail)
+            return valid_data[0]
+        except ValueError as e:
+            raise ValueError(f"Invalid interface data received from API: {str(e)}")
+
+    def get_config(self) -> Dict[str, Any]:
+        """Get the base configuration of an interface.
+
+        Args:
+            interface_id (int): The ID of the interface
+
+        Returns:
+            Dict[str, Any]: Interface configuration including:
+                - mapping (List): List of mapping configurations
+                - variables (Dict): Configuration variables
+
+        Raises:
+            ValueError: If interface_id is not a positive integer or if the response data is invalid
+            requests.exceptions.RequestException: If the API request fails
+        """
+        # Basic validation
+
+        response = self._brynq.brynq_session.get(
+            f"{self._brynq.url}interfaces/{self._brynq.data_interface_id}/config",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        try:
+            config_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(config_data, schema=InterfaceConfig)
+            return valid_data[0]
+        except ValueError as e:
+            raise ValueError(f"Invalid interface configuration data: {str(e)}")
+
+    def flush_config(self) -> Dict[str, Any]:
+        """
+        Flushes the interface config to revert to a fresh state.
+
+        Returns:
+            Dict[str, Any]: Response from the flush operation
+
+        Raises:
+            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/flush',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def get_schedule(self) -> Dict[str, Any]:
+        """Get the schedule configuration of an interface.
+
+        Returns:
+            Dict[str, Any]: Schedule configuration including:
+                - id (int): The schedule ID
+                - triggerType (str): Type of trigger (e.g., 'MANUAL')
+                - triggerPattern (str): Pattern for the trigger
+                - timezone (str): Timezone setting
+                - nextReload (str, optional): Next scheduled reload time
+                - frequency (Dict): Object containing day, hour, month, minute
+                - startAfterPrecedingTask (bool, optional): Whether to start after preceding task
+                - lastReload (str): Last reload time
+                - lastErrorMessage (str): Last error message
+
+        Raises:
+            ValueError: If interface_id is not a positive integer or if the response data is invalid
+            requests.exceptions.RequestException: If the API request fails
+        """
+        response = self._brynq.brynq_session.get(
+            f"{self._brynq.url}interfaces/{self._brynq.data_interface_id}/config/schedule",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        try:
+            schedule_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(schedule_data, schema=Schedule)
+            return valid_data[0]
+        except ValueError as e:
+            raise ValueError(f"Invalid schedule configuration data: {str(e)}")
+
+
+    def get_scope(self) -> Dict[str, Any]:
+        """Get live and draft scopes from interface by id.
+
+        Returns:
+            Dict[str, Any]: Scope configuration including:
+                - live (Dict, optional): Live scope configuration
+                - draft (Dict, optional): Draft scope configuration
+
+        Raises:
+            ValueError: If interface_id is not a positive integer or if the response data is invalid
+            requests.exceptions.RequestException: If the API request fails
+        """
+        response = self._brynq.brynq_session.get(
+            f"{self._brynq.url}interfaces/{self._brynq.data_interface_id}/scope",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        try:
+            scope_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(scope_data, schema=Scope)
+            return valid_data[0]
+        except ValueError as e:
+            raise ValueError(f"Invalid scope data: {str(e)}")
+
+    def get_dev_settings(self) -> List[dict[str,Any]]:
+        """Get the dev-settings of an interface
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the dev settings:
+                - dockerImage (str): Docker image name
+                - sftpMapping (List[dict]): SFTP mapping configuration
+                - runfilePath (str): Path to the runfile
+                - stopIsAllowed (bool): Whether stopping is allowed
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            requests.exceptions.HTTPError: If dev settings not found (404)
+            ValueError: If interface_id is not a positive integer
+        """
+
+        response = self._brynq.brynq_session.get(
+            url=f"{self._brynq.url}interfaces/{self._brynq.data_interface_id}/config/dev-settings",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        valid_data, _ = Functions.validate_pydantic_data(response.json(), schema=DevSettings)
+        return valid_data
+
+    def get_variables(self, variable_name: str = None):
+        """
+        Get a value from the task_variables table corresponding with the given name. If temp value is filled, it will
+        (run_instant = 1), then the temp_value will be returned. This is to give the possibility for users in the frontend to run
+        a task once manual with other values then normal without overwriting the normal values.
+        :param variable_name: the name of the variable
+        :return: the value of the given variable.
+        """
+
+        variables = self.get_config().get("variables")
+
+        if not variables:
+            raise Exception(f"There are no valid variables in interface '{self._brynq.data_interface_id}'")
+
+        if variable_name:
+            variable = variables.get(variable_name)
+            if not variable:
+                raise Exception(f"The variable '{variable_name}' does not exist in interface '{self._brynq.data_interface_id}'")
+            self.flush_config()
+            return variable
+        else:
+            self.flush_config()
+            return variables

brynq_sdk_brynq/mappings.py

@@ -0,0 +1,107 @@
+import requests
+import pandas as pd
+from typing import Optional, Union, Literal, Any, Tuple, List, Dict
+import warnings
+from .schemas.interfaces import MappingItem
+from brynq_sdk_functions import Functions
+
+class MappingNotFoundError(Exception):
+    """Raised when a requested mapping is not found"""
+    pass
+
+class Mappings:
+    """
+    Handles all mapping-related operations for BrynQ SDK.
+    """
+    def __init__(self, brynq_instance):
+        """
+        Initialize Mappings manager.
+
+        Args:
+            brynq_instance: The parent BrynQ instance
+        """
+        self._brynq = brynq_instance
+
+    def _get_mappings(self) -> List[Dict[str, Any]]:
+        """Get all mappings for an interface.
+
+        Args:
+            interface_id (int): The ID of the interface
+
+        Returns:
+            List[Dict[str, Any]]: List of mapping configurations
+
+        Raises:
+            ValueError: If interface_id is not a positive integer or if the response data is invalid
+            requests.exceptions.RequestException: If the API request fails
+        """
+        response = self._brynq.brynq_session.get(
+            f"{self._brynq.url}interfaces/{self._brynq.data_interface_id}/config/mapping",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+
+        try:
+            mappings_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(mappings_data, schema=MappingItem)
+            return valid_data
+        except ValueError as e:
+            raise ValueError(f"Invalid mappings data: {str(e)}")
+
+    def _to_dataframe(self, mapping_data: dict, prefix: bool = False) -> pd.DataFrame:
+        """Convert mapping values to DataFrame format"""
+        rows = []
+        for value in mapping_data['values']:
+            row = {}
+            for key, val in value['input'].items():
+                row[f'input.{key}' if prefix else key] = val
+            for key, val in value['output'].items():
+                row[f'output.{key}' if prefix else key] = val
+            rows.append(row)
+        return pd.DataFrame(rows)
+
+    def _to_dict(self, mapping_data: dict) -> dict:
+        """Convert mapping values to dictionary format"""
+        mappings = {}
+        for value in mapping_data['values']:
+            input_key = ','.join(value['input'].values())
+            output_value = ','.join(value['output'].values()) if len(value['output']) > 1 else next(iter(value['output'].values()))
+            mappings[input_key] = output_value
+        return mappings
+
+    def get(self, mapping: Optional[str] = None, as_df: bool = False, prefix: bool = False) -> dict:
+        """Get the mapping from BrynQ.
+
+        Args:
+            interface_id (int): The id of the task in BrynQ
+            mapping (str): The name of the mapping
+            as_df (bool, optional): If True, returns mappings as pandas DataFrame. If False, returns mappings as dictionary. Defaults to False.
+            prefix (bool, optional): Only used when as_df is True. If True, prefixes column names with 'input.' and 'output.'. Defaults to False.
+
+        Returns:
+            dict: Dictionary with keys:
+                - 'default_value': The default value for the mapping
+                - 'mappings': Either a DataFrame (if as_df=True) or a dictionary (if as_df=False)
+
+        Raises:
+            MappingNotFoundError: If mapping is not found
+            ValueError: If mapping data is invalid
+        """
+        mappings = self._get_mappings()
+        if mapping is None:
+            if as_df:
+                mapping_data = [{'default_value': item['default_value'], 'mappings': self._to_dataframe(item, prefix)} for item in mappings]
+            else:
+                mapping_data = [{'default_value': item['default_value'], 'mappings': self._to_dict(item)} for item in mappings]
+
+            return mapping_data
+        else:
+            mapping_data = next((item for item in mappings if item['name'] == mapping), None)
+
+            if not mapping_data:
+                raise MappingNotFoundError(f"Mapping named '{mapping}' not found")
+
+            return {
+                'default_value': mapping_data['default_value'],
+                'mappings': self._to_dataframe(mapping_data, prefix) if as_df else self._to_dict(mapping_data)
+            }

brynq_sdk_brynq/organization_chart.py

@@ -0,0 +1,251 @@
+import requests
+from typing import Dict, List, Any, Literal, Union, Optional
+from .schemas.organization_chart import (
+    OrganizationChartNode,
+    OrganizationLayerCreate,
+    OrganizationLayerGet,
+    OrganizationLayerUpdate,
+    OrganizationNode,
+    OrganizationNodeCreate, OrganizationNodeUpdate
+)
+from brynq_sdk_functions import Functions
+
+
+class OrganizationChart:
+    """
+    Handles all organization chart related operations for BrynQ SDK.
+    """
+    def __init__(self, brynq_instance):
+        """
+        Initialize OrganizationChart manager.
+        
+        Args:
+            brynq_instance: The parent BrynQ instance
+        """
+        self._brynq = brynq_instance
+
+    def get(self, layout: Literal["nested", "flat"] = "nested") -> List[Dict[str, Any]]:
+        """Get all organization charts.
+
+        Args:
+            layout (str): Layout format, either "nested" or "flat"
+
+        Returns:
+            Dict[str, Any]: Organization charts data including:
+                - id (int): Node ID
+                - name (str): Node name
+                - dropIndex (int): Drop index for ordering
+                - parent_id (int, optional): Parent node ID, null for root nodes
+                - source_system_entities (List[str]): List of source system entities
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If layout is not "nested" or "flat" or if the response data is invalid
+        """
+        if layout not in ["nested", "flat"]:
+            raise ValueError('layout must be either "nested" or "flat"')
+
+        response = self._brynq.brynq_session.get(
+            f"{self._brynq.url}organization-chart",
+            params={"layout": layout},
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        
+        try:
+            chart_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(chart_data, schema=OrganizationChartNode)
+            return valid_data
+        except ValueError as e:
+            raise ValueError(f"Invalid organization chart data: {str(e)}")
+
+    def get_layers(self) -> List[Dict[str, Any]]:
+        """Get all organization layers.
+        
+        Returns:
+            Dict[str, Any]: Organization chart layers data including:
+                - id (int): Layer ID
+                - name (str): Layer name
+                - level (int): Layer level in hierarchy
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the response data is invalid
+        """
+        response = self._brynq.brynq_session.get(
+            f"{self._brynq.url}organization-chart/layers",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        
+        try:
+            layers_data = response.json()
+            valid_data, _ = Functions.validate_pydantic_data(layers_data, schema=OrganizationLayerGet)
+            return valid_data
+        except ValueError as e:
+            raise ValueError(f"Invalid organization layer data: {str(e)}")
+
+    def create_layer(self, data:Dict[str,Any]) -> Dict[str, Any]:
+        """Create a new organization layer.
+        
+        Args:
+            data (Dict[str,Any]): Data to create a new layer for
+                {
+                    name (str): Layer name
+                    level (int): Layer level in hierarchy
+                }
+        Returns:
+            Dict[str, Any]: Response from the API
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the input data is invalid
+        """
+        valid_data, _ = Functions.validate_pydantic_data(data, schema=OrganizationLayerCreate)
+        
+        response = self._brynq.brynq_session.post(
+            f"{self._brynq.url}organization-chart/layers",
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def update_layer(self, data:dict[str, Any]) -> Dict[str, Any]:
+        """Update an existing organization layer.
+        
+        Args:
+            data(dict[]): Organization layer data
+                {
+                    layer_id (int): ID of the layer to update
+                    name (str): New layer name
+                    level (int): New layer level in hierarchy
+                }
+        Returns:
+            Dict[str, Any]: Response from the API
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the input data is invalid
+        """
+        valid_data, _ = Functions.validate_pydantic_data(data, schema=OrganizationLayerUpdate)
+        
+        response = self._brynq.brynq_session.put(
+            f"{self._brynq.url}organization-chart/layers/{data['id']}",
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def delete_layer(self, layer_id: int) -> None:
+        """Delete a layer and its underlying layers.
+        
+        Args:
+            layer_id (int): ID of the layer to delete
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If layer_id is not an integer
+        """
+        if not isinstance(layer_id, int):
+            raise ValueError("layer_id must be an integer")
+        
+        response = self._brynq.brynq_session.delete(
+            f"{self._brynq.url}organization-chart/layers/{layer_id}",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def get_nodes(self) -> List[Dict[str, Any]]:
+        """Get all organization chart nodes.
+        
+        Returns:
+            Dict[str, Any]: Organization chart nodes data including:
+                - id (int): Node ID
+                - name (str): Node name
+                - parentId (int, optional): Parent node ID
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the response data is invalid
+        """
+        response = self._brynq.brynq_session.get(
+            url=f'{self._brynq.url}organization-chart/nodes',
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        valid_data, _ = Functions.validate_pydantic_data(response.json(), schema=OrganizationNode)
+        return valid_data
+
+    def create_nodes(self, data:dict) -> Dict[str, Any]:
+        """Create an organization chart node.
+        
+        Args:
+            data (dict): Node data
+                {
+                    name (str): Name of the node
+                    position (int, optional): Position among siblings
+                    parent_id (int, optional): ID of the parent node
+                }
+        Returns:
+            Dict[str, Any]: Response from the API
+            
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If the input data is invalid
+        """
+
+        valid_data, _ = Functions.validate_pydantic_data(data, schema=OrganizationNodeCreate)
+        
+        response = self._brynq.brynq_session.post(
+            f"{self._brynq.url}organization-chart/nodes",
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def update_node(self, data: dict) -> dict:
+        """Update an organization chart node.
+
+        Args:
+            data (dict): Dictionary containing fields to update (e.g. name, position, parentId)
+
+        Returns:
+            dict: Updated node details returned from API
+
+        Raises:
+            ValueError: If node_id is not a positive integer
+            requests.exceptions.RequestException: If the API request fails
+        """
+        valid_data, _ = Functions.validate_pydantic_data(data, schema=OrganizationNodeUpdate)
+
+        response = self._brynq.brynq_session.put(
+            f"{self._brynq.url}organization-chart/nodes/{data['id']}",
+            json=valid_data[0],
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response
+
+    def delete_node(self, node_id: int) -> None:
+        """Delete a node and its underlying nodes.
+
+        Args:
+            node_id (int): ID of the layer to delete
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails
+            ValueError: If layer_id is not an integer
+        """
+        if not isinstance(node_id, int):
+            raise ValueError("node_id must be an integer")
+
+        response = self._brynq.brynq_session.delete(
+            f"{self._brynq.url}organization-chart/nodes/{node_id}",
+            timeout=self._brynq.timeout
+        )
+        response.raise_for_status()
+        return response