azure-quantum 0.30.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

azure/quantum/aio/optimization/streaming_problem.py

@@ -1,280 +0,0 @@
-##
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-##
-
-import logging
-import sys
-import gzip
-import io
-
-from asyncio import sleep
-
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
-from azure.quantum.optimization import Term
-from azure.quantum.aio.optimization import Problem
-from azure.quantum.aio.storage import (
-    StreamedBlob,
-    ContainerClient,
-    BlobClient,
-    download_blob,
-)
-from azure.quantum.optimization.streaming_problem import StreamingProblem as SyncStreamingProblem
-from azure.quantum.optimization.streaming_problem import JsonStreamingProblemUploader as SyncJsonStreamingProblemUploader
-from azure.quantum.aio.storage import StreamedBlobState
-from azure.quantum.aio.optimization.problem import ProblemType
-
-from asyncio import create_task
-from queue import Empty
-
-if TYPE_CHECKING:
-    from azure.quantum.aio.workspace import Workspace
-
-
-logger = logging.getLogger(__name__)
-
-__all__ = ["StreamingProblem"]
-
-
-class StreamingProblem(SyncStreamingProblem):
-    """Problem to be streamed to the service.
-
-    Streaming problems are uploaded on the fly as terms are added,
-    meaning that the whole problem representation is not kept in memory. This
-    is very useful when constructing large  problems.
-
-    :param workspace: Workspace to upload problem to
-    :type workspace: Workspace
-    :param name: Problem name
-    :type name: str
-    :param terms: Problem terms, depending on solver. Defaults to None
-    :type terms: Optional[List[Term]], 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
-    """
-    @classmethod
-    async def create(
-        cls,
-        workspace: "Workspace",
-        name: str = "Optimization Problem",
-        terms: Optional[List[Term]] = None,
-        init_config: Optional[Dict[str, int]] = None,
-        problem_type: "ProblemType" = ProblemType.ising,
-        metadata: Dict[str, str] = {},
-        **kw,
-    ):
-        problem = cls(
-            workspace,
-            name,
-            None,   # terms need to be added manually later so it can be awaited
-            init_config,
-            problem_type,
-            metadata,
-            **kw
-        )
-        if terms is not None and len(terms) > 0:
-            await problem.add_terms(terms.copy())
-        return problem
-
-    async def add_term(self, c: Union[int, float], indices: List[int]):
-        """Adds a single term to the `Problem`
-        representation and queues it to be uploaded
-
-        :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]
-        """
-        await self.add_terms([Term(indices=indices, c=c)])
-
-    async def _get_upload_coords(self):
-        blob_name = self.id
-        if self.upload_to_url:
-            blob_client = BlobClient.from_blob_url(self.upload_to_url)
-            container_client = ContainerClient.from_container_url(
-                await self.workspace._get_linked_storage_sas_uri(
-                    blob_client.container_name
-                )
-            )
-            blob_name = blob_client.blob_name
-            await blob_client.close()
-        elif not self.workspace.storage:
-            # No storage account is passed, use the linked one
-            container_uri = await self.workspace._get_linked_storage_sas_uri(self.id)
-            container_client = ContainerClient.from_container_url(
-                container_uri
-            )
-        else:
-            # Use the specified storage account
-            container_client = ContainerClient.from_connection_string(
-                self.workspace.storage, self.id
-            )
-
-        return {"blob_name": blob_name, "container_client": container_client}
-
-    async def add_terms(self, terms: List[Term]):
-        """Adds a list of terms to the `Problem`
-         representation and queues them to be uploaded
-
-        :param terms: The list of terms to add to the problem
-        """
-        if self.uploaded_uri is not None:
-            raise Exception("Cannot add terms after problem has been uploaded")
-
-        if terms is not None:
-            if self.uploader is None:
-                upload_coords = await self._get_upload_coords()
-                self.uploader = JsonStreamingProblemUploader(
-                    problem=self,
-                    container=upload_coords["container_client"],
-                    name=upload_coords["blob_name"],
-                    upload_size_threshold=self.upload_size_threshold,
-                    upload_term_threshold=self.upload_terms_threshold,
-                )
-
-            max_coupling = -sys.float_info.max
-            min_coupling = sys.float_info.max
-            for term in terms:
-                if isinstance(term, Term):
-                    n = len(term.ids)
-                    max_coupling = max(max_coupling, n)
-                    min_coupling = min(min_coupling, n)
-                    self.__n_couplers += n
-                    self.stats["num_terms"] += 1
-                else:
-                    raise Exception(
-                        "Unsupported statistics in streamingproblem for TermBase subclass {}.".format(type(term))
-                    )
-
-            self.stats["avg_coupling"] = (
-                self.__n_couplers / self.stats["num_terms"]
-            )
-            if self.stats["max_coupling"] < max_coupling:
-                self.stats["max_coupling"] = max_coupling
-            if self.stats["min_coupling"] > min_coupling:
-                self.stats["min_coupling"] = min_coupling
-
-            await self.uploader.upload(terms)
-
-    async def download(self):
-        """Downloads the uploaded problem as an instance of `Problem`"""
-        if not self.uploaded_uri:
-            raise Exception(
-                "StreamingProblem may not be downloaded before it is uploaded"
-            )
-
-        coords = await self._get_upload_coords()
-        blob = coords["container_client"].get_blob_client(coords["blob_name"])
-        contents = await download_blob(blob.url)
-        return Problem.deserialize(contents, self.name)
-
-    async def upload(
-        self,
-        workspace=None
-    ):
-        """Uploads an optimization problem instance
-           to the cloud storage linked with the Workspace.
-
-        :return: uri of the uploaded problem
-        """
-        if self.uploader is None:
-            raise RuntimeError("You must add terms before uploading")
-
-        if self.uploaded_uri:
-            raise RuntimeError("Problem has already been uploaded.")
-
-        if workspace and self.workspace != workspace:
-            raise RuntimeError("Workspace must match workspace provided in constructor.")
-
-        if not self.uploaded_uri:
-            self.uploader.blob_properties = {
-                k: str(v) for k, v in {**self.stats, **self.metadata}.items()
-            }
-            await self.uploader.finish_upload()
-            blob = self.uploader.blob
-            self.uploaded_uri = blob.getUri(self.workspace.storage)
-            self.uploader = None
-            self.terms_queue = None
-
-        return self.uploaded_uri
-
-
-class JsonStreamingProblemUploader(SyncJsonStreamingProblemUploader):
-    """Helper class for uploading json problem files in chunks.
-
-    :param problem: Back-ref to the problem being uploaded
-    :param container: Reference to the container
-     client in which to store the problem
-    :param name: Name of the problem (added to blob metadata)
-    :param upload_size_threshold: Chunking threshold (in bytes).
-     Once the internal buffer reaches this size, the chunk will be uploaded.
-    :param upload_term_threshold: Chunking threshold (in terms).
-     Once this many terms are ready to be uploaded, the chunk will be uploaded.
-    :param blob_properties: Properties to set on the blob.
-    """
-    def __init__(
-        self,
-        problem: StreamingProblem,
-        container: ContainerClient,
-        name: str,
-        upload_size_threshold: int,
-        upload_term_threshold: int,
-        blob_properties: Dict[str, str] = None,
-    ):
-        self.problem = problem
-        self.started_upload = False
-        self.blob = StreamedBlob(
-            container,
-            name,
-            "application/json",
-            self._get_content_type(),
-        )
-        self.compressedStream = io.BytesIO()
-        self.compressor = (
-            gzip.GzipFile(mode="wb", fileobj=self.compressedStream)
-        )
-        self.uploaded_terms = 0
-        self.blob_properties = blob_properties
-        self.__thread = None
-        self.__queue_wait_timeout = 1
-        self.__upload_terms_threshold = upload_term_threshold
-        self.__upload_size_threshold = upload_size_threshold
-        self.__read_pos = 0
-
-    def is_done(self):
-        """True if the thread uploader has completed"""
-        return self.blob.state == StreamedBlobState.committed
-
-    async def _upload_start(self, terms):
-        self.started_upload = True
-        await self._upload_chunk(
-            f'{{"cost_function":{{"version":"{self._get_version()}",'
-            + f'"type":"{self._scrub(self.problem.problem_type.name)}",'
-            + self._get_initial_config_string()
-            + '"terms":['
-            + self._get_terms_string(terms)
-        )
-
-    async def upload(self, terms):
-        if not self.started_upload:
-            await self._upload_start(terms)
-        else:
-            await self._upload_chunk(self._get_terms_string(terms))
-
-    async def _upload_chunk(self, chunk: str, is_final: bool = False):
-        compressed = self._maybe_compress_bits(chunk.encode(), is_final)
-        if compressed is None:
-            return
-        if len(compressed) > 0:
-            await self.blob.upload_data(compressed)
-
-    async def finish_upload(self):
-        if not self.started_upload:
-            await self._upload_start([])
-
-        await self._upload_chunk(f'{"]}}"}', True)
-        await self.blob.commit(metadata=self.blob_properties)

azure/quantum/aio/storage.py

@@ -1,390 +0,0 @@
-##
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-##
-import logging
-from typing import Any, Dict
-from azure.core import exceptions
-from azure.storage.blob.aio import (
-    BlobServiceClient,
-    ContainerClient,
-    BlobClient,
-    BlobType,
-)
-from azure.storage.blob import (
-    BlobSasPermissions,
-    ContentSettings,
-    generate_blob_sas,
-    generate_container_sas,
-)
-from datetime import datetime, timedelta
-from enum import Enum
-
-logger = logging.getLogger(__name__)
-
-
-async def create_container(
-    connection_string: str, container_name: str
-) -> ContainerClient:
-    """
-    Creates and initialize a container; returns the client needed to access it.
-    """
-    blob_service_client = BlobServiceClient.from_connection_string(
-        connection_string
-    )
-    logger.info(
-        f'{"Initializing storage client for account:"}'
-        + f"{blob_service_client.account_name}"
-    )
-
-    container_client = blob_service_client.get_container_client(container_name)
-    await create_container_using_client(container_client)
-    return container_client
-
-
-async def create_container_using_client(container_client: ContainerClient):
-    """
-    Creates and initializes a container.
-    """
-    container_exists = await container_client.exists()
-    if not container_exists:
-        logger.debug(
-            f'{"  - uploading to **new** container:"}'
-            f"{container_client.container_name}"
-        )
-        await container_client.create_container()
-
-
-async def get_container_uri(connection_string: str, container_name: str) -> str:
-    """
-    Creates and initialize a container;
-    returns a URI with a SAS read/write token to access it.
-    """
-    container = await create_container(connection_string, container_name)
-    logger.info(
-        f'{"Creating SAS token for container"}'
-        + f"'{container_name}' on account: '{container.account_name}'"
-    )
-
-    sas_token = generate_container_sas(
-        container.account_name,
-        container.container_name,
-        account_key=container.credential.account_key,
-        permission=BlobSasPermissions(
-            read=True, add=True, write=True, create=True
-        ),
-        expiry=datetime.utcnow() + timedelta(days=14),
-    )
-
-    uri = container.url + "?" + sas_token
-    logger.debug(f"  - container url: '{uri}'.")
-    return uri
-
-
-async def upload_blob(
-    container: ContainerClient,
-    blob_name: str,
-    content_type: str,
-    content_encoding: str,
-    data: Any,
-    return_sas_token: bool = True,
-) -> str:
-    """
-    Uploads the given data to a blob record.
-    If a blob with the given name already exist, it throws an error.
-
-    Returns a uri with a SAS token to access the newly created blob.
-    """
-    await create_container_using_client(container)
-    logger.info(
-        f"Uploading blob '{blob_name}'"
-        + f"to container '{container.container_name}'"
-        + f"on account: '{container.account_name}'"
-    )
-
-    content_settings = ContentSettings(
-        content_type=content_type, content_encoding=content_encoding
-    )
-    blob = container.get_blob_client(blob_name)
-    await blob.upload_blob(data, content_settings=content_settings)
-    logger.debug(f"  - blob '{blob_name}' uploaded. generating sas token.")
-
-    if return_sas_token:
-        uri = get_blob_uri_with_sas_token(blob)
-    else:
-        uri = remove_sas_token(blob.url)
-
-    logger.debug(f"  - blob access url: '{uri}'.")
-    await blob.close()
-
-    return uri
-
-
-async def append_blob(
-    container: ContainerClient,
-    blob_name: str,
-    content_type: str,
-    content_encoding: str,
-    data: Any,
-    return_sas_token: bool = True,
-    metadata: Dict[str, str] = None,
-) -> str:
-    """
-    Uploads the given data to a blob record.
-    If a blob with the given name already exist, it throws an error.
-
-    Returns a uri with a SAS token to access the newly created blob.
-    """
-    await create_container_using_client(container)
-    logger.info(
-        f"Appending data to blob '{blob_name}'"
-        + f"in container '{container.container_name}'"
-        + f"on account: '{container.account_name}'"
-    )
-
-    content_settings = ContentSettings(
-        content_type=content_type, content_encoding=content_encoding
-    )
-    blob = container.get_blob_client(blob_name)
-    try:
-        props = await blob.get_blob_properties()
-        if props.blob_type != BlobType.AppendBlob:
-            raise Exception("blob must be an append blob")
-    except exceptions.ResourceNotFoundError:
-        props = await blob.create_append_blob(
-            content_settings=content_settings, metadata=metadata
-        )
-
-    await blob.append_block(data, len(data))
-    logger.debug(f"  - blob '{blob_name}' appended. generating sas token.")
-
-    if return_sas_token:
-        uri = get_blob_uri_with_sas_token(blob)
-    else:
-        uri = remove_sas_token(blob.url)
-
-    logger.debug(f"  - blob access url: '{uri}'.")
-    await blob.close()
-
-    return uri
-
-
-def get_blob_uri_with_sas_token(blob: BlobClient):
-    """Returns a URI for the given blob that contains a SAS Token"""
-    sas_token = generate_blob_sas(
-        blob.account_name,
-        blob.container_name,
-        blob.blob_name,
-        account_key=blob.credential.account_key,
-        permission=BlobSasPermissions(read=True),
-        expiry=datetime.utcnow() + timedelta(days=14),
-    )
-
-    return blob.url + "?" + sas_token
-
-
-async def download_blob(blob_url: str) -> Any:
-    """
-    Downloads the given blob from the container.
-    """
-    blob_client = BlobClient.from_blob_url(blob_url)
-    logger.info(
-        f"Downloading blob '{blob_client.blob_name}'"
-        + f"from container '{blob_client.container_name}'"
-        + f"on account: '{blob_client.account_name}'"
-    )
-
-    response = await (await blob_client.download_blob()).readall()
-    logger.debug(response)
-    await blob_client.close()
-
-    return response
-
-
-async def download_blob_properties(blob_url: str) -> Dict[str, str]:
-    """Downloads the blob properties from Azure for the given blob URI"""
-    blob_client = BlobClient.from_blob_url(blob_url)
-    logger.info(
-        f"Downloading blob properties '{blob_client.blob_name}'"
-        + f"from container '{blob_client.container_name}'"
-        + f"on account: '{blob_client.account_name}'"
-    )
-
-    response = await blob_client.get_blob_properties()
-    logger.debug(response)
-
-    return response
-
-
-async def download_blob_metadata(blob_url: str) -> Dict[str, str]:
-    """Downloads the blob metadata from the
-    blob properties in Azure for the given blob URI"""
-    return (await download_blob_properties(blob_url)).metadata
-
-
-async def set_blob_metadata(blob_url: str, metadata: Dict[str, str]):
-    """Sets the provided dictionary as the metadata on the Azure blob"""
-    blob_client = BlobClient.from_blob_url(blob_url)
-    logger.info(
-        f"Setting blob properties '{blob_client.blob_name}'"
-        + f"from container '{blob_client.container_name}' on account:"
-        + f"'{blob_client.account_name}'"
-    )
-    return await blob_client.set_blob_metadata(metadata=metadata)
-
-
-def remove_sas_token(sas_uri: str) -> str:
-    """Removes the SAS Token from the given URI if it contains one"""
-    index = sas_uri.find("?")
-    if index != -1:
-        sas_uri = sas_uri[0:index]
-
-    return sas_uri
-
-
-async def init_blob_for_streaming_upload(
-    container: ContainerClient,
-    blob_name: str,
-    content_type: str,
-    content_encoding: str,
-    data: Any,
-    return_sas_token: bool = True,
-) -> str:
-    """
-    Uploads the given data to a blob record.
-    If a blob with the given name already exist, it throws an error.
-
-    Returns a uri with a SAS token to access the newly created blob.
-    """
-    await create_container_using_client(container)
-    logger.info(
-        f"Streaming blob '{blob_name}'"
-        + f"to container '{container.container_name}' on account:"
-        + f"'{container.account_name}'"
-    )
-
-    content_settings = ContentSettings(
-        content_type=content_type, content_encoding=content_encoding
-    )
-    blob = container.get_blob_client(blob_name)
-    await blob.stage_block()
-    await blob.commit_block_list()
-    await blob.upload_blob(data, content_settings=content_settings)
-    logger.debug(f"  - blob '{blob_name}' uploaded. generating sas token.")
-
-    if return_sas_token:
-        sas_token = generate_blob_sas(
-            blob.account_name,
-            blob.container_name,
-            blob.blob_name,
-            account_key=blob.credential.account_key,
-            permission=BlobSasPermissions(read=True),
-            expiry=datetime.utcnow() + timedelta(days=14),
-        )
-
-        uri = blob.url + "?" + sas_token
-    else:
-        uri = remove_sas_token(blob.url)
-
-    logger.debug(f"  - blob access url: '{uri}'.")
-
-    return uri
-
-
-class StreamedBlobState(str, Enum):
-    not_initialized = 0
-    uploading = 1
-    committed = 2
-
-
-class StreamedBlob:
-    """Class that provides a state machine for writing
-    blobs using the Azure Block Blob API
-
-    Internally implements a state machine for uploading blob data.
-    To use, start calling `upload_data()`
-    to add data blocks. Each call to `upload_data()`
-    will synchronously upload an individual block to Azure.
-    Once all blocks have been added, call `commit()`
-    to commit the blocks and make the blob available/readable.
-
-    :param container: The container client that the blob will be uploaded to
-    :param blob_name: The name of the blob
-        (including optional path) within the blob container
-    :param content_type: The HTTP content type to apply to the blob metadata
-    :param content_encoding: The HTTP
-        content encoding to apply to the blob metadata
-    """
-
-    def __init__(
-        self,
-        container: ContainerClient,
-        blob_name: str,
-        content_type: str,
-        content_encoding: str,
-    ):
-        self.container = container
-        self.blob_name = blob_name
-        self.content_settings = ContentSettings(
-            content_type=content_type, content_encoding=content_encoding
-        )
-        self.state = StreamedBlobState.not_initialized
-        self.blob = container.get_blob_client(blob_name)
-        self.blocks = []
-
-    async def upload_data(self, data):
-        """Synchronously uploads a block to the given block blob in Azure
-
-        :param data: The data to be uploaded as a block.
-        :type data: Union[Iterable[AnyStr], IO[AnyStr]]
-        """
-        if self.state == StreamedBlobState.not_initialized:
-            await create_container_using_client(self.container)
-            logger.info(
-                f"Streaming blob '{self.blob_name}' to container"
-                + f"'{self.container.container_name}'"
-                + f"on account: '{self.container.account_name}'"
-            )
-            self.initialized = True
-
-        self.state = StreamedBlobState.uploading
-        id = self._get_next_block_id()
-        logger.debug(f"Uploading block '{id}' to {self.blob_name}")
-        await self.blob.stage_block(id, data, length=len(data))
-        self.blocks.append(id)
-
-    async def commit(self, metadata: Dict[str, str] = None):
-        """Synchronously commits all previously
-        uploaded blobs to the block blob
-
-        :param metadata: Optional dictionary of
-               metadata to be applied to the block blob
-        """
-        if self.state == StreamedBlobState.not_initialized:
-            raise Exception("StreamedBlob cannot commit before uploading data")
-        elif self.state == StreamedBlobState.committed:
-            raise Exception("StreamedBlob is already committed")
-
-        logger.debug(f"Committing {len(self.blocks)} blocks {self.blob_name}")
-        await self.blob.commit_block_list(
-            self.blocks,
-            content_settings=self.content_settings,
-            metadata=metadata,
-        )
-        self.state = StreamedBlobState.committed
-        await self.container.close()
-        await self.blob.close()
-        logger.debug(f"Committed {self.blob_name}")
-
-    def getUri(self, with_sas_token: bool = False):
-        """Gets the full Azure Storage URI for the
-        uploaded blob after it has been committed"""
-        if self.state != StreamedBlobState.committed:
-            raise Exception("Can only retrieve sas token for committed blob")
-        if with_sas_token:
-            return get_blob_uri_with_sas_token(self.blob)
-
-        return remove_sas_token(self.blob.url)
-
-    def _get_next_block_id(self):
-        return f"{len(self.blocks):10}"

azure/quantum/aio/target/__init__.py

@@ -1,19 +0,0 @@
-##
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-##
-from azure.quantum.aio.target.target import Target
-from azure.quantum.aio.target.solvers import Solver
-from .toshiba import (
-    SimulatedBifurcationMachine
-)
-from .ionq import IonQ
-from .quantinuum import Quantinuum
-
-# Default targets to use when there is no target class
-# associated with a given target ID
-DEFAULT_TARGETS = {
-    "ionq": IonQ,
-    "quantinuum": Quantinuum,
-    "toshiba": Solver
-}