azure-quantum 1.1.1.dev0__py3-none-any.whl → 1.1.2.dev0__py3-none-any.whl

{azure_quantum-1.1.1.dev0.dist-info → azure_quantum-1.1.2.dev0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 azure/quantum/__init__.py,sha256=Za8xZY4lzFkW8m4ero-bqrfN437D2NRukM77ukb4GPM,508
-azure/quantum/_constants.py,sha256=MU8ESmdzF_X1IE8X56eYYr5-Giab0-7PIZk5SwbkP_I,3162
-azure/quantum/_workspace_connection_params.py,sha256=YeKmNinB-mNV3QngDR2woNX8cXnv5pt9wo-JwbpRBlQ,21520
+azure/quantum/_constants.py,sha256=6FCBpjUK2GHeycKejgGYTvxtlSsfWdbG2iOXGQg8NaM,3219
+azure/quantum/_workspace_connection_params.py,sha256=fGha3ALz1YRnKo07xHCbDzDcmUS7rsaakGvx_pvVINo,21632
 azure/quantum/storage.py,sha256=_4bMniDk9LrB_K5CQwuCivJFZXdmhRvU2b6Z3xxXw9I,12556
-azure/quantum/version.py,sha256=SnHlUvsqoBQmwVz8O22mBl1LIvGv0Ue9OU2tNhDt39U,240
-azure/quantum/workspace.py,sha256=FrpcXcOc0L2RooGipEzCjACScPb_WqRV5hmIBtl0i7M,17600
+azure/quantum/version.py,sha256=-vAeAqsgIjIU8KmFftm1j4jiGOI7BOHvbIG4ovYqcv4,240
+azure/quantum/workspace.py,sha256=QXnIHOOYEGixajbZ8oeEWu-fAUI_Fms4zkA_amurm3g,17607
 azure/quantum/_authentication/__init__.py,sha256=bniNZlS0hMIjO_y7DevGBAS6MixyA5pbPHcdGipUWM4,236
 azure/quantum/_authentication/_chained.py,sha256=0rdohB_fVGFHUhlly9sGxqQTBTZGpGxtlBqNHDFbAqE,4848
-azure/quantum/_authentication/_default.py,sha256=djDGa_7z_P0SW7XXWuK0w305HwpVWyRY_KNIyoUMAh0,6625
+azure/quantum/_authentication/_default.py,sha256=RzhK5UNQb6TK95VQI4o8Gm2nxtOaz64yA0J9Tw9zpW4,6625
 azure/quantum/_authentication/_token.py,sha256=mOrvibDiOgkDnqU1OBIw9PyIv-np6DkdxMNC4UtuGkc,3616
 azure/quantum/_client/__init__.py,sha256=kzaVxPfnju-Y_EGMfOVYVB7pHjPvc-IWrkFI2eNk68s,896
 azure/quantum/_client/_client.py,sha256=ZG-zalnITLyBk3BSMjLt4PtnNv8Nky5-kcmnIrk1IkQ,7143
@@ -14,7 +14,7 @@ azure/quantum/_client/_configuration.py,sha256=5uktKtZxoVVAoSyeL0VNGS9AfPERp-9rU
 azure/quantum/_client/_patch.py,sha256=YTV6yZ9bRfBBaw2z7v4MdzR-zeHkdtKkGb4SU8C25mE,694
 azure/quantum/_client/_serialization.py,sha256=KJSS6KWgnKcz-cENQCmWZ9Ziv303lnBbLwFIpYZeKFU,81097
 azure/quantum/_client/_vendor.py,sha256=h8ByiyZ4cCQyFxqnuhTQdv1Rms3dVjKsrgZDzwMcSJ0,996
-azure/quantum/_client/_version.py,sha256=xcDDuL0FYpiNdGfo1HmEdsont0bkC3sM_2MXFuLjt20,500
+azure/quantum/_client/_version.py,sha256=1BvMPpsGTc8vSsVvDoi2TMiSVPtozGm87WOCYKmau7Q,500
 azure/quantum/_client/models/__init__.py,sha256=c1PRpzNsQTcDk4GkrFMMIlwNQQa2c0p5N0Lzd-23YBA,2100
 azure/quantum/_client/models/_enums.py,sha256=omj_B8_E8ONzTHg5hLgDlFYibRRbdr9sEN298im_otA,2977
 azure/quantum/_client/models/_models.py,sha256=wktCM5oBVfwQetNoHobL1wNsC3knXV-HmqBq_Q77Kw4,41810
@@ -33,24 +33,16 @@ azure/quantum/cirq/targets/ionq.py,sha256=xCabcYklH9wW1TFBzpMdxvipzqhKWCYbtcgNqD
 azure/quantum/cirq/targets/quantinuum.py,sha256=t7L5prczDQJlzStth6Rh6r35DX1Z8J_my-VJxLBp2n4,4537
 azure/quantum/cirq/targets/target.py,sha256=1EEog72dFZoiOTQP7obOrCuO3VH0yjXGAIMeO6bm22o,2184
 azure/quantum/job/__init__.py,sha256=bRfMuK8aAQGwggoXF4bwymwBjBumBrQFqw0LjvSMWhI,762
-azure/quantum/job/base_job.py,sha256=x3jXMEhhR7OKPRvlr9zvaQQvx8nKlKG-iRv4YgEDXbU,12886
+azure/quantum/job/base_job.py,sha256=NovuhFFH4HCpXRDn2EwlWAxcpY8Kenu58RwbddIbtdA,12882
 azure/quantum/job/filtered_job.py,sha256=qZfxTuDp0hzK4wermn4GRzLxnDy4yM-j6oZQ3D0O4vI,1877
-azure/quantum/job/job.py,sha256=NuXflIFShjbOQ66IqusrFIB-wGLeQgqFjDmqnmhobh0,6131
+azure/quantum/job/job.py,sha256=V69KjIw6QvxlDgnU3xOmfMU2SdU3AwGrqeRd4olvUM4,6151
 azure/quantum/job/job_failed_with_results_error.py,sha256=4NZVUPnCnnJsSmNg9VkIjcRChK118jkCfKlVBlHNE24,1279
 azure/quantum/job/session.py,sha256=EEJVKEEB5g0yyH963aaR0GY0Cd0axrX-49gwDWxBcfE,11961
 azure/quantum/job/workspace_item.py,sha256=lyBIJCtUfIZMGJYJkX7Se8IDnXhXe4JU0RnqzSuhhI4,1380
 azure/quantum/job/workspace_item_factory.py,sha256=QRWyrtgcKZqUucJOFi9V_SYMV3lj6S74tGRrPtk3NE0,1200
-azure/quantum/optimization/__init__.py,sha256=EQbilP4U-XfED1QCBOx8Nz2xapcpHx_CA5o0ZkiXyMg,276
-azure/quantum/optimization/online_problem.py,sha256=6XMnl-5U17CSYsWaplEcuMIBpMzS-QyrcWPxq0Vmt3w,636
-azure/quantum/optimization/problem.py,sha256=UpuMXfk4SRqmfCh68baVSUlEP_ZxtRET-DwPniBbOD8,13570
-azure/quantum/optimization/solvers.py,sha256=m6O_n8-GJbnk_waO4vtZLiQskpGRGjy0BiyVHi6A9-M,319
-azure/quantum/optimization/streaming_problem.py,sha256=tTvw-SRx90Z2XzmOYvxP42X4LGMy5ZecBzni_lwpCEY,13650
-azure/quantum/optimization/term.py,sha256=5OP_XeGN4SjozesvpW9QV7g3pc2xEOINN5uiAW59UWo,5983
-azure/quantum/optimization/toshiba/__init__.py,sha256=wdtNlaOhnN10P631WZvYFIvfUXjpGthNGxNQQAKxhmc,302
-azure/quantum/optimization/toshiba/solvers.py,sha256=s3DceUtsMh1L6AycfFM9fa-eOEiE7tM5hIV3noYbV8U,374
 azure/quantum/qiskit/__init__.py,sha256=7Ok1mrUf-fsVuOJjVBx7OGzXJ7oHAI1Zqm8R2wdjMgE,273
 azure/quantum/qiskit/job.py,sha256=PHgEIY7dOQtpfo-J--frj-PVX3OWr8llfBUv9VClLNg,14370
-azure/quantum/qiskit/provider.py,sha256=qudlCY7uIW-NK_N7mzzt3tfbFsIjhs-2NBaC4XRuK_U,10871
+azure/quantum/qiskit/provider.py,sha256=R9Zx6nSrx8U3iKy0ALoUy01I0pdCKSBvOhomQstFdRo,10789
 azure/quantum/qiskit/backends/__init__.py,sha256=ULX3zXu9eTUX0Tyo-vXp3QMlCbxaV2bHvepRaAM_KBo,1082
 azure/quantum/qiskit/backends/backend.py,sha256=9Rqkac8PN7fwNM2K8zXuoM9UQeM6Xi3ua0KHpoANZHI,20409
 azure/quantum/qiskit/backends/ionq.py,sha256=rxAhWvXrAMuFbdg72qDy_MKIx8EuCV7BvKCgwQwpogY,18024
@@ -60,30 +52,27 @@ azure/quantum/qiskit/backends/quantinuum.py,sha256=6lm4yWv-3724PBaB9dnJfdeOvlGro
 azure/quantum/qiskit/backends/rigetti.py,sha256=QeV_kQveHk9uUZUZLR0CiHhrcVY8twJWLb2Wh1h5Lrk,4248
 azure/quantum/qiskit/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 azure/quantum/qiskit/results/resource_estimator.py,sha256=pAP5ZpVxdzNekQ_qXfSdSKYWWuqL_Vq7WK6pWU4wbEQ,814
-azure/quantum/target/__init__.py,sha256=vM6R1IeT_PmhfZmh9DRN4f-b72wBeFzIEWB_L5GzJdw,802
+azure/quantum/target/__init__.py,sha256=F0nIEJdlbczmxAdtvPDWf8J1Y33_XjPzloliHeWpJos,689
 azure/quantum/target/ionq.py,sha256=f6V_Ce09RHU56NmCdwcupDDjSxA3kDVodjwEBvpWrvg,8130
 azure/quantum/target/params.py,sha256=oI-35HUEMCskNjpxCJU3tjL664K-TxqAg5LA5xU0nso,9130
 azure/quantum/target/quantinuum.py,sha256=2VWng9h-OA7v9GeSsmMFWHVqBITqPrFjQcD5fH8ANHU,7710
-azure/quantum/target/solvers.py,sha256=_Uhz9k7CNJk6cR6fsRrWp_ZhlpEerc3le16j75yg6Pg,14963
 azure/quantum/target/target.py,sha256=X8FLG1sfcdul6tH58XtxQuvRm3B3OjYiI7opPxMfb1M,13850
-azure/quantum/target/target_factory.py,sha256=LYV8Smsnw0won9PdnTlq-rFpdRiszGriV54GQ6hcl8M,5247
+azure/quantum/target/target_factory.py,sha256=5nYFo_PLvnDrsILMd4zzprnjQSJCj2P-as5Z-J8_tnk,5053
 azure/quantum/target/microsoft/__init__.py,sha256=36kM2YlWv69AzAfUA5wMdWyYRSaCMwX2Ajhffpzx67g,570
 azure/quantum/target/microsoft/job.py,sha256=GM4OA-rxFUqQzsH8V59pVc4BmBaPYvd99E26pyPwxto,1249
 azure/quantum/target/microsoft/result.py,sha256=AntJptXKHNRdRR6oxhTlKKPOJVSU7u9fIfH2GXJqfx0,18784
 azure/quantum/target/microsoft/target.py,sha256=D7KS3AH-sjD1MVXL-J0SG61aGdWlrTZNT9JicjJzWeE,17879
 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=RlvBef1M0lAbcnXX_cCWG7tQMwKdCxlVopBNgGYFaI0,2856
+azure/quantum/target/microsoft/elements/dft/job.py,sha256=0CPe4Xf1iniEBt4--4PsbHUE5NZraP5tMk1H96sZzyM,2854
 azure/quantum/target/microsoft/elements/dft/target.py,sha256=IeFDVh3SqDsQOZmd9UKhl1Qu0ChkOEIHHb5fC5x4YGE,2556
 azure/quantum/target/pasqal/__init__.py,sha256=qbe6oWTQTsnTYwY3xZr32z4AWaYIchx71bYlqC2rQqw,348
 azure/quantum/target/pasqal/result.py,sha256=4hs1SP02bKA73bX2CEKdOyTufLp7Fx6W7K-sCmdUKrc,1458
 azure/quantum/target/pasqal/target.py,sha256=j9xK9chbmo-FL4Y9HBVqtL14Rr6lxQK6UN-lMMo6hME,3966
 azure/quantum/target/rigetti/__init__.py,sha256=I1vyzZBYGI540pauTqJd0RSSyTShGqkEL7Yjo25_RNY,378
 azure/quantum/target/rigetti/result.py,sha256=yDtT1y-JZFU7_mCaN1V_E6LPjJVD2vn4jvHOPT0IP9k,2278
-azure/quantum/target/rigetti/target.py,sha256=jSqliOyXi5g02EnB1WvxmdTxpS5OuanoHzWIgrl3HsU,6626
-azure/quantum/target/toshiba/__init__.py,sha256=XOGavxw_ekyTealmx5EPYzlYIdVlUnlbsIXPZVSMU-g,146
-azure/quantum/target/toshiba/solvers.py,sha256=-lao-2r_fzMxmxNjdH-hzWC3bfVuGtPkdj5k-kp5bwI,5722
-azure_quantum-1.1.1.dev0.dist-info/METADATA,sha256=8SM--PJLTeI2c5Fko0UcCTwfLG4Y9x8wN3ZqHMkp0YM,7348
-azure_quantum-1.1.1.dev0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-azure_quantum-1.1.1.dev0.dist-info/top_level.txt,sha256=S7DhWV9m80TBzAhOFjxDUiNbKszzoThbnrSz5MpbHSQ,6
-azure_quantum-1.1.1.dev0.dist-info/RECORD,,
+azure/quantum/target/rigetti/target.py,sha256=hGZm1wkBb1CBtDBWXEFS2Nje6gRXBTjOYgFkjOJ7TZ8,6458
+azure_quantum-1.1.2.dev0.dist-info/METADATA,sha256=Zorh_0O9e8Wlm5o9DWOxLThwb2Evn68rVPmzrct02MU,7309
+azure_quantum-1.1.2.dev0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+azure_quantum-1.1.2.dev0.dist-info/top_level.txt,sha256=S7DhWV9m80TBzAhOFjxDUiNbKszzoThbnrSz5MpbHSQ,6
+azure_quantum-1.1.2.dev0.dist-info/RECORD,,

azure/quantum/optimization/__init__.py

@@ -1,11 +0,0 @@
-# coding=utf-8
-##
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-##
-
-from .term import *
-from .problem import *
-from .streaming_problem import *
-from .online_problem import *
-from azure.quantum.target.solvers import *

azure/quantum/optimization/online_problem.py

@@ -1,21 +0,0 @@
-import logging
-from typing import TYPE_CHECKING
-from azure.quantum.optimization import Problem
-
-logger = logging.getLogger(__name__)
-
-__all__ = ["OnlineProblem"]
-
-if TYPE_CHECKING:
-    from azure.quantum.workspace import Workspace
-
-
-class OnlineProblem(object):
-    def __init__(self, name: str, blob_uri: str, **kw):
-        super(OnlineProblem, self).__init__(**kw)
-        self.name = name
-        self.uploaded_blob_uri = blob_uri
-
-    def download(self, workspace: "Workspace") -> Problem:
-        logger.warning("The problem will be downloaded to the client")
-        return Problem.download(self, workspace)

azure/quantum/optimization/problem.py

@@ -1,393 +0,0 @@
-##
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-##
-
-from __future__ import annotations
-import logging
-import io
-import gzip
-import json
-import numpy
-import os
-import tarfile
-
-
-from typing import List, Tuple, Union, Dict, Optional, TYPE_CHECKING
-from enum import Enum
-from azure.quantum.optimization import TermBase, Term
-from azure.quantum.storage import (
-    ContainerClient,
-    download_blob,
-    BlobClient,
-    download_blob_metadata,
-    download_blob_properties
-)
-from azure.quantum.job.base_job import ContentType
-from azure.quantum.job.job import Job
-from azure.quantum.target.target import Target
-
-logger = logging.getLogger(__name__)
-
-__all__ = ["Problem", "ProblemType"]
-
-if TYPE_CHECKING:
-    from azure.quantum.workspace import Workspace
-
-class ProblemType(str, Enum):
-    pubo = 0
-    ising = 1
-
-
-class Problem:
-    """Problem to submit to the service.
-
-    :param name: Problem name
-    :type name: str
-        When passing None, it will default to "Optimization problem"
-    :param terms: Problem terms, depending on solver.
-        Defaults to None
-    :type terms: Optional[List[TermBase]], optional
-    :param init_config: Optional configuration details, depending on solver.
-        Defaults to None
-    :type init_config: Optional[Dict[str,int]], optional
-    :param problem_type: Problem type (ProblemType.pubo or
-        ProblemType.ising), defaults to ProblemType.ising
-    :type problem_type: ProblemType, optional
-    :param content_type: Content type, eg: application/json. Default is application/json
-    :type content_type: ContentType, optional
-    """
-
-    def __init__(
-        self,
-        name: str,
-        terms: Optional[List[TermBase]] = None,
-        init_config: Optional[Dict[str, int]] = None,
-        problem_type: ProblemType = ProblemType.ising,
-        content_type: Optional[ContentType] = ContentType.json 
-    ):
-        self.name = name or "Optimization problem"
-        self.problem_type = problem_type
-        self.init_config = init_config
-        self.uploaded_blob_uri = None
-        self.uploaded_blob_params = None
-        self.content_type = content_type
-
-        # each type of term has its own section for quicker serialization
-        self.terms = []
-
-        # set the terms
-        if terms:
-            for term in terms:
-                self.terms.append(term)
-
-    """
-    Constant thresholds used to determine if a problem is "large".
-    """
-    NUM_VARIABLES_LARGE = 2500
-    NUM_TERMS_LARGE = 1e6
-
-
-    def serialize(self) -> Union[str, list]:
-        """Wrapper function for serializing to json
-        """ 
-        return self.to_json()
-
-    def to_json(self) -> str:
-        """Serializes the problem to a JSON string"""
-        result = {
-            "metadata": {
-                "name": self.name,
-            },
-            "cost_function": {
-                "version": "1.1" if self.init_config else "1.0",
-                "type": self.problem_type.name,
-                "terms": [term.to_dict() for term in self.terms]
-            }
-        }
-
-        if self.init_config:
-            result["cost_function"]["initial_configuration"] = self.init_config
-
-        return json.dumps(result)
-
-    
-    @classmethod
-    def from_json(
-            cls, 
-            input_problem: str, 
-            name: Optional[str] = None
-        ) -> Problem:
-        """Deserializes the problem from a
-        json serialized with Problem.serialize()
-
-        :param input_problem:
-            the json string to be deserialized to a `Problem` instance
-        :type problem_msgs: str
-        :param
-        :param name: 
-            The name of the problem is optional, since it will try 
-            to read the serialized name from the json payload.
-            If this parameter is not empty, it will use it as the
-            problem name ignoring the serialized value.
-        :type name: Optional[str]
-        """
-        result = json.loads(input_problem)
-
-        if name is None:
-            metadata = result.get("metadata")
-            if metadata is not None:
-                name = metadata.get("name")
-
-        terms = [Term.from_dict(t) for t in result["cost_function"]["terms"]] if "terms" in result["cost_function"] else []
-
-        problem = cls(
-            name=name,
-            terms=terms,
-            problem_type=ProblemType[result["cost_function"]["type"]],
-        )
-
-        if "initial_configuration" in result["cost_function"]:
-            problem.init_config = result["cost_function"]["initial_configuration"]
-
-        return problem
-
-    @classmethod
-    def deserialize(
-        cls, 
-        input_problem: Union[str, list],
-        name: Optional[str] = None, 
-        content_type: Optional[ContentType] = None) -> Problem:
-        """Deserializes the problem from a
-        JSON string serialized with Problem.serialize()
-        Also used to deserialize the messages downloaded from the blob
-
-        :param input_problem:
-            The json string
-        :type input_problem: Union[str,list]
-        :param
-        :param name: 
-            The name of the problem is optional, since it will try 
-            to read the serialized name from the json payload.
-            If this parameter is not empty, it will use it as the
-            problem name ignoring the serialized value.
-        :type name: Optional[str]
-        :param content_type: The content type of the input problem data
-        :type: Optional, ContentType
-        """
-        return cls.from_json(input_problem, name)
-
-    def add_term(self, c: Union[int, float], indices: List[int]):
-        """Adds a single monomial term to the `Problem` representation
-
-        :param c: The cost or weight of this term
-        :type c: int, float
-        :param indices: The variable indices that are in this term
-        :type indices: List[int]
-        """
-        self.terms.append(Term(indices=indices, c=c))
-        self.uploaded_blob_uri = None
-
-    def add_terms(
-        self, 
-        terms: List[Term]
-    ):
-        """Adds a list of monomial terms to the `Problem` representation
-
-        :param terms: The list of terms to add to the problem
-        """
-        self.terms += terms
-        self.uploaded_blob_uri = None
-    
-            
-    def to_blob(self) -> bytes:
-        """Convert problem data to a binary blob.
-
-        :return: Blob data
-        :rtype: bytes
-        """
-        input_problem = self.serialize()
-        debug_input_string = input_problem if type(input_problem) is str else b''.join( input_problem).decode('latin-1')
-        logger.debug("Input Problem: " + debug_input_string)
-        data = io.BytesIO()
-        with gzip.GzipFile(fileobj=data, mode="w") as fo:
-            fo.write(input_problem.encode())
-
-        return data.getvalue()
-    
-    def _blob_name(self):
-        import uuid
-        return "{}-{}".format(self.name, uuid.uuid1())
-
-    def upload(
-        self,
-        workspace: "Workspace",
-        container_name: str = "optimization-problems",
-        blob_name: str = "inputData",
-        container_uri: str = None,
-    ):
-        """Uploads an optimization problem instance to
-        the cloud storage linked with the Workspace.
-
-        :param workspace: interaction terms of the problem.
-        :type workspace: Workspace
-        :param container_name: Container name, defaults to "optimization-problems"
-        :type container_name: str, optional
-        :param blob_name: Blob name, defaults to None
-        :type blob_name: str, optional
-        :param container_uri: Optional container URI
-        :type container_uri: str
-        :return: uri of the uploaded problem
-        :rtype: str
-        """
-        blob_params = [workspace, container_name, blob_name]
-        if self.uploaded_blob_uri and self.uploaded_blob_params == blob_params:
-            return self.uploaded_blob_uri
-
-        if blob_name is None:
-            blob_name = self._blob_name()
-
-        encoding = "gzip"
-        content_type = self.content_type
-
-        blob = self.to_blob()
-        if container_uri is None:
-            container_uri = workspace.get_container_uri(
-                container_name=container_name
-            )
-        input_data_uri = Job.upload_input_data(
-            input_data=blob,
-            blob_name=blob_name,
-            container_uri=container_uri,
-            encoding=encoding,
-            content_type= content_type
-        )
-        self.uploaded_blob_params = blob_params
-        self.uploaded_blob_uri = input_data_uri
-        return input_data_uri
-
-    def set_fixed_variables(
-        self, fixed_variables: Union[Dict[int, int], Dict[str, int]]
-    ) -> Problem:
-        """Transforms the current problem with a set of fixed
-        variables and returns the new modified problem.
-        The original Problem instance is untouched.
-
-        :param fixed_variables:
-            The dictionary of variable ids and their fixed state
-        """
-        if len(fixed_variables) == 0:
-            raise RuntimeError(
-                "Error: fixed_variables is empty - \
-                please specify at least one fixed variable"
-            )
-
-        fixed_transformed = {
-            int(k): fixed_variables[k] for k in fixed_variables
-        }  # if ids are given in string form, convert them to int
-        new_terms = []
-
-        constant = 0
-        for term in self.terms:
-            reduced_term = term.reduce_by_variable_state(fixed_transformed)
-            if reduced_term:
-                if not isinstance(reduced_term, Term) or len(reduced_term.ids) > 0:
-                    new_terms.append(reduced_term)
-                else:
-                    # reduced to a constant term
-                    constant += reduced_term.c
-
-        if constant:
-            new_terms.append(Term(c=constant, indices=[]))
-
-        new_init_config = None
-        if self.init_config:
-            new_init_config = {
-                k: self.init_config[k]
-                for k in self.init_config
-                if int(k) not in fixed_transformed
-            }
-
-        return Problem(
-            self.name,
-            terms=new_terms,
-            init_config=new_init_config,
-            problem_type=self.problem_type,
-        )
-
-    def _evaluate(self, configuration, term_list):
-        total = 0
-        if term_list:
-            for term in term_list:
-                total += term.evaluate(configuration)
-        return total
-
-    def evaluate(self, configuration: Union[Dict[int, int], Dict[str, int]]) -> float:
-        """Given a configuration/variable assignment,
-        return the cost function value of this problem.
-
-        :param configuration: The dictionary of
-         variable ids to their assigned value
-        """
-        configuration_transformed = {
-            int(k): configuration[k] for k in configuration
-        }  # if ids are given in string form, convert them to int
-
-        total_cost = 0
-        for terms in self.terms:
-            total_cost += self._evaluate(configuration_transformed, terms)
-
-        return total_cost
-
-    def is_large(self) -> bool:
-        """Determines if the current problem is large.
-        "large" is an arbitrary threshold and can be easily changed.
-        Based on usage data, we have defined a
-        large problem to be NUM_VARIABLES_LARGE+
-        variables AND NUM_TERMS_LARGE+ terms.
-        """
-
-        set_vars = set()
-        total_term_count = 0
-        for term in self.terms:
-            if isinstance(term, Term):
-                set_vars.update(term.ids)
-                total_term_count += 1
-        
-        return (
-            len(set_vars) >= Problem.NUM_VARIABLES_LARGE
-            and total_term_count >= Problem.NUM_TERMS_LARGE
-        )
-
-    def download(self, workspace: "Workspace"):
-        """Downloads the uploaded problem as an instance of `Problem`"""
-        if not self.uploaded_blob_uri:
-            raise Exception("Problem may not be downloaded before it is uploaded")
-        blob_client = BlobClient.from_blob_url(self.uploaded_blob_uri)
-        container_client = ContainerClient.from_container_url(
-            workspace._get_linked_storage_sas_uri(blob_client.container_name)
-        )
-        blob_name = blob_client.blob_name
-        blob = container_client.get_blob_client(blob_name)
-        contents = download_blob(blob.url)
-        blob_properties = download_blob_properties(blob.url)        
-        content_type = blob_properties.content_type
-        return Problem.deserialize(contents, self.name, content_type)
-
-    def get_terms(self, id: int) -> List[TermBase]:
-        """Given an index the function will return
-        a list of terms with that index
-        """
-        terms = []
-        if self.terms != []:
-            for term in self.terms:
-                if isinstance(term, Term):
-                    if id in term.ids:
-                        terms.append(term)
-            return terms
-        else:
-            raise Exception(
-                "There are currently no terms in this problem. \
-                Please download the problem on the client or add terms to the \
-                    problem to perform this operation"
-            )

azure/quantum/optimization/solvers.py

@@ -1,10 +0,0 @@
-# coding=utf-8
-##
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-##
-import warnings
-warnings.warn("The azure.quantum.optimization.solvers namespace will be deprecated. \
-Please use azure.quantum.target instead.")
-
-from azure.quantum.target.solvers import Solver