qubicon 1.0.0__py3-none-any.whl

qubicon/__init__.py

@@ -0,0 +1,13 @@
+from .config import Config
+from .auth import authenticate
+from .api.models import Models
+from .api.quantities import Quantities
+from .api.processes import Processes
+
+__all__ = [
+    'Config',
+    'authenticate',
+    'Models',
+    'Quantities',
+    'Processes',
+]

qubicon/api/__init__.py

@@ -0,0 +1,9 @@
+from .models import Models
+from .quantities import Quantities
+from .processes import Processes
+
+__all__ = [
+    'Models',
+    'Quantities',
+    'Processes',
+]

qubicon/api/models.py

@@ -0,0 +1,237 @@
+from ..utils import make_request
+from ..logger import get_logger
+from ..utils import make_request
+from .quantities import Quantities 
+import json
+
+class Models:
+    def __init__(self, config):
+        self.config = config
+        self.endpoint = f"{self.config.base_url}/api/computable-models"
+        self.logger = get_logger(self.__class__.__name__)
+        self.headers = {'Authorization': f'Bearer {self.config.load_token()}', 'Content-Type': 'application/json'}
+        self.physical_quantities = Quantities(config)  # Delegate handling to the PhysicalQuantities class
+
+    def list(self, params=None):
+        """
+        Retrieve a list of models with the same query parameters as the command-line client.
+        :param params: Optional dictionary of query parameters.
+        :return: List of models (dictionary containing model details).
+        """
+        headers = {'Authorization': f'Bearer {self.config.load_token()}'}
+        # Define the same query parameters used in the command-line client
+        default_params = {
+            'search': '',
+            'size': 50,
+            'sort': 'updateDate,desc',
+            'page': 0,
+            'statuses': 'DRAFT,RELEASED'
+        }
+
+        # Merge any additional params provided with the default ones
+        if params:
+            default_params.update(params)
+
+        self.logger.info("Fetching list of models with query parameters...")
+        
+        try:
+            # Make request to the API endpoint with proper query params
+            response = make_request('GET', self.endpoint, headers=headers, params=default_params, timeout=self.config.timeout)
+            
+            # Handle the response and ensure the 'content' field contains models
+            if 'content' in response:
+                return response['content']  # Return the list of models
+            else:
+                self.logger.error("Unexpected response format when fetching models.")
+                return []
+        except Exception as e:
+            self.logger.error(f"Error fetching models: {e}")
+            return []
+
+
+    def get_model_dict(self):
+        """
+        Returns a dictionary mapping valid model names to their IDs.
+        :return: Dictionary where keys are model names and values are model IDs.
+        """
+        models = self.list()
+        
+        # Create a dictionary of model names and their IDs
+        model_dict = {model['kpiName']: model['id'] for model in models if 'kpiName' in model and 'id' in model}
+        
+        self.logger.info("Generated model dictionary with names and IDs.")
+        return model_dict
+
+    def get(self, model_id):
+        """
+        Retrieve details of a specific model.
+        :param model_id: ID of the model.
+        :return: Dictionary containing model details.
+        """
+        headers = {'Authorization': f'Bearer {self.config.load_token()}'}
+        url = f"{self.endpoint}/{model_id}?deleted=false"
+        self.logger.info(f"Fetching model with ID {model_id}...")
+
+        try:
+            # Make request to fetch the specific model details
+            response = make_request('GET', url, headers=headers, timeout=self.config.timeout)
+            return response
+        except Exception as e:
+            self.logger.error(f"Error fetching model details for ID {model_id}: {e}")
+            return None
+        
+    # functions for importing models from JSON files
+        
+    def import_model_from_json(self, file_path):
+        """
+        Import a model from a JSON file, handling the physical quantities and units mapping.
+        """
+        with open(file_path, 'r') as f:
+            model_data = json.load(f)
+
+        # Delegate physical quantity handling to the PhysicalQuantities class
+        model_data = self.physical_quantities.handle_physical_quantities(model_data)
+        self.create_model(model_data)
+
+    def create_model(self, model_data):
+        """
+        Create a new model with the updated model data.
+        """
+        self.logger.info(f"Attempting to create model: {model_data.get('kpiName')}")
+
+        try:
+            # Make the POST request to create the model and get both the response object and JSON data
+            response, response_data = make_request('POST', self.endpoint, headers=self.headers, json=model_data)
+
+            if response:
+                status_code = response.status_code
+
+                if status_code == 201:
+                    self.logger.info(f"Model '{model_data.get('kpiName')}' created successfully!")
+                elif status_code == 200:
+                    self.logger.info(f"Model '{model_data.get('kpiName')}' updated or already existed.")
+                else:
+                    # If there is an error status code, log the error response content
+                    error_message = response_data if response_data else response.text
+                    self.logger.error(f"Error during model creation: {error_message}")
+
+            else:
+                self.logger.error(f"Model creation failed for '{model_data.get('kpiName')}': No response received.")
+
+        except Exception as e:
+            self.logger.error(f"Error during model creation: {e}")
+
+    
+    # functions for exporting models to JSON files
+
+    def fetch_model_details(self, model_id):
+        """
+        Fetch details of a specific model from the API.
+        
+        Args:
+            model_id (int): The ID of the model to fetch.
+        
+        Returns:
+            dict: The model details, or None if the request fails.
+        """
+        url = f"{self.endpoint}/{model_id}?deleted=false"
+        self.logger.info(f"Fetching details for model ID: {model_id}")
+        
+        try:
+            # Expecting only a single return value from make_request (the response data)
+            response_data = make_request('GET', url, headers=self.headers)
+            if response_data:
+                self.logger.info(f"Successfully fetched model details for ID: {model_id}")
+                return response_data
+            else:
+                self.logger.error(f"Failed to fetch model details.")
+                return None
+        except Exception as e:
+            self.logger.error(f"Error fetching model details: {e}")
+            return None
+
+
+    def convert_to_importable_format(self, api_response):
+        """
+        Converts the fetched model details into an importable JSON structure.
+        
+        Args:
+            api_response (dict): The API response containing the model details.
+        
+        Returns:
+            dict: The reformatted model ready for export, or None on error.
+        """
+        if not api_response:
+            self.logger.error("No valid model data to convert.")
+            return None
+
+        # Create the structure for the importable model
+        importable_model = {
+            "engineType": api_response.get("engineType"),
+            "kpiName": api_response.get("kpiName"),
+            "abbr": api_response.get("abbr"),
+            "calculationStyle": api_response.get("calculationStyle"),
+            "status": "DRAFT",  # Default to DRAFT for export, can be modified later
+            "description": api_response.get("description", ""),
+            "script": api_response.get("script", "")
+        }
+
+        # Process inputs
+        importable_model["inputs"] = [
+            {
+                "name": input_item.get("name"),
+                "order": idx,
+                "physicalQuantityUnit": {
+                    "name": input_item["physicalQuantityUnit"].get("name"),
+                    "unit": input_item["physicalQuantityUnit"].get("unit"),
+                    "status": input_item["physicalQuantityUnit"].get("status")
+                },
+                "description": input_item.get("description", "")
+            } for idx, input_item in enumerate(api_response.get("inputs", []))
+        ]
+
+        # Process outputs
+        importable_model["outputs"] = [
+            {
+                "name": output_item.get("name"),
+                "order": idx,
+                "physicalQuantityUnit": {
+                    "name": output_item["physicalQuantityUnit"].get("name"),
+                    "unit": output_item["physicalQuantityUnit"].get("unit"),
+                    "status": output_item["physicalQuantityUnit"].get("status")
+                },
+                "description": output_item.get("description", "")
+            } for idx, output_item in enumerate(api_response.get("outputs", []))
+        ]
+
+        return importable_model
+
+    def export_model_to_json(self, model_id, output_file):
+        """
+        Export a model to a JSON file based on the model's ID.
+        
+        Args:
+            model_id (int): The ID of the model to export.
+            output_file (str): The output file path for the exported JSON.
+        """
+        self.logger.info(f"Exporting model with ID {model_id} to {output_file}...")
+
+        # Fetch model details
+        model_details = self.fetch_model_details(model_id)
+        if not model_details:
+            self.logger.error(f"Failed to fetch model details for ID {model_id}.")
+            return
+
+        # Convert model details to an importable format
+        importable_json = self.convert_to_importable_format(model_details)
+        if not importable_json:
+            self.logger.error(f"Failed to convert model to importable format for ID {model_id}.")
+            return
+
+        # Export the model to a JSON file
+        try:
+            with open(output_file, 'w') as json_file:
+                json.dump(importable_json, json_file, indent=4)
+            self.logger.info(f"Model ID {model_id} exported successfully to {output_file}.")
+        except IOError as e:
+            self.logger.error(f"Failed to write model to JSON file: {e}")

qubicon/api/processes.py

@@ -0,0 +1,145 @@
+from ..utils import make_request
+from ..logger import get_logger
+import pandas as pd
+
+class Processes:
+    def __init__(self, config):
+        """
+        Initializes the Processes class with the provided configuration.
+        
+        :param config: A Config object that contains the API base URL and authentication token.
+        """
+        self.config = config
+        self.endpoint = f"{self.config.base_url}/public-api/processes"
+        self.logger = get_logger(self.__class__.__name__)
+        self.headers = {'Authorization': f'Bearer {self.config.load_token()}'}
+
+    def list_processes(self):
+        """
+        Fetches and returns all available processes from the API. This method retrieves a list of processes 
+        based on parameters like the number of processes to fetch, sorting order, and GMP status.
+
+        :return: A list of processes in dictionary format, or None if the request fails.
+        """
+        params = {
+            'size': 90,
+            'sort': 'lastUsageDate,desc',
+            'gmp': False,
+            'archivedOrWillBeArchived': False,
+            'partOfExperiment': False
+        }
+        
+        try:
+            self.logger.info("Fetching processes from the API...")
+            response = make_request('GET', self.endpoint, headers=self.headers, params=params)
+            processes = response.get('content', [])
+            
+            if processes:
+                self.logger.info(f"Retrieved {len(processes)} processes.")
+                return processes
+            else:
+                self.logger.warning("No processes available or invalid response format.")
+                return None
+        except Exception as e:
+            self.logger.error(f"Error fetching processes: {e}")
+            return None
+        
+    def list_process_channels(self, process_id):
+        """
+        Fetches and returns the channels associated with a specific process.
+
+        :param process_id: The ID of the process whose channels should be retrieved.
+        :return: A list of channels in dictionary format, or None if the request fails.
+        """
+        url = f"{self.config.base_url}/api/processes/{process_id}/channels"
+        
+        try:
+            self.logger.info(f"Fetching channels for process ID: {process_id}")
+            response = make_request('GET', url, headers=self.headers)
+            
+            if response:
+                self.logger.info(f"Retrieved {len(response)} channels.")
+                return response
+            else:
+                self.logger.warning(f"No channels available for process {process_id}.")
+                return None
+        except Exception as e:
+            self.logger.error(f"Error fetching channels for process {process_id}: {e}")
+            return None
+        
+    def extract_process_data(self, process_id, selected_channels, start_date, end_date, granularity, output_file, output_format="json"):
+        """
+        Extracts process data for the selected channels and saves it in the specified format (JSON or CSV).
+        
+        :param process_id: The ID of the process from which data is to be extracted.
+        :param selected_channels: A list of dictionaries, each containing a channel ID.
+        :param start_date: The start timestamp (in milliseconds) for data extraction.
+        :param end_date: The end timestamp (in milliseconds) for data extraction.
+        :param granularity: The granularity of the data to be fetched (e.g., every minute, hour).
+        :param output_file: The file path where the extracted data will be saved.
+        :param output_format: The format for saving the data, either 'json' or 'csv' (default is 'json').
+        """
+        url = f"{self.config.base_url}/api/charts/multiplex-data-channels"
+        collected_data = []
+
+        payload = {
+            "channels": [
+                {
+                    "id": channel["id"],
+                    "type": "ONLINE",
+                    "startDate": start_date,
+                    "endDate": end_date,
+                    "granularity": granularity
+                } for channel in selected_channels
+            ]
+        }
+
+        try:
+            self.logger.info(f"Fetching data for process ID: {process_id}")
+            response = make_request('POST', url, json=payload, headers=self.headers)
+            if response:
+                for entry in response['channels']:
+                    for value in entry['value']:
+                        collected_data.append({
+                            "time": value['time'],
+                            "channel_id": entry['key']['id'],
+                            "value": value['value']
+                        })
+
+                df = pd.DataFrame(collected_data)
+                if output_format == "json":
+                    df.to_json(output_file, orient='records', indent=4)
+                    self.logger.info(f"Data successfully written to {output_file} in JSON format.")
+                elif output_format == "csv":
+                    df.pivot(index="time", columns="channel_id", values="value").to_csv(output_file)
+                    self.logger.info(f"Data successfully written to {output_file} in CSV format.")
+            else:
+                self.logger.error(f"Failed to fetch data for process ID {process_id}.")
+        except Exception as e:
+            self.logger.error(f"Error extracting data for process {process_id}: {e}")
+
+    def get_process_details(self, process_id):
+        """
+        Fetches the start and end dates of a specific process using its ID.
+        If the process is still running, the end date is defaulted to 30 minutes after the start date.
+
+        :param process_id: The ID of the process.
+        :return: A tuple containing the start and end dates (in milliseconds) of the process.
+        """
+        url = f"{self.config.base_url}/public-api/processes/{process_id}"
+        
+        try:
+            self.logger.info(f"Fetching details for process ID: {process_id}")
+            response = make_request('GET', url, headers=self.headers)
+            
+            if response:
+                start_date = response.get('startDate')
+                end_date = response.get('endDate') or start_date + (30 * 60 * 1000)  # Default to 30 min after start
+                self.logger.info(f"Process {process_id} start date: {start_date}, end date: {end_date}")
+                return start_date, end_date
+            else:
+                self.logger.error(f"Failed to fetch details for process {process_id}.")
+                return None, None
+        except Exception as e:
+            self.logger.error(f"Error fetching details for process {process_id}: {e}")
+            return None, None

qubicon/api/quantities.py

@@ -0,0 +1,160 @@
+from ..utils import make_request
+from ..logger import get_logger
+
+class Quantities:
+    def __init__(self, config):
+        """
+        Initializes the Quantities class with the provided configuration.
+        
+        :param config: A Config object that contains the API base URL and authentication token.
+        """
+        self.config = config
+        self.endpoint = f"{self.config.base_url}/api/physical-quantities"
+        self.logger = get_logger(self.__class__.__name__)
+        self.headers = {'Authorization': f'Bearer {self.config.load_token()}'}
+        
+    def list(self):
+        """
+        Retrieves and returns a list of all physical quantities available in the system.
+
+        :return: A list of physical quantities in dictionary format, or None if the request fails.
+        """
+        self.logger.info("Fetching list of physical quantities...")
+        return make_request('GET', self.endpoint, headers=self.headers, timeout=self.config.timeout)
+
+    def get(self, quantity_id):
+        """
+        Retrieves the details of a specific physical quantity by its ID.
+
+        :param quantity_id: The ID of the physical quantity to retrieve.
+        :return: A dictionary containing the physical quantity details, or None if the request fails.
+        """
+        url = f"{self.endpoint}/{quantity_id}"
+        self.logger.info(f"Fetching physical quantity with ID {quantity_id}...")
+        return make_request('GET', url, headers=self.headers, timeout=self.config.timeout)
+
+    def normalize_name(self, name):
+        """
+        Normalizes a physical quantity name by removing special characters and converting it to lowercase.
+
+        :param name: The name of the physical quantity.
+        :return: A normalized version of the name.
+        """
+        import re
+        return re.sub(r'[^a-zA-Z0-9]', '', name).lower()
+
+    def fuzzy_match(self, name1, name2, threshold=93):
+        """
+        Performs a fuzzy string matching between two physical quantity names.
+
+        :param name1: The first name to compare.
+        :param name2: The second name to compare.
+        :param threshold: The similarity threshold for considering a match (default is 93%).
+        :return: True if the similarity exceeds the threshold, False otherwise.
+        """
+        from rapidfuzz import fuzz
+        normalized_name1 = self.normalize_name(name1)
+        normalized_name2 = self.normalize_name(name2)
+        similarity = fuzz.token_sort_ratio(normalized_name1, normalized_name2)
+        return similarity >= threshold
+
+    def check_existing_physical_quantity(self, pq_name):
+        """
+        Checks if a physical quantity with a similar name already exists in the system using fuzzy matching.
+
+        :param pq_name: The name of the physical quantity to check.
+        :return: The matching physical quantity if found, or None if no match is found.
+        """
+        response = make_request('GET', self.endpoint, headers=self.headers)
+        if response and isinstance(response, list):
+            for pq in response:
+                if self.fuzzy_match(pq['name'], pq_name):
+                    self.logger.info(f"Fuzzy match found: '{pq['name']}' matches '{pq_name}' (ID: {pq['id']}).")
+                    return pq
+        return None
+
+    def check_existing_unit(self, physical_quantity, unit_name):
+        """
+        Checks if a specific unit exists within a given physical quantity.
+
+        :param physical_quantity: The physical quantity dictionary.
+        :param unit_name: The name of the unit to check.
+        :return: The matching unit if found, or None if no match is found.
+        """
+        for unit in physical_quantity.get('units', []):
+            if self.fuzzy_match(unit['unit'], unit_name):
+                self.logger.info(f"Unit match found: '{unit_name}' in physical quantity '{physical_quantity['name']}'.")
+                return unit
+        return None
+
+    def create_physical_quantity(self, pq_name, unit_name):
+        """
+        Creates a new physical quantity along with an initial unit.
+
+        :param pq_name: The name of the physical quantity to create.
+        :param unit_name: The name of the unit to associate with the new physical quantity.
+        :return: The created physical quantity in dictionary format, or None if creation fails.
+        """
+        data = {"name": pq_name, "units": [{"unit": unit_name}]}
+        response = make_request('POST', self.endpoint, headers=self.headers, json=data)
+        if response and response.status_code in [200, 201]:
+            self.logger.info(f"Physical quantity '{pq_name}' created successfully.")
+            return response.json()
+        else:
+            self.logger.error(f"Failed to create physical quantity '{pq_name}'. Response: {response.content}")
+            return None
+
+    def add_unit_to_existing_physical_quantity(self, pq_id, pq_name, unit_name):
+        """
+        Adds a new unit to an existing physical quantity.
+
+        :param pq_id: The ID of the existing physical quantity.
+        :param pq_name: The name of the existing physical quantity.
+        :param unit_name: The name of the unit to add.
+        :return: The updated physical quantity in dictionary format, or None if the update fails.
+        """
+        url = f"{self.endpoint}/{pq_id}"
+        existing_pq = self.check_existing_physical_quantity(pq_name)
+        if not existing_pq:
+            self.logger.error(f"Physical quantity '{pq_name}' not found.")
+            return None
+
+        new_unit = {"unit": unit_name, "physicalQuantityId": pq_id}
+        existing_pq['units'].append(new_unit)
+        response = make_request('PUT', url, headers=self.headers, json=existing_pq)
+        if response and response.status_code == 200:
+            self.logger.info(f"Unit '{unit_name}' added to physical quantity '{pq_name}'.")
+            return response.json()
+        else:
+            self.logger.error(f"Failed to add unit to physical quantity '{pq_name}'.")
+            return None
+
+    def handle_physical_quantities(self, model_data):
+        """
+        Processes and ensures all physical quantities and units in the model data exist in the system. 
+        If a physical quantity or unit doesn't exist, it is created.
+
+        :param model_data: A dictionary containing the model's inputs and outputs.
+        :return: The updated model data with physicalQuantityId and unit ID populated.
+        """
+        for var in model_data.get('inputs', []) + model_data.get('outputs', []):
+            pq_name = var['physicalQuantityUnit']['name']
+            unit_name = var['physicalQuantityUnit']['unit']
+
+            existing_pq = self.check_existing_physical_quantity(pq_name)
+            if existing_pq:
+                var['physicalQuantityUnit']['physicalQuantityId'] = existing_pq['id']
+                existing_unit = self.check_existing_unit(existing_pq, unit_name)
+                if not existing_unit:
+                    updated_pq = self.add_unit_to_existing_physical_quantity(existing_pq['id'], pq_name, unit_name)
+                    if updated_pq:
+                        new_unit = next((u for u in updated_pq['units'] if u['unit'] == unit_name), None)
+                        if new_unit:
+                            var['physicalQuantityUnit']['id'] = new_unit['id']
+            else:
+                new_pq = self.create_physical_quantity(pq_name, unit_name)
+                if new_pq:
+                    var['physicalQuantityUnit']['physicalQuantityId'] = new_pq['id']
+                    var['physicalQuantityUnit']['id'] = new_pq['units'][0]['id']
+
+        return model_data

qubicon/auth.py

@@ -0,0 +1,30 @@
+from .utils import make_request
+from .exceptions import AuthenticationError
+from .logger import get_logger
+
+logger = get_logger(__name__)
+
+def authenticate(config, username, password):
+    """
+    Authenticate with the Qubicon API and store the token in the config.
+
+    :param config: Config object.
+    :param username: User's username.
+    :param password: User's password.
+    :raises AuthenticationError: If authentication fails.
+    """
+    login_endpoint = '/api/login'
+    url = f"{config.base_url}{login_endpoint}"
+    data = {'username': username, 'password': password}
+    headers = {'Content-Type': 'application/json'}
+
+    logger.info("Attempting to authenticate with the Qubicon API...")
+    response = make_request('POST', url, headers=headers, json=data, timeout=config.timeout)
+
+    token = response.get('normal', {}).get('token')
+    if token:
+        config.save_token(token)
+        logger.info("Authentication successful.")
+    else:
+        logger.error("Authentication failed.")
+        raise AuthenticationError("Invalid credentials provided.")

qubicon/config.py

@@ -0,0 +1,36 @@
+import os
+
+class Config:
+    def __init__(self, base_url, timeout=30):
+        """
+        Configuration class for Qubicon API interactions.
+
+        :param base_url: Base URL of the Qubicon API (customer-specific).
+        :param timeout: Request timeout in seconds.
+        """
+        self.base_url = base_url.rstrip('/')
+        self.timeout = timeout
+        self.token = None
+        self.config_dir = os.path.expanduser('~/.qubicon')
+        self.token_file = os.path.join(self.config_dir, 'token')
+
+    def save_token(self, token):
+        """Save the authentication token."""
+        self.token = token
+        if not os.path.exists(self.config_dir):
+            os.makedirs(self.config_dir)
+        with open(self.token_file, 'w') as f:
+            f.write(token)
+
+    def load_token(self):
+        """Load the authentication token."""
+        if os.path.exists(self.token_file):
+            with open(self.token_file, 'r') as f:
+                self.token = f.read().strip()
+        return self.token
+
+    def delete_token(self):
+        """Delete the saved authentication token."""
+        if os.path.exists(self.token_file):
+            os.remove(self.token_file)
+        self.token = None

qubicon/exceptions.py

@@ -0,0 +1,19 @@
+class QubiconError(Exception):
+    """Base exception class for the Qubicon library."""
+    pass
+
+class AuthenticationError(QubiconError):
+    """Exception raised for authentication errors."""
+    pass
+
+class APIRequestError(QubiconError):
+    """Exception raised for API request errors."""
+    pass
+
+class NotFoundError(QubiconError):
+    """Exception raised when a requested resource is not found."""
+    pass
+
+class ValidationError(QubiconError):
+    """Exception raised for data validation errors."""
+    pass

qubicon/logger.py

@@ -0,0 +1,23 @@
+import logging
+
+def get_logger(name):
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        logger.setLevel(logging.DEBUG)
+        formatter = logging.Formatter(
+            '[%(asctime)s] %(levelname)s %(name)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+
+        # File handler
+        fh = logging.FileHandler('qubicon.log')
+        fh.setLevel(logging.DEBUG)
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+
+        # Console handler
+        ch = logging.StreamHandler()
+        ch.setLevel(logging.INFO)
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)
+    return logger

qubicon/utils.py

@@ -0,0 +1,48 @@
+import requests
+from .exceptions import AuthenticationError, APIRequestError
+from .logger import get_logger
+
+logger = get_logger(__name__)
+
+def make_request(method, url, headers=None, json=None, data=None, params=None, timeout=30):
+    try:
+        if method == 'POST' or method == 'PUT':
+            if json:
+                response = requests.request(
+                    method,
+                    url,
+                    headers=headers,
+                    json=json,  # Send JSON payload
+                    params=params,
+                    timeout=timeout
+                )
+            else:
+                response = requests.request(
+                    method,
+                    url,
+                    headers=headers,
+                    data=data,  # Send form data or other payload
+                    params=params,
+                    timeout=timeout
+                )
+        else:
+            response = requests.request(
+                method,
+                url,
+                headers=headers,
+                params=params,
+                timeout=timeout
+            )
+
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.HTTPError as e:
+        if response.status_code == 401:
+            logger.error("Authentication error: Unauthorized access.")
+            raise AuthenticationError("Unauthorized access.")
+        else:
+            logger.error(f"HTTP error occurred: {e}")
+            raise APIRequestError(f"HTTP error occurred: {e}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Request exception: {e}")
+        raise APIRequestError(f"Request exception: {e}")

qubicon-1.0.0.dist-info/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 QUBICON AG
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

qubicon-1.0.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: qubicon
+Version: 1.0.0
+Summary: Python library for the Qubicon Platform API
+Home-page: https://git.qub-lab.io/qub-client/qubicon-python-library
+Author: Stephan Karas
+Author-email: stephan.karas@qubicon-ag.com
+License: Apache License 2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+Requires-Dist: requests >=2.25.1
+Requires-Dist: rapidfuzz >=2.0.11
+Requires-Dist: pandas >=2.1.1
+Requires-Dist: tabulate >=0.9.0
+Requires-Dist: rich >=13.5.1
+Requires-Dist: re >=2.2.1
+

qubicon-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+qubicon/__init__.py,sha256=M5_Xl5iBE2ckr8goi4XC5dZqiBLYxSfXjiymB05JX7s,276
+qubicon/auth.py,sha256=kihZ9IgZrapzkDhaoH8PFcCFJUZRBUodWhsqMW1vk6Q,1099
+qubicon/config.py,sha256=eYRC1lUW58gVGgOpnujL12N9apZG9tmF90Z3-cFv8VU,1239
+qubicon/exceptions.py,sha256=ZNzJJoYLLknVxA_WlL3NwPUTOQUswxafc0AhrsmRD-s,532
+qubicon/logger.py,sha256=zu38MkUOac-oqidh1yyBGvn0NvnlljeMjODknNU5RSY,673
+qubicon/utils.py,sha256=4xysQkfEFadGCsO7t7ilUG2_fWMBAyyBJQAxtxCb0sk,1730
+qubicon/api/__init__.py,sha256=cW187QcNsxu8sJchJ_Q83vFtXg4yUpddySam46eAE1U,168
+qubicon/api/models.py,sha256=wymOttyaV6CF8zw075wc_s_NNXaoaIjiYxd-hipyZNM,9990
+qubicon/api/processes.py,sha256=deKVXKPVcnsNmZ98b2mT9gK7lofKtR2OrlcpWW8KJmc,6848
+qubicon/api/quantities.py,sha256=OK0u50u5B8GqQP4xgZTR_4UBYlhKMKV4CmH2oGZnzeY,7775
+qubicon-1.0.0.dist-info/LICENSE,sha256=4sNjFI-TB_VRlM6W6W7OhP4Q3FHI2cCl-P2Ov3P53Yk,11541
+qubicon-1.0.0.dist-info/METADATA,sha256=5xfPc-edBBq7hM84q83-tRJsyBP_Bfu6iHS89nzNCso,585
+qubicon-1.0.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+qubicon-1.0.0.dist-info/top_level.txt,sha256=ov8RJlegYZY6ylhFn6dVjgrKc4O4qKDIpDQdKfRN-Sg,8
+qubicon-1.0.0.dist-info/RECORD,,

qubicon-1.0.0.dist-info/WHEEL

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

qubicon-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+qubicon