azure-quantum 3.1.1.dev2__tar.gz → 3.3.0__tar.gz

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-quantum
-Version: 3.1.1.dev2
+Version: 3.3.0
 Summary: Python client for Azure Quantum
 Home-page: https://github.com/microsoft/azure-quantum-python
 Author: Microsoft
@@ -14,7 +14,7 @@ Requires-Dist: azure-core<2.0,>=1.30
 Requires-Dist: azure-identity<2.0,>=1.17
 Requires-Dist: azure-storage-blob==12.20
 Requires-Dist: msrest<1.0,>=0.7.1
-Requires-Dist: numpy>=1.21.0
+Requires-Dist: numpy<2.0,>=1.21.0
 Requires-Dist: deprecated<2.0,>=1.2.12
 Requires-Dist: Markdown>=3.4.1
 Requires-Dist: python-markdown-math>=0.8

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/azure/quantum/_client/_version.py

@@ -6,4 +6,4 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "3.1.1.dev2"
+VERSION = "3.3.0"

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/azure/quantum/job/job.py

@@ -111,7 +111,7 @@ class Job(BaseJob, FilteredJob):
         Raises :class:`ValueError` if job output is malformed or output format is not compatible.
 
         Raises :class:`azure.quantum.job.JobFailedWithResultsError` if job execution fails, 
-                but failure results could still be retrieved (e.g. for jobs submitted against "microsoft.dft" target).
+                but failure results could still be retrieved.
 
         :param timeout_secs: Timeout in seconds, defaults to 300
         :type timeout_secs: float
@@ -274,7 +274,7 @@ class Job(BaseJob, FilteredJob):
         Raises :class:`ValueError` if job output is malformed or output format is not compatible.
 
         Raises :class:`azure.quantum.job.JobFailedWithResultsError` if job execution fails, 
-                but failure results could still be retrieved (e.g. for jobs submitted against "microsoft.dft" target).
+                but failure results could still be retrieved.
 
         :param timeout_secs: Timeout in seconds, defaults to 300
         :type timeout_secs: float

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/azure/quantum/target/__init__.py

@@ -10,7 +10,6 @@ from .ionq import IonQ
 from .quantinuum import Quantinuum
 from .rigetti import Rigetti
 from .pasqal import Pasqal
-from .microsoft.elements.dft import MicrosoftElementsDft, MicrosoftElementsDftJob
 
 # Default targets to use when there is no target class
 # associated with a given target ID

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/azure/quantum/target/rigetti/target.py

@@ -32,6 +32,8 @@ class RigettiTarget(str, Enum):
 
     ANKAA_3 = "rigetti.qpu.ankaa-3"
 
+    CEPHEUS_1_36Q = "rigetti.qpu.cepheus-1-36q"
+
     def simulators() -> List[str]:
         """Returns a list of simulator targets"""
         return [
@@ -42,6 +44,7 @@ class RigettiTarget(str, Enum):
         """Returns a list of QPU targets"""
         return [
             RigettiTarget.ANKAA_3.value,
+            RigettiTarget.CEPHEUS_1_36Q
         ]
 
     def num_qubits(target_name) -> int:
@@ -51,6 +54,8 @@ class RigettiTarget(str, Enum):
             return 20
         elif target_name == RigettiTarget.ANKAA_3.value:
             return 84
+        elif target_name == RigettiTarget.CEPHEUS_1_36Q.value:
+            return 36
         else:
             raise ValueError(f"Unknown target {target_name}")
 

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/azure/quantum/version.py

@@ -5,4 +5,4 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 ##
-__version__ = "3.1.1.dev2"
+__version__ = "3.3.0"

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/azure_quantum.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-quantum
-Version: 3.1.1.dev2
+Version: 3.3.0
 Summary: Python client for Azure Quantum
 Home-page: https://github.com/microsoft/azure-quantum-python
 Author: Microsoft
@@ -14,7 +14,7 @@ Requires-Dist: azure-core<2.0,>=1.30
 Requires-Dist: azure-identity<2.0,>=1.17
 Requires-Dist: azure-storage-blob==12.20
 Requires-Dist: msrest<1.0,>=0.7.1
-Requires-Dist: numpy>=1.21.0
+Requires-Dist: numpy<2.0,>=1.21.0
 Requires-Dist: deprecated<2.0,>=1.2.12
 Requires-Dist: Markdown>=3.4.1
 Requires-Dist: python-markdown-math>=0.8

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/azure_quantum.egg-info/SOURCES.txt

@@ -63,10 +63,6 @@ azure/quantum/target/params.py
 azure/quantum/target/quantinuum.py
 azure/quantum/target/target.py
 azure/quantum/target/target_factory.py
-azure/quantum/target/microsoft/elements/__init__.py
-azure/quantum/target/microsoft/elements/dft/__init__.py
-azure/quantum/target/microsoft/elements/dft/job.py
-azure/quantum/target/microsoft/elements/dft/target.py
 azure/quantum/target/pasqal/__init__.py
 azure/quantum/target/pasqal/result.py
 azure/quantum/target/pasqal/target.py

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/azure_quantum.egg-info/requires.txt

@@ -2,7 +2,7 @@ azure-core<2.0,>=1.30
 azure-identity<2.0,>=1.17
 azure-storage-blob==12.20
 msrest<1.0,>=0.7.1
-numpy>=1.21.0
+numpy<2.0,>=1.21.0
 deprecated<2.0,>=1.2.12
 Markdown>=3.4.1
 python-markdown-math>=0.8

{azure_quantum-3.1.1.dev2 → azure_quantum-3.3.0}/requirements.txt

@@ -4,7 +4,7 @@ azure-identity>=1.17,<2.0
 # More than one match for "https://mystorage.blob.core.windows.net/.../rawOutputData"
 azure-storage-blob==12.20
 msrest>=0.7.1,<1.0
-numpy>=1.21.0
+numpy>=1.21.0,<2.0
 deprecated>=1.2.12,<2.0
 Markdown>=3.4.1
 python-markdown-math>=0.8

azure_quantum-3.1.1.dev2/azure/quantum/target/microsoft/elements/__init__.py

@@ -1 +0,0 @@
-"""Defines classes for interacting with Microsoft Elements services"""

azure_quantum-3.1.1.dev2/azure/quantum/target/microsoft/elements/dft/__init__.py

@@ -1,6 +0,0 @@
-"""Defines classes for interacting with Microsoft Elements DFT service"""
-
-from .target import MicrosoftElementsDft
-from .job import MicrosoftElementsDftJob
-
-__all__ = ["MicrosoftElementsDft", "MicrosoftElementsDftJob"]

azure_quantum-3.1.1.dev2/azure/quantum/target/microsoft/elements/dft/job.py

@@ -1,171 +0,0 @@
-import collections.abc
-import logging
-from typing import Any, Dict, Union, Optional
-from azure.quantum.job import JobFailedWithResultsError
-from azure.quantum.job.base_job import BaseJob, ContentType
-from azure.quantum.job.job import Job, DEFAULT_TIMEOUT
-from azure.quantum._client.models import JobDetails
-from azure.quantum.workspace import Workspace
-
-logger = logging.getLogger(__name__)
-
-class MicrosoftElementsDftJob(Job):
-    """
-    A dedicated job class for jobs from the microsoft.dft target.
-    """
-
-    def __init__(self, workspace, job_details: JobDetails, **kwargs):
-        """Azure Quantum Job that is submitted to a given Workspace.
-
-        :param workspace: Workspace instance to submit job to
-        :type workspace: Workspace
-        :param job_details: Job details model,
-                contains Job ID, name and other details
-        :type job_details: JobDetails
-        """
-        super().__init__(workspace, job_details, **kwargs)
-
-
-    def get_results(self, timeout_secs: float = DEFAULT_TIMEOUT) -> Dict[str, Any]:
-        """Get job results by downloading the results blob from the
-        storage container linked via the workspace.
-
-        :param timeout_secs: Timeout in seconds, defaults to 300
-        :type timeout_secs: float
-        :raises: :class:`RuntimeError` if job execution failed.
-        :raises: :class:`azure.quantum.job.JobFailedWithResultsError` if job execution failed,
-                but failure results could still be retrieved.
-        :return: Results dictionary.
-        """
-
-        try:
-            job_results = super().get_results(timeout_secs)
-            return job_results
-        except JobFailedWithResultsError as e:
-                failure_results = e.get_failure_results()
-                if MicrosoftElementsDftJob._is_dft_failure_results(failure_results):
-                    error = failure_results["results"][0]["error"]
-                    message = f'{e.get_message()} Error type: {error["error_type"]}. Message: {error["error_message"]}'
-                    raise JobFailedWithResultsError(message, failure_results) from None
-
-
-    @classmethod
-    def _allow_failure_results(cls) -> bool: 
-        """
-        Allow to download job results even if the Job status is "Failed".
-        """
-        return True
-
-
-    @staticmethod
-    def _is_dft_failure_results(failure_results: Union[Dict[str, Any], str]) -> bool:
-         return isinstance(failure_results, dict) \
-                    and "results" in failure_results \
-                    and isinstance(failure_results["results"], collections.abc.Sequence) \
-                    and len(failure_results["results"]) > 0 \
-                    and isinstance(failure_results["results"][0], dict) \
-                    and "error" in failure_results["results"][0] \
-                    and isinstance(failure_results["results"][0]["error"], dict) \
-                    and "error_type" in failure_results["results"][0]["error"] \
-                    and "error_message" in failure_results["results"][0]["error"]
-
-    @classmethod
-    def from_input_data_container(
-        cls,
-        workspace: "Workspace",
-        name: str,
-        target: str,
-        input_data: bytes,
-        batch_input_blobs: Dict[str, bytes],
-        content_type: ContentType = ContentType.json,
-        blob_name: str = "inputData",
-        encoding: str = "",
-        job_id: str = None,
-        container_name: str = None,
-        provider_id: str = None,
-        input_data_format: str = None,
-        output_data_format: str = None,
-        input_params: Dict[str, Any] = None,
-        session_id: Optional[str] = None,
-        **kwargs
-    ) -> "BaseJob":
-        """Create a new Azure Quantum job based on a list of input_data.
-
-        :param workspace: Azure Quantum workspace to submit the input_data to
-        :type workspace: Workspace
-        :param name: Name of the job
-        :type name: str
-        :param target: Azure Quantum target
-        :type target: str
-        :param input_data: Raw input data to submit
-        :type input_data: Dict
-        :param blob_name: Dict of Input data json to gives a table of contents
-        :type batch_input_blobs: Dict
-        :param blob_name: Dict of QcSchema Data where the key is the blob name to store it in the container
-        :type blob_name: str
-        :param content_type: Content type, e.g. "application/json"
-        :type content_type: ContentType
-        :param encoding: input_data encoding, e.g. "gzip", defaults to empty string
-        :type encoding: str
-        :param job_id: Job ID, defaults to None
-        :type job_id: str
-        :param container_name: Container name, defaults to None
-        :type container_name: str
-        :param provider_id: Provider ID, defaults to None
-        :type provider_id: str
-        :param input_data_format: Input data format, defaults to None
-        :type input_data_format: str
-        :param output_data_format: Output data format, defaults to None
-        :type output_data_format: str
-        :param input_params: Input parameters, defaults to None
-        :type input_params: Dict[str, Any]
-        :param input_params: Input params for job
-        :type input_params: Dict[str, Any]
-        :return: Azure Quantum Job
-        :rtype: Job
-        """
-        # Generate job ID if not specified
-        if job_id is None:
-            job_id = cls.create_job_id()
-
-        # Create container if it does not yet exist
-        container_uri = workspace.get_container_uri(
-            job_id=job_id,
-            container_name=container_name
-        )
-        logger.debug(f"Container URI: {container_uri}")
-
-        # Upload Input Data
-        input_data_uri = cls.upload_input_data(
-            container_uri=container_uri,
-            input_data=input_data,
-            content_type=content_type,
-            blob_name=blob_name,
-            encoding=encoding,
-        )
-
-        # Upload data to container
-        for blob_name, input_data_item in batch_input_blobs.items():
-            cls.upload_input_data(
-                container_uri=container_uri,
-                input_data=input_data_item,
-                content_type=content_type,
-                blob_name=blob_name,
-                encoding=encoding,
-            )
-
-        # Create and submit job
-        return cls.from_storage_uri(
-            workspace=workspace,
-            job_id=job_id,
-            target=target,
-            input_data_uri=input_data_uri,
-            container_uri=container_uri,
-            name=name,
-            input_data_format=input_data_format,
-            output_data_format=output_data_format,
-            provider_id=provider_id,
-            input_params=input_params,
-            session_id=session_id,
-            **kwargs
-        )

azure_quantum-3.1.1.dev2/azure/quantum/target/microsoft/elements/dft/target.py

@@ -1,316 +0,0 @@
-import warnings
-
-from azure.quantum.job.base_job import ContentType
-from azure.quantum.job.job import Job
-from azure.quantum.target.target import Target
-from azure.quantum.workspace import Workspace
-from azure.quantum.target.params import InputParams
-from typing import Any, Dict, Type, Union, List
-from .job import MicrosoftElementsDftJob
-from pathlib import Path
-import copy
-import json
-from collections import defaultdict
-
-
-class MicrosoftElementsDft(Target):
-    """
-    Microsoft Elements Dft target from the microsoft-elements provider.
-    """
-
-    target_names = [
-        "microsoft.dft"
-    ]
-
-
-    def __init__(
-        self,
-        workspace: "Workspace",
-        name: str = "microsoft.dft",
-        **kwargs
-    ):
-        """
-        Initializes a new DFT target.
-
-        :param workspace: Associated workspace
-        :type workspace: Workspace
-        :param name: Target name
-        """
-        # There is only a single target name for this target
-        assert name == self.target_names[0]
-
-        # make sure to not pass argument twice
-        kwargs.pop("provider_id", None)
-
-        super().__init__(
-            workspace=workspace,
-            name=name,
-            input_data_format="microsoft.xyz.v1",
-            output_data_format="microsoft.dft-results.v1",
-            provider_id="microsoft-elements",
-            content_type=ContentType.text_plain,
-            **kwargs
-        )
-
-
-    def submit(self,
-               input_data: Any,
-               name: str = "azure-quantum-dft-job",
-               shots: int = None,
-               input_params: Union[Dict[str, Any], InputParams, None] = None,
-               **kwargs) -> MicrosoftElementsDftJob:
-        """
-        Submit DFT job to Azure Quantum Services.
-        
-        :param input_data: Input data
-        :type input_data: Any
-        :param name: Job name
-        :type name: str
-        :param shots: Number of shots. Ignored in DFT job. Defaults to None
-        :type shots: int
-        :param input_params: Input parameters
-        :type input_params: Dict[str, Any]
-        :return: Azure Quantum job
-        :rtype: Job
-        """
-
-        if shots is not None:
-            warnings.warn("The 'shots' parameter is ignored in Microsoft Elements Dft job.")
-        
-        if isinstance(input_data, list):
-
-            if len(input_data) < 1:
-                raise ValueError("Input data list has no elements.")
-
-            if all(isinstance(task,str) for task in input_data):
-                qcschema_data = self.assemble_qcschema_from_files(input_data, input_params)
-            
-                qcschema_blobs = {}
-                for i in range(len(qcschema_data)):
-                    qcschema_blobs[f"inputData_{i}"] = self._encode_input_data(qcschema_data[i])
-            
-                toc_str = self._create_table_of_contents(input_data, list(qcschema_blobs.keys()))
-            elif all(isinstance(task,dict) for task in input_data): 
-                qcschema_blobs = {}
-                for i in range(len(input_data)):
-                    qcschema_blobs[f"inputData_{i}"] = self._encode_input_data(input_data[i])
-                toc_str = '{"description": "QcSchema Objects were given for input."}'
-            else:
-                raise ValueError(f"Unsupported batch submission. Please use List[str] or List[dict].")
-            toc = self._encode_input_data(toc_str)
-
-            input_params = {} if input_params is None else input_params
-            return self._get_job_class().from_input_data_container(
-                workspace=self.workspace,
-                name=name,
-                target=self.name,
-                input_data=toc,
-                batch_input_blobs=qcschema_blobs,
-                input_params={ 'numberOfFiles': len(input_data), "inputFiles": list(qcschema_blobs.keys()), **input_params },
-                content_type=kwargs.pop('content_type', self.content_type),
-                encoding=kwargs.pop('encoding', self.encoding),
-                provider_id=self.provider_id,
-                input_data_format=kwargs.pop('input_data_format', 'microsoft.qc-schema.v1'),
-                output_data_format=kwargs.pop('output_data_format', self.output_data_format),
-                session_id=self.get_latest_session_id(),
-                **kwargs
-            )
-        else:
-            return super().submit(
-                input_data=input_data,
-                name=name, 
-                shots=shots, 
-                input_params=input_params,
-                **kwargs
-            )
-
-
-    
-    @classmethod
-    def assemble_qcschema_from_files(self, input_data: Union[List[str]], input_params: Dict) -> List[Dict]:
-        """
-        Convert a list of files to a list of QcSchema objects that are ready for submission.
-        
-        :param input_data: Input data
-        :type input_data: List[str]
-        :param input_params: Input parameters
-        :type input_params: Dict[str, Any]
-        :rtype: List[Dict]
-        """
-
-        self._check_file_paths(input_data)
-
-        qcshema_objects = []
-        for file in input_data:
-            file_path = Path(file)
-            
-            file_data = file_path.read_text()
-            if file_path.suffix == '.xyz':
-                mol = self._xyz_to_qcschema_mol(file_data)
-                new_qcschema = self._new_qcshema( input_params, mol )
-                qcshema_objects.append(new_qcschema)
-            elif file_path.suffix == '.json':
-                if input_params is not None and len(input_params.keys()) > 0:
-                    warnings.warn('Input parameters were given along with a QcSchema file which contains parameters, using QcSchema parameters as is.')
-                with open(file_path, 'r') as f:
-                    qcshema_objects.append( json.load(f) )
-            else:
-                raise ValueError(f"File type '{file_path.suffix}' for file '{file_path}' is not supported.")
-
-        return qcshema_objects
-
-    @classmethod
-    def _check_file_paths( self, input_data: List[str]):
-        """Check the file types and make sure they are supported by our parsers."""
-
-        warn_task_count = 1000
-        if len(input_data) >= warn_task_count:
-            warnings.warn(f'Number of tasks is greater than {warn_task_count}.')
-
-        supported_ext = ['.xyz', '.json']
-        prev_ext = None
-        for path_str in input_data:
-            path = Path(path_str)
-
-            if not path.exists():
-                raise FileNotFoundError(f"File {path_str} does not exist.")
-
-            if path.suffix not in supported_ext:
-                raise ValueError(f"'{path.suffix}' file type is not supported. Please use one of {supported_ext}.")
-            
-            if prev_ext is not None and prev_ext !=  path.suffix:
-                raise ValueError(f"Multiple file types were provided ('{path.suffix}', '{prev_ext}'). Please submit only one file type.")
-            else:
-                prev_ext = path.suffix
-            
-
-    @classmethod
-    def _new_qcshema( self, input_params: Dict[str,Any], mol: Dict[str,Any],  ) -> Dict[str, Any]:
-        """
-        Create a new default qcshema object.
-        """
-
-        self._sanity_check_params(input_params, mol)
-
-        if input_params.get("driver").lower() == "go":
-            copy_input_params = copy.deepcopy(input_params)
-            copy_input_params["driver"] = "gradient"
-            new_object = {
-                "schema_name": "qcschema_optimization_input",
-                "schema_version": 1,
-                "initial_molecule": mol,
-            }
-            if copy_input_params.get("go_keywords"):
-                new_object["keywords"] = copy_input_params.pop("go_keywords")
-            new_object["input_specification"] = copy_input_params
-            return new_object
-        elif input_params.get("driver").lower() == "bomd":
-            copy_input_params = copy.deepcopy(input_params)
-            copy_input_params["driver"] = "gradient"
-            new_object = {
-                "schema_name": "madft_molecular_dynamics_input",
-                "schema_version": 1,
-                "initial_molecule": mol,
-            }
-            if copy_input_params.get("bomd_keywords"):
-                new_object["keywords"] = copy_input_params.pop("bomd_keywords")
-            new_object["input_specification"] = copy_input_params
-            return new_object
-        else:
-            new_object = copy.deepcopy(input_params)
-            new_object.update({
-                "schema_name": "qcschema_input",
-                "schema_version": 1,
-                "molecule": mol,
-            })
-            return new_object
-    
-    @classmethod
-    def _sanity_check_params(self, input_params, mol):
-
-        # QM/MM is not supported for GO, BOMD and Hessian.
-        driver = input_params.get("driver",'').lower()
-        if driver in ["go", "bomd", "hessian"]:
-            if "extras" in mol and "mm_charges" in mol["extras"]:
-                raise ValueError(f"'{driver}' does not support QM/MM.")
-
-        # Top level params
-        self._check_dict_for_required_keys(input_params, 'input_params', ['driver', 'model'])
-        
-        # Check Model params
-        self._check_dict_for_required_keys(input_params['model'], 'input_params["model"]', ['method', 'basis'])
-
-    
-    @classmethod
-    def _check_dict_for_required_keys(self, input_params: dict, dict_name: str, required_keys: list[str]):
-        """Check dictionary for required keys and if it doesn't have then raise ValueError."""
-
-        for required_key in required_keys:
-            if required_key not in input_params.keys():
-                raise ValueError(f"Required key ({required_key}) was not provided in {dict_name}.")
-
-    @classmethod
-    def _xyz_to_qcschema_mol(self, file_data: str ) -> Dict[str, Any]:
-        """
-        Convert xyz format to qcschema molecule.
-        """
-
-        lines = file_data.split("\n")
-        if len(lines) < 3 or not lines[0]:
-            raise ValueError("Invalid xyz format.")
-        n_atoms = int(lines.pop(0))
-        comment = lines.pop(0)
-        mol = defaultdict(list)
-        mol['extras'] = defaultdict(list)
-        bohr_to_angstrom = 0.52917721092
-        for line in lines:
-            if line:
-                elements = line.split()
-                if len(elements) == 4:
-                    symbol, x, y, z = elements
-                    mol["symbols"].append(symbol)
-                    mol["geometry"] += [float(x)/bohr_to_angstrom, float(y)/bohr_to_angstrom, float(z)/bohr_to_angstrom]
-                elif len(elements) == 5:
-                    symbol, x, y, z, q = elements
-                    if symbol[0] != '-':
-                        raise ValueError("Invalid xyz format. Molecular Mechanics atoms requires '-' at the beginning of the atom type.")
-                    mol["extras"]["mm_symbols"].append(symbol.replace('-', ''))
-                    mol["extras"]["mm_geometry"] += [float(x)/bohr_to_angstrom, float(y)/bohr_to_angstrom, float(z)/bohr_to_angstrom]
-                    mol["extras"]["mm_charges"].append(float(q))
-                else:
-                    raise ValueError("Invalid xyz format.")
-            else:
-                break
-
-        # Convert defaultdict to dict
-        mol = dict(mol)
-        mol["extras"] = dict(mol["extras"])
-        
-        if len(mol["symbols"])+len(mol["extras"].get("mm_symbols",[])) != n_atoms:
-            raise ValueError("Number of inputs does not match the number of atoms in xyz file.")
-
-        return mol
-
-    @classmethod
-    def _get_job_class(cls) -> Type[Job]:
-        return MicrosoftElementsDftJob
-
-    @classmethod
-    def _create_table_of_contents(cls, input_files: List[str], input_blobs: List[str]) -> Dict[str,Any]:
-        """Create the table of contents for a batched job that contains a description of file and the mapping between the file names and the blob names"""
-
-        assert len(input_files) == len(input_blobs), "Internal error: number of blobs is not that same as the number of files."
-
-        toc = []
-        for i in range(len(input_files)):
-            toc.append( 
-                {
-                    "inputFileName": input_files[i],
-                    "qcschemaBlobName": input_blobs[i],
-                }
-            )
-
-        return {
-            "description": "This files contains the mapping between the xyz file name that were submitted and the qcschema blobs that are used for the calculation.",
-            "tableOfContents": toc,
-        }