quantum-pipeline 1.0.2__tar.gz

quantum_pipeline-1.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Piotr Krzysztof Lis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

quantum_pipeline-1.0.2/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: quantum-pipeline
+Version: 1.0.2
+Summary: Framework for running, monitoring and analysing quantum algorithms.
+Author-Email: Piotr Krzysztof <piotrlis555@gmail.com>
+Maintainer-Email: Piotr Krzysztof <piotrlis555@gmail.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://github.com/straightchlorine/quantum-pipeline
+Requires-Python: <3.13,>=3.10
+Requires-Dist: qiskit>=1.0.0
+Requires-Dist: qiskit-ibm-runtime>=0.20.0
+Requires-Dist: qiskit-aer>=0.15.1
+Requires-Dist: qiskit-nature>=0.7.0
+Requires-Dist: qiskit-qasm3-import>=0.5.1
+Requires-Dist: openqasm3>=1.0.0
+Requires-Dist: rustworkx>=0.13.0
+Requires-Dist: pyscf>=2.7.0
+Requires-Dist: numpy>=1.22.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: reportlab>=4.2.5
+Requires-Dist: h5py>=3.8.0
+Requires-Dist: sympy>=1.11.0
+Requires-Dist: kafka-python-ng>=2.2.3
+Requires-Dist: avro>=1.12.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: debugpy; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: ipdb; extra == "dev"
+Requires-Dist: pytest>=7.3.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-all; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: py-spy; extra == "dev"
+Requires-Dist: memory-profiler; extra == "dev"
+Requires-Dist: line-profiler; extra == "dev"
+Requires-Dist: jupyter; extra == "dev"
+Requires-Dist: notebook; extra == "dev"
+Requires-Dist: jupyterlab; extra == "dev"
+Requires-Dist: ipykernel; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: pdoc3; extra == "dev"
+Requires-Dist: bandit; extra == "dev"
+Requires-Dist: safety; extra == "dev"
+

quantum_pipeline-1.0.2/pyproject.toml

@@ -0,0 +1,161 @@
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[project]
+name = "quantum-pipeline"
+description = "Framework for running, monitoring and analysing quantum algorithms."
+authors = [
+    { name = "Piotr Krzysztof", email = "piotrlis555@gmail.com" },
+]
+maintainers = [
+    { name = "Piotr Krzysztof", email = "piotrlis555@gmail.com" },
+]
+version = "1.0.2"
+requires-python = ">=3.10,<3.13"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Physics",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "qiskit>=1.0.0",
+    "qiskit-ibm-runtime>=0.20.0",
+    "qiskit-aer>=0.15.1",
+    "qiskit-nature>=0.7.0",
+    "qiskit-qasm3-import>=0.5.1",
+    "openqasm3>=1.0.0",
+    "rustworkx>=0.13.0",
+    "pyscf>=2.7.0",
+    "numpy>=1.22.0",
+    "scipy>=1.10.0",
+    "pandas>=2.0.0",
+    "matplotlib>=3.7.0",
+    "reportlab>=4.2.5",
+    "h5py>=3.8.0",
+    "sympy>=1.11.0",
+    "kafka-python-ng>=2.2.3",
+    "avro>=1.12.0",
+    "pydantic>=2.0.0",
+    "python-dotenv>=1.0.0",
+]
+
+[project.license]
+text = "MIT"
+
+[project.optional-dependencies]
+dev = [
+    "debugpy",
+    "ipython",
+    "ipdb",
+    "pytest>=7.3.0",
+    "pytest-cov",
+    "pytest-mock",
+    "hypothesis",
+    "mypy",
+    "types-all",
+    "ruff",
+    "black",
+    "isort",
+    "py-spy",
+    "memory-profiler",
+    "line-profiler",
+    "jupyter",
+    "notebook",
+    "jupyterlab",
+    "ipykernel",
+    "sphinx",
+    "pdoc3",
+    "bandit",
+    "safety",
+]
+
+[project.urls]
+Homepage = "https://github.com/straightchlorine/quantum-pipeline"
+
+[project.scripts]
+quantum-pipeline = "quantum_pipeline.cli:main"
+
+[tool.ruff]
+line-length = 99
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "W",
+    "I",
+    "N",
+    "UP",
+    "ASYNC",
+    "S",
+    "C4",
+]
+ignore = [
+    "E501",
+]
+
+[tool.ruff.format]
+quote-style = "single"
+indent-style = "space"
+docstring-code-format = true
+
+[tool.black]
+line-length = 99
+target-version = [
+    "py310",
+]
+include = "\\.pyi?$"
+extend-exclude = "/(\n  # directories\n  \\.eggs\n  | \\.git\n  | \\.hg\n  | \\.mypy_cache\n  | \\.tox\n  | \\.venv\n  | build\n  | dist\n)/\n"
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+addopts = "-ra -q"
+testpaths = [
+    "tests",
+]
+pythonpath = [
+    ".",
+]
+
+[tool.coverage.run]
+source = [
+    "quantum_pipeline",
+]
+omit = [
+    "tests/*",
+]
+
+[tool.flake8]
+max-line-length = 127
+max-complexity = 10
+ignore = [
+    "C901",
+]
+select = [
+    "E9",
+    "F63",
+    "F7",
+    "F82",
+]
+exclude = [
+    ".git",
+    "__pycache__",
+    "venv",
+    "build",
+    "dist",
+]

quantum_pipeline-1.0.2/quantum_pipeline/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.0.2'

quantum_pipeline-1.0.2/quantum_pipeline/configs/defaults.py

@@ -0,0 +1,26 @@
+DEFAULTS = {
+    'basis_set': 'sto3g',
+    'ansatz_reps': 2,
+    'local': True,
+    'ibm_quantum': False,
+    'max_iterations': 100,
+    'convergence_threshold_enable': False,
+    'convergence_threshold': 1e-6,
+    'optimizer': 'COBYLA',
+    'shots': 1024,
+    'backend': {
+        'local': True,
+        'min_qubits': None,
+        'optimization_level': 3,
+        'filters': None,
+    },
+    'kafka': {
+        'servers': 'localhost:9092',
+        'topic': 'vqe_results',
+        'retries': 3,
+        'internal_retries': 0,
+        'acks': 'all',
+        'timeout': 10,
+        'retry_delay': 2,
+    },
+}

quantum_pipeline-1.0.2/quantum_pipeline/configs/parsing/argparser.py

@@ -0,0 +1,258 @@
+import argparse
+import logging
+import os
+from typing import Any, Dict
+
+from quantum_pipeline.configs import settings
+from quantum_pipeline.configs.defaults import DEFAULTS
+from quantum_pipeline.configs.parsing.configuration_manager import ConfigurationManager
+from quantum_pipeline.utils.dir import ensureDirExists
+from quantum_pipeline.utils.logger import get_logger
+
+
+class QuantumPipelineArgParser:
+    """Class for handling command line argument parsing for quantum pipeline."""
+
+    def __init__(self):
+        """Initialize the parser with default configuration."""
+        self.logger = get_logger('Argparser')
+
+        self.initialize_simulation_environment()
+        self.parser = argparse.ArgumentParser(
+            description='Quantum Circuit Simulation and Execution',
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+        )
+
+        self._add_arguments()
+
+    def initialize_simulation_environment(self):
+        """Ensure required directories and configurations are in place."""
+        ensureDirExists(settings.GEN_DIR)
+        ensureDirExists(settings.GRAPH_DIR)
+        ensureDirExists(settings.REPORT_DIR)
+        ensureDirExists(settings.RUN_CONFIGS)
+
+    def _create_optimizer_help_text(self) -> str:
+        """Create detailed help text for optimizer options."""
+        help_text = 'Available optimizers:\n'
+        for optimizer, description in settings.SUPPORTED_OPTIMIZERS.items():
+            help_text += f'|  {optimizer}: {description} |'
+        return help_text
+
+    def _add_arguments(self):
+        """Add all argument groups and their arguments to the parser."""
+        self._add_required_arguments()
+        self._add_simulation_config()
+        self._add_vqe_parameters()
+        self._add_output_logging()
+        self._add_backend_options()
+        self._add_kafka_config()
+        self._add_additional_features()
+
+    def _add_required_arguments(self):
+        """Add required arguments to the parser."""
+        self.parser.add_argument(
+            '-f', '--file', required=True, help='Path to molecule data file (JSON)'
+        )
+
+    def _add_simulation_config(self):
+        """Add simulation configuration arguments."""
+        sim_group = self.parser.add_argument_group('Simulation Configuration')
+        sim_group.add_argument(
+            '-b', '--basis', default=DEFAULTS['basis_set'], help='Basis set for the simulation'
+        )
+        sim_group.add_argument(
+            '-ar',
+            '--ansatz-reps',
+            default=DEFAULTS['ansatz_reps'],
+            help='Amount of reps for the ansatz',
+        )
+        sim_group.add_argument(
+            '--ibm',
+            action='store_false',
+            default=DEFAULTS['backend']['local'],
+            help='Using IBM Quantum backend for simulation (otherwise local Aer simulator is used.)',
+        )
+        sim_group.add_argument(
+            '--min-qubits',
+            type=int,
+            default=DEFAULTS['backend']['min_qubits'],
+            help='Minimum number of qubits required for the backend',
+        )
+
+    def _add_kafka_config(self):
+        """Add simulation configuration arguments."""
+        kafka_group = self.parser.add_argument_group('Kafka Configuration')
+        kafka_group.add_argument(
+            '--kafka', action='store_true', help='Enable streaming results to Apache Kafka'
+        )
+        kafka_group.add_argument(
+            '--servers',
+            type=str,
+            default=DEFAULTS['kafka']['servers'],
+            help='Apache Kafka instance address',
+        )
+        kafka_group.add_argument(
+            '--topic',
+            type=str,
+            default=DEFAULTS['kafka']['topic'],
+            help='Name of the topic, with which message will be categorised with',
+        )
+        kafka_group.add_argument(
+            '--retries',
+            type=str,
+            default=DEFAULTS['kafka']['retries'],
+            help='Number of attempts to send message to kafka',
+        )
+        kafka_group.add_argument(
+            '--retry-delay',
+            type=str,
+            default=DEFAULTS['kafka']['retries'],
+            help='Number of attempts to send message to kafka',
+        )
+        kafka_group.add_argument(
+            '--internal-retries',
+            type=int,
+            default=DEFAULTS['kafka']['internal_retries'],
+            help='Number of attempts kafka should attempt automatically (introduces risk of duplicate entries)',
+        )
+        kafka_group.add_argument(
+            '--acks',
+            default=DEFAULTS['kafka']['acks'],
+            choices=['0', '1', 'all'],
+            help='Number of acknowledgments producer requires to receive before a request is complete.',
+        )
+        kafka_group.add_argument(
+            '--timeout',
+            type=int,
+            default=DEFAULTS['kafka']['timeout'],
+            help='Number of seconds required for producer to consider request as failed',
+        )
+
+    def _add_vqe_parameters(self):
+        """Add VQE-specific parameters."""
+        vqe_group = self.parser.add_argument_group('VQE Parameters')
+        vqe_group.add_argument(
+            '--max-iterations',
+            type=int,
+            default=DEFAULTS['max_iterations'],
+            help='Maximum number of VQE iterations',
+        )
+
+        vqe_group.add_argument(
+            '--convergence',
+            action='store_true',
+            default=DEFAULTS['convergence_threshold_enable'],
+            help='Enable convergence threshold during minimization',
+        )
+        vqe_group.add_argument(
+            '--threshold',
+            type=float,
+            default=DEFAULTS['convergence_threshold'],
+            help='Set convergence threshold for VQE optimization',
+        )
+        vqe_group.add_argument(
+            '--optimizer',
+            choices=list(settings.SUPPORTED_OPTIMIZERS.keys()),
+            default=DEFAULTS['optimizer'],
+            help=self._create_optimizer_help_text(),
+            metavar='OPTIMIZER',
+        )
+
+    def _add_output_logging(self):
+        """Add output and logging related arguments."""
+        output_group = self.parser.add_argument_group('Output and Logging')
+        output_group.add_argument(
+            '--output-dir', default=settings.GEN_DIR, help='Directory to store output files'
+        )
+        output_group.add_argument(
+            '--log-level',
+            choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+            default='INFO',
+            help='Set the logging level',
+        )
+
+    def shots(self, shots):
+        if int(shots) <= 0:
+            raise argparse.ArgumentTypeError(f'shots:{shots} is not a valid number')
+        return shots
+
+    def _add_backend_options(self):
+        """Add advanced backend configuration options."""
+        backend_group = self.parser.add_argument_group('Advanced Backend Options')
+        backend_group.add_argument(
+            '--shots',
+            type=self.shots,
+            default=DEFAULTS['shots'],
+            help='Number of shots for quantum circuit execution',
+        )
+        backend_group.add_argument(
+            '--optimization-level',
+            type=int,
+            choices=[0, 1, 2, 3],
+            default=DEFAULTS['backend']['optimization_level'],
+            help='Circuit optimization level',
+        )
+
+    def dir_path(self, path):
+        if os.path.isfile(path):
+            return path
+        else:
+            raise argparse.ArgumentTypeError(f'readable_dir:{path} is not a valid path')
+
+    def _add_additional_features(self):
+        """Add additional feature arguments."""
+        additional_group = self.parser.add_argument_group('Additional Features')
+        additional_group.add_argument(
+            '--report', action='store_true', help='Generate a PDF report after simulation'
+        )
+        additional_group.add_argument(
+            '--dump',
+            action='store_true',
+            help='Dump configuration generated by the parameters into JSON file',
+        )
+        additional_group.add_argument(
+            '--load',
+            type=self.dir_path,
+            help='Path to a JSON configuration file to load parameters from',
+        )
+
+    def kafka_params_set(self, args: argparse.Namespace):
+        if (
+            args.servers != DEFAULTS['kafka']['servers']
+            or args.topic != DEFAULTS['kafka']['topic']
+            or args.retries != DEFAULTS['kafka']['retries']
+            or args.internal_retries != DEFAULTS['kafka']['internal_retries']
+            or args.acks != DEFAULTS['kafka']['acks']
+            or args.timeout != DEFAULTS['kafka']['timeout']
+        ):
+            return True
+        return False
+
+    def _validate_args(self, args: argparse.Namespace) -> None:
+        """Validate parsed arguments."""
+        settings.LOG_LEVEL = getattr(logging, args.log_level)
+
+        if args.dump and args.load:
+            self.parser.error('--dump and --load cannot be used together.')
+
+        if args.min_qubits is not None and not args.ibm_quantum:
+            self.parser.error('--min-qubits can only be used if --ibm-quantum is selected.')
+
+        if args.convergence and args.threshold is None:
+            self.parser.error('--threshold must be set if --convergence is enabled.')
+
+        if self.kafka_params_set(args) and not args.kafka:
+            self.parser.error('--kafka must be set for the options to take effect.')
+
+    def parse_args(self) -> argparse.Namespace:
+        """Parse and validate command line arguments."""
+        args = self.parser.parse_args()
+        self._validate_args(args)
+        return args
+
+    def get_config(self) -> Dict[str, Any]:
+        """Get the configuration from the parsed arguments."""
+        config_manager = ConfigurationManager()
+        args = self.parse_args()
+        return config_manager.get_config(args)

quantum_pipeline-1.0.2/quantum_pipeline/configs/parsing/backend_config.py

@@ -0,0 +1,38 @@
+from dataclasses import asdict, dataclass
+from typing import Any, Callable, Dict
+
+from qiskit_ibm_runtime import IBMBackend
+
+
+@dataclass
+class BackendConfig:
+    """Dataclass for storing backend filter."""
+
+    local: bool | None
+    optimization_level: int | None
+    min_num_qubits: int | None
+    filters: Callable[[IBMBackend], bool] | None
+
+    def to_dict(self):
+        """Convert the dataclass to a dictionary."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'BackendConfig':
+        """Create a BackendConfig instance from a dictionary."""
+        return cls(
+            local=data.get('local'),
+            optimization_level=data.get('optimization_level'),
+            min_num_qubits=data.get('min_num_qubits'),
+            filters=None,
+        )
+
+    @classmethod
+    def default_backend_config(cls) -> 'BackendConfig':
+        """Return the default backend configuration."""
+        return cls(
+            local=True,
+            optimization_level=3,
+            min_num_qubits=None,
+            filters=None,
+        )

quantum_pipeline-1.0.2/quantum_pipeline/configs/parsing/configuration_manager.py

@@ -0,0 +1,124 @@
+import argparse
+from copy import deepcopy
+from datetime import datetime
+import json
+from pathlib import Path
+from typing import Any, Dict
+
+from quantum_pipeline.configs import settings
+from quantum_pipeline.configs.parsing.backend_config import BackendConfig
+from quantum_pipeline.configs.parsing.producer_config import ProducerConfig
+from quantum_pipeline.utils.logger import get_logger
+
+
+class ConfigurationManager:
+    """Class for managing application configurations."""
+
+    def __init__(self):
+        self.logger = get_logger(self.__class__.__name__)
+
+    def create_kafka_config(self, args: argparse.Namespace) -> ProducerConfig:
+        """Create Kafka configuration from arguments."""
+        return ProducerConfig.from_dict(
+            {
+                'servers': args.servers,
+                'topic': args.topic,
+                'retries': args.retries,
+                'retry_delay': args.retry_delay,
+                'kafka_retries': args.internal_retries,
+                'acks': args.acks,
+                'timeout': args.timeout,
+            }
+        )
+
+    def create_backend_config(self, args: argparse.Namespace) -> BackendConfig:
+        """Create Backend configuration from arguments."""
+        return BackendConfig.from_dict(
+            {
+                'local': args.ibm,
+                'min_num_qubits': args.min_qubits,
+                'optimization_level': args.optimization_level,
+                'filters': None,
+            }
+        )
+
+    def dump(self, args: argparse.Namespace, config: Dict[str, Any]):
+        """Dump the configurations for debugging or logging."""
+
+        self.logger.debug('Dumping configuration into the file...')
+
+        # create a copy thats JSON serializable
+        config_dict = deepcopy(config)
+        config_dict['backend_config'] = self.create_backend_config(args)
+        config_dict['kafka_config'] = self.create_kafka_config(args)
+        config_dict['backend_config'] = config_dict['backend_config'].to_dict()
+        config_dict['kafka_config'] = config_dict['kafka_config'].to_dict()
+
+        for k in list(config_dict.keys()):
+            if k in config_dict.get('backend_config', {}):
+                config_dict.pop(k)
+            if k in config_dict.get('kafka_config', {}):
+                config_dict.pop(k)
+
+        #  create a filename
+        file_name = Path(args.file).stem
+        basis_set = args.basis
+        optimizer = args.optimizer
+        backend_local = 'api' if args.ibm else 'local'
+        current_date = datetime.now().strftime('%Y%m%d')
+
+        file_path = f'{file_name}-{basis_set}-{optimizer}-{backend_local}-{current_date}.json'
+        self.config_path = Path(settings.RUN_CONFIGS, file_path)
+
+        try:
+            with open(self.config_path, 'w') as file:
+                json.dump(config_dict, file, indent=4)
+        except Exception as e:
+            self.logger.error(f'Failed to save configuration: {e}')
+            raise
+
+        self.logger.info(f'Configuration saved to:\n\n{file_path}\n')
+        self.logger.debug(f'Arguments:\n\n{vars(args)}\n')
+        self.logger.debug(f'Configurations:\n\n{config_dict}\n')
+
+    def load(self, file_path: str) -> Dict[str, Any]:
+        """Load the configurations from a JSON file."""
+        try:
+            self.logger.debug(f'Loading configuration from:\n\n{file_path}\n')
+            with open(file_path, 'r') as file:
+                config_dict = json.load(file)
+
+            # reconstruct config objects
+            backend_config = BackendConfig.from_dict(config_dict['backend_config'])
+            kafka_config = ProducerConfig.from_dict(config_dict['kafka_config'])
+
+            # build full dictionary
+            config_dict['backend_config'] = backend_config
+            config_dict['kafka_config'] = kafka_config
+
+            self.logger.info(f'Configuration loaded from:\n\n{file_path}\n')
+            self.logger.debug(f'Loaded configurations:\n\n{config_dict}\n')
+            return config_dict
+
+        except FileNotFoundError:
+            self.logger.error(f'Configuration file not found: {file_path}')
+            raise
+        except json.JSONDecodeError as e:
+            self.logger.error(f'Failed to parse JSON configuration: {e}')
+            raise
+
+    def get_config(self, args: argparse.Namespace) -> Dict[str, Any]:
+        """Convert parsed arguments dynamically into a dictionary."""
+
+        if args.load:
+            self.load(args.load)
+
+        # create a dictionary from the parsed arguments
+        config_dict = {key: value for key, value in vars(args).items() if key != 'local'}
+        config_dict['kafka_config'] = self.create_kafka_config(args)
+        config_dict['backend_config'] = self.create_backend_config(args)
+
+        if args.dump:
+            self.dump(args, config_dict)
+
+        return config_dict