azure-quantum 3.2.0__py3-none-any.whl → 3.3.0__py3-none-any.whl

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.2.0"
+VERSION = "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/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/version.py

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

{azure_quantum-3.2.0.dist-info → azure_quantum-3.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-quantum
-Version: 3.2.0
+Version: 3.3.0
 Summary: Python client for Azure Quantum
 Home-page: https://github.com/microsoft/azure-quantum-python
 Author: Microsoft

{azure_quantum-3.2.0.dist-info → azure_quantum-3.3.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ azure/quantum/__init__.py,sha256=Za8xZY4lzFkW8m4ero-bqrfN437D2NRukM77ukb4GPM,508
 azure/quantum/_constants.py,sha256=nDL_QrGdI_Zz_cvTB9nVgfE7J6A_Boo1ollMYqsiEBs,3499
 azure/quantum/_workspace_connection_params.py,sha256=KoT90U89Dj6pVwAKp_ENJL1hyTF0oQe7w0QioOGvjXg,21685
 azure/quantum/storage.py,sha256=_4bMniDk9LrB_K5CQwuCivJFZXdmhRvU2b6Z3xxXw9I,12556
-azure/quantum/version.py,sha256=laSNPiS2SGFzmsJOnaidlYYIirf4V5VcA6YB3hl3OtM,235
+azure/quantum/version.py,sha256=yFZaZzIK6r33ln03-vVtefApA1zWBz3pvQF1jin-hgk,235
 azure/quantum/workspace.py,sha256=9oO4vjwIn1pdHFLZCQcEPQ_xjQjTNO4UIWSBQpj6Cgo,35574
 azure/quantum/_authentication/__init__.py,sha256=bniNZlS0hMIjO_y7DevGBAS6MixyA5pbPHcdGipUWM4,236
 azure/quantum/_authentication/_chained.py,sha256=0rdohB_fVGFHUhlly9sGxqQTBTZGpGxtlBqNHDFbAqE,4848
@@ -14,7 +14,7 @@ azure/quantum/_client/_configuration.py,sha256=FFUHJPp6X0015GpD-YLmYCoq8GI86nHCn
 azure/quantum/_client/_model_base.py,sha256=hu7OdRS2Ra1igfBo-R3zS3dzO3YhFC4FGHJ_WiyZgNg,43736
 azure/quantum/_client/_patch.py,sha256=YTV6yZ9bRfBBaw2z7v4MdzR-zeHkdtKkGb4SU8C25mE,694
 azure/quantum/_client/_serialization.py,sha256=bBl0y0mh-0sDd-Z8_dj921jQQhqhYWTOl59qSLuk01M,86686
-azure/quantum/_client/_version.py,sha256=RskRm0SPBVlwu8AISISisDC4SuWtXmNNap7puHbpbWQ,495
+azure/quantum/_client/_version.py,sha256=lVYNMqxgvpsfmcBW1y_FXP__aNVaVme9UgQv-jHbWdM,495
 azure/quantum/_client/py.typed,sha256=dcrsqJrcYfTX-ckLFJMTaj6mD8aDe2u0tkQG-ZYxnEg,26
 azure/quantum/_client/models/__init__.py,sha256=MR2av7s_tCP66hicN9JXCmTngJ4_-ozM4cmblGjPwn8,1971
 azure/quantum/_client/models/_enums.py,sha256=RNCPXxeae4d7wtPqcSxu5JZBLFLZZYVZbALjui_f1fM,4288
@@ -35,7 +35,7 @@ azure/quantum/cirq/targets/target.py,sha256=1EEog72dFZoiOTQP7obOrCuO3VH0yjXGAIMe
 azure/quantum/job/__init__.py,sha256=nFuOsG25a8WzYFLwA2fhA0JMNWtblfDjV5WRgB6UQbw,829
 azure/quantum/job/base_job.py,sha256=GDwoJDxoaCwGz9TBuzlkuqXdU84L6FliO_2YWxnLnrE,14399
 azure/quantum/job/filtered_job.py,sha256=qZfxTuDp0hzK4wermn4GRzLxnDy4yM-j6oZQ3D0O4vI,1877
-azure/quantum/job/job.py,sha256=D6MMOUEvx_qLdyr7vU1t62MUNMapOnFgcMBYCt7-TXM,17721
+azure/quantum/job/job.py,sha256=uMn0ET7DX9EUwN8xerZzm8MflbvbU1NOGM1uCvh8c-g,17607
 azure/quantum/job/job_failed_with_results_error.py,sha256=bSqOZ0c6FNbS9opvwkCXG9mfTkAiyZRvp_YA3V-ktEs,1597
 azure/quantum/job/session.py,sha256=EEJVKEEB5g0yyH963aaR0GY0Cd0axrX-49gwDWxBcfE,11961
 azure/quantum/job/workspace_item.py,sha256=lyBIJCtUfIZMGJYJkX7Se8IDnXhXe4JU0RnqzSuhhI4,1380
@@ -49,23 +49,19 @@ azure/quantum/qiskit/backends/ionq.py,sha256=exXdWL63CxlIIiK4bfSFpJCKXzJgjLKz5OL
 azure/quantum/qiskit/backends/qci.py,sha256=c0YK-znG8TSAnFmeszo7mpKhM624QHszTQoapOqOvHg,4794
 azure/quantum/qiskit/backends/quantinuum.py,sha256=1ThH4mmk4CUG-2RTvwsFEXQ3TEvHPJnW7Lo6QYpC3QE,12705
 azure/quantum/qiskit/backends/rigetti.py,sha256=lTsa0UjPdsAZUvvfnBge7H22TvA7c-_3fU09ZTA4ARs,4146
-azure/quantum/target/__init__.py,sha256=F0nIEJdlbczmxAdtvPDWf8J1Y33_XjPzloliHeWpJos,689
+azure/quantum/target/__init__.py,sha256=hK4OqAOkgwO8W52YvPp6QeoMTFj_eum3iexMmpCMEsI,606
 azure/quantum/target/ionq.py,sha256=2iS4H-fBJYRTCM7VJse3Hqya_y2iEuU5QBG3Oj4c-SU,3931
 azure/quantum/target/params.py,sha256=Txpq_AKdVV8OeZjK1z48CIym--_a6wncorj4LmmlQ_E,9128
 azure/quantum/target/quantinuum.py,sha256=5xvYb0Q2KSQr6FJ_A1bc2904Gz6NF_Xmn8UJ79NMOZU,3306
 azure/quantum/target/target.py,sha256=jmB4mU32rQIViJ_Zq5qYh-ktLr9vv_vz-sKpvR8GY-M,16658
 azure/quantum/target/target_factory.py,sha256=jjZ9zxWaNDkcvslKV02GSP8rtXwStJ7EmVXQSOFh_j8,5266
-azure/quantum/target/microsoft/elements/__init__.py,sha256=gVVpaN5086iuBnajtvTjSd7MLExtnsR6RDCmcgz6xpE,70
-azure/quantum/target/microsoft/elements/dft/__init__.py,sha256=kCXOA9HT-gb23An-A0eyktlB66VoH6EwNO4gPM97l3U,224
-azure/quantum/target/microsoft/elements/dft/job.py,sha256=6v7lZwXyUGrOI8J17akanMrFXrPVDhsZR3c6AFpa5So,6942
-azure/quantum/target/microsoft/elements/dft/target.py,sha256=10el-q7QO3k19sytnoBfRaMzd5H2RvGHqm4N5IZfcjQ,12826
 azure/quantum/target/pasqal/__init__.py,sha256=qbe6oWTQTsnTYwY3xZr32z4AWaYIchx71bYlqC2rQqw,348
 azure/quantum/target/pasqal/result.py,sha256=SUvpnrtgvCGiepmNpyifW8b4p14-SZZ1ToCC0NAdIwg,1463
 azure/quantum/target/pasqal/target.py,sha256=K_vqavov6gvS84voRKeBx9pO8g4LrtWrlZ5-RMLWozw,5139
 azure/quantum/target/rigetti/__init__.py,sha256=I1vyzZBYGI540pauTqJd0RSSyTShGqkEL7Yjo25_RNY,378
 azure/quantum/target/rigetti/result.py,sha256=65mtAZxfdNrTWNjWPqgfwt2BZN6Nllo4g_bls7-Nm68,2334
 azure/quantum/target/rigetti/target.py,sha256=HFrng9SigibPn_2KWhD5qWHiP_RNz3CNRkv288tf-z8,7586
-azure_quantum-3.2.0.dist-info/METADATA,sha256=5jB1UwikXFbSEJznlYHLeyKVHNTPDtSI_1nKGRguDcc,7359
-azure_quantum-3.2.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-azure_quantum-3.2.0.dist-info/top_level.txt,sha256=S7DhWV9m80TBzAhOFjxDUiNbKszzoThbnrSz5MpbHSQ,6
-azure_quantum-3.2.0.dist-info/RECORD,,
+azure_quantum-3.3.0.dist-info/METADATA,sha256=GrqD7EGCoJapqc_YNzvK_Ng8_37VeRXD_i59TBZM2v4,7359
+azure_quantum-3.3.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+azure_quantum-3.3.0.dist-info/top_level.txt,sha256=S7DhWV9m80TBzAhOFjxDUiNbKszzoThbnrSz5MpbHSQ,6
+azure_quantum-3.3.0.dist-info/RECORD,,

azure/quantum/target/microsoft/elements/__init__.py

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

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/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/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,
-        }