classiq 0.33.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -1,13 +1,16 @@
 import json
-from typing import Any, Dict, Optional, Protocol, Type, TypeVar, Union
+from typing import Dict, Optional, Protocol, Type, TypeVar
 
 import pydantic
-from pydantic import parse_obj_as
 
 import classiq.interface.pyomo_extension  # noqa: F401 - patches pyomo to add few features
 from classiq.interface.analyzer import analysis_params, result as analysis_result
 from classiq.interface.analyzer.analysis_params import AnalysisRBParams
 from classiq.interface.chemistry import ground_state_problem, operator
+from classiq.interface.execution.jobs import (
+    ExecutionJobDetailsV1,
+    ExecutionJobsQueryResultsV1,
+)
 from classiq.interface.executor import execution_request, result as execute_result
 from classiq.interface.generator import generated_circuit as generator_result
 from classiq.interface.jobs import JobDescription, JobID, JobStatus, JSONObject
@@ -19,16 +22,14 @@ from classiq._internals.enum_utils import StrEnum
 from classiq._internals.jobs import JobPoller
 from classiq.exceptions import ClassiqAPIError, ClassiqValueError
 
-_FAIL_FAST_INDICATOR = "{"
 ResultType = TypeVar("ResultType", bound=pydantic.BaseModel)
-OtherResultType = TypeVar("OtherResultType", bound=pydantic.BaseModel)
-_Circuit = Union[generator_result.GeneratedCircuit, generator_result.ExecutionCircuit]
 
 
 class HTTPMethod(StrEnum):
     # Partial backport from Python 3.11
     GET = "GET"
     POST = "POST"
+    PATCH = "PATCH"
 
 
 class StatusType(Protocol):
@@ -45,26 +46,22 @@ def _parse_job_response(
     return output_type.parse_obj(description)
 
 
-def _parse_job_response_multiple_outputs(
-    job_result: JobDescription[JSONObject],
-    output_type: Any,  # UnionType in Python 3.10,
-) -> Union[ResultType, OtherResultType]:
-    description = job_result.description
-    if job_result.status != JobStatus.COMPLETED:
-        raise ClassiqAPIError(description["details"])
-    return parse_obj_as(output_type, description)
-
-
 class ApiWrapper:
     @classmethod
     async def _call_task_pydantic(
-        cls, http_method: str, url: str, model: pydantic.BaseModel
+        cls,
+        http_method: str,
+        url: str,
+        model: pydantic.BaseModel,
+        use_versioned_url: bool = True,
     ) -> dict:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
         # This was added because JSON serializer doesn't serialize complex type, and pydantic does.
         # We should add support for smarter json serialization.
         body = json.loads(model.json())
-        return await cls._call_task(http_method, url, body)
+        return await cls._call_task(
+            http_method, url, body, use_versioned_url=use_versioned_url
+        )
 
     @classmethod
     async def _call_task(
@@ -73,24 +70,30 @@ class ApiWrapper:
         url: str,
         body: Optional[Dict] = None,
         params: Optional[Dict] = None,
+        use_versioned_url: bool = True,
     ) -> dict:
         res = await client().call_api(
-            http_method=http_method, url=url, body=body, params=params
+            http_method=http_method,
+            url=url,
+            body=body,
+            params=params,
+            use_versioned_url=use_versioned_url,
         )
         if not isinstance(res, dict):
             raise ClassiqValueError(f"Unexpected returned value: {res}")
         return res
 
     @classmethod
-    async def call_generation_task(cls, model: ModelInput) -> _Circuit:
+    async def call_generation_task(
+        cls, model: ModelInput
+    ) -> generator_result.GeneratedCircuit:
         poller = JobPoller(base_url=routes.TASKS_GENERATE_FULL_PATH)
         result = await poller.run_pydantic(model, timeout_sec=None)
-        return _parse_job_response_multiple_outputs(result, _Circuit)
+        return _parse_job_response(result, generator_result.GeneratedCircuit)
 
     @classmethod
     async def call_execute_generated_circuit(
-        cls,
-        circuit: _Circuit,
+        cls, circuit: generator_result.GeneratedCircuit
     ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -121,6 +124,39 @@ class ApiWrapper:
         )
         return execution_request.ExecuteGeneratedCircuitResults.parse_obj(data)
 
+    @classmethod
+    async def call_patch_execution_job(
+        cls,
+        job_id: JobID,
+        name: str,
+    ) -> ExecutionJobDetailsV1:
+        data = await cls._call_task(
+            http_method=HTTPMethod.PATCH,
+            url=f"{routes.EXECUTION_SERVICE_JOBS_FULL_PATH}/{job_id.job_id}",
+            params={
+                "name": name,
+            },
+            use_versioned_url=False,
+        )
+        return ExecutionJobDetailsV1.parse_obj(data)
+
+    @classmethod
+    async def call_query_execution_jobs(
+        cls,
+        offset: int,
+        limit: int,
+    ) -> ExecutionJobsQueryResultsV1:
+        data = await cls._call_task(
+            http_method=HTTPMethod.GET,
+            url=f"{routes.EXECUTION_SERVICE_JOBS_FULL_PATH}",
+            params={
+                "offset": offset,
+                "limit": limit,
+            },
+            use_versioned_url=False,
+        )
+        return ExecutionJobsQueryResultsV1.parse_obj(data)
+
     @classmethod
     async def call_execute_estimate(
         cls, request: execution_request.ExecutionRequest
@@ -231,7 +267,9 @@ class ApiWrapper:
     async def call_generate_hamiltonian_task(
         cls, problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE
     ) -> operator.PauliOperator:
-        poller = JobPoller(base_url=routes.CHEMISTRY_GENERATE_HAMILTONIAN_FULL_PATH)
+        poller = JobPoller(
+            base_url=routes.GENERATE_HAMILTONIAN_FULL_PATH, use_versioned_url=False
+        )
         result = await poller.run_pydantic(problem, timeout_sec=None)
         return _parse_job_response(result, operator.PauliOperator)
 

classiq/_internals/client.py

@@ -195,11 +195,14 @@ class Client:
         url: str,
         body: Optional[Dict] = None,
         params: Optional[Dict] = None,
+        use_versioned_url: bool = True,
     ) -> Union[Dict, str]:
+        if use_versioned_url:
+            url = self.make_versioned_url(url)
         async with self.async_client() as async_client:
             response = await async_client.request(
                 method=http_method,
-                url=self.make_versioned_url(url),
+                url=url,
                 json=body,
                 params=params,
             )

classiq/_internals/jobs.py

@@ -52,11 +52,18 @@ class JobPoller:
     DEV_INTERVAL = 0.05
 
     def __init__(
-        self, base_url: str, required_headers: Optional[Set[str]] = None
+        self,
+        base_url: str,
+        required_headers: Optional[Set[str]] = None,
+        use_versioned_url: bool = True,
     ) -> None:
         self._required_headers = required_headers or set()
         client_instance = client()
-        self._base_url = client_instance.make_versioned_url(base_url)
+        self._base_url = (
+            client_instance.make_versioned_url(base_url)
+            if use_versioned_url
+            else base_url
+        )
         self._async_client = client_instance.async_client()
         self._mode = client_instance.config.mode
 

classiq/applications_model_constructors/grover_model_constructor.py

@@ -162,7 +162,7 @@ def construct_grover_model(
                 port_declarations=predicate_port_decls,
                 body=[
                     ArithmeticOperation(
-                        expr_str=expression,
+                        expression=Expression(expr=expression),
                         result_var=HandleBinding(name="res"),
                         inplace_result=True,
                     ),

classiq/execution/__init__.py

@@ -9,13 +9,20 @@ from ..interface.executor.execution_preferences import __all__ as _ep_all
 from ..interface.executor.iqae_result import IQAEResult
 from ..interface.executor.result import ExecutionDetails
 from ..interface.executor.vqe_result import VQESolverResult
-from .jobs import ExecutionJob
+from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
 
 __all__ = (
     _be_all
     + _ep_all
     + _exec_all
-    + ["ExecutionDetails", "VQESolverResult", "IQAEResult", "ExecutionJob"]
+    + [
+        "ExecutionDetails",
+        "VQESolverResult",
+        "IQAEResult",
+        "ExecutionJob",
+        "get_execution_jobs",
+        "get_execution_jobs_async",
+    ]
 )
 
 

classiq/execution/jobs.py

@@ -1,7 +1,9 @@
-from typing import Optional
-
-from pydantic import PrivateAttr
+import webbrowser
+from datetime import datetime
+from typing import List, Optional, Union
+from urllib.parse import urljoin
 
+from classiq.interface.execution.jobs import ExecutionJobDetailsV1
 from classiq.interface.executor.execution_request import (
     ExecutionJobDetails,
     ResultsCollection,
@@ -11,19 +13,67 @@ from classiq.interface.server.routes import EXECUTION_JOBS_FULL_PATH
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
+from classiq._internals.client import client
 from classiq._internals.jobs import JobID, JobPoller
 from classiq.exceptions import ClassiqAPIError
 
+_JobDetails = Union[ExecutionJobDetails, ExecutionJobDetailsV1]
+
+
+class ExecutionJob:
+    _details: _JobDetails
+    _result: Optional[ResultsCollection]
+
+    def __init__(self, details: _JobDetails) -> None:
+        self._details = details
+        self._result = None
+
+    @property
+    def id(self) -> str:
+        return self._details.id
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._details.name
+
+    @property
+    def start_time(self) -> datetime:
+        return self._details.start_time
+
+    @property
+    def end_time(self) -> Optional[datetime]:
+        return self._details.end_time
 
-class ExecutionJob(ExecutionJobDetails):
-    _result: Optional[ResultsCollection] = PrivateAttr(default=None)
+    @property
+    def provider(self) -> Optional[str]:
+        return self._details.provider
 
-    def __init__(self, details: ExecutionJobDetails) -> None:
-        super().__init__(**details.dict())
+    @property
+    def backend_name(self) -> Optional[str]:
+        return self._details.backend_name
 
-    def _update_details(self, details: ExecutionJobDetails) -> None:
-        for k, v in details.dict().items():
-            setattr(self, k, v)
+    @property
+    def status(self) -> JobStatus:
+        return self._details.status
+
+    @property
+    def num_shots(self) -> Optional[int]:
+        return self._details.num_shots
+
+    @property
+    def program_id(self) -> Optional[str]:
+        return self._details.program_id
+
+    @property
+    def error(self) -> Optional[str]:
+        return self._details.error
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        if self.name is None:
+            return f"{class_name}(id={self.id!r})"
+        else:
+            return f"{class_name}(name={self.name!r}, id={self.id!r})"
 
     @classmethod
     async def from_id_async(cls, id: str) -> "ExecutionJob":
@@ -64,7 +114,7 @@ class ExecutionJob(ExecutionJobDetails):
 
     async def _poll_job(self, timeout_sec: Optional[float] = None) -> None:
         def response_parser(json_response: JSONObject) -> Optional[bool]:
-            self._update_details(ExecutionJobDetails.parse_obj(json_response))
+            self._details = ExecutionJobDetails.parse_obj(json_response)
             if self.status.is_final():
                 return True
             return None
@@ -75,3 +125,26 @@ class ExecutionJob(ExecutionJobDetails):
             response_parser=response_parser,
             timeout_sec=timeout_sec,
         )
+
+    async def rename_async(self, name: str) -> None:
+        self._details = await ApiWrapper.call_patch_execution_job(self._job_id, name)
+
+    rename = syncify_function(rename_async)
+
+    @property
+    def ide_url(self) -> str:
+        base_url = client().config.ide
+        return urljoin(base_url, f"jobs/{self.id}")
+
+    def open_in_ide(self) -> None:
+        webbrowser.open_new_tab(self.ide_url)
+
+
+async def get_execution_jobs_async(
+    offset: int = 0, limit: int = 50
+) -> List[ExecutionJob]:
+    result = await ApiWrapper().call_query_execution_jobs(offset=offset, limit=limit)
+    return [ExecutionJob(details) for details in result.results]
+
+
+get_execution_jobs = syncify_function(get_execution_jobs_async)

classiq/executor.py

@@ -3,7 +3,6 @@ import functools
 from typing import Optional, Tuple, Union
 
 import more_itertools
-from pydantic import parse_raw_as
 from typing_extensions import TypeAlias
 
 from classiq.interface.backend.backend_preferences import BackendPreferencesTypes
@@ -19,10 +18,7 @@ from classiq.interface.executor.execution_request import (
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.quantum_program import MultipleArguments, QuantumProgram
 from classiq.interface.executor.result import ExecutionDetails
-from classiq.interface.generator.generated_circuit import (
-    ExecutionCircuit,
-    GeneratedCircuit,
-)
+from classiq.interface.generator.generated_circuit import GeneratedCircuit
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
@@ -40,11 +36,8 @@ _MAX_ARGUMENTS_SIZE = 1024
 
 def _parse_serialized_qprog(
     quantum_program: SerializedQuantumProgram,
-) -> Union[GeneratedCircuit, ExecutionCircuit]:
-    return parse_raw_as(
-        Union[GeneratedCircuit, ExecutionCircuit],  # type:ignore[arg-type]
-        quantum_program,
-    )
+) -> GeneratedCircuit:
+    return GeneratedCircuit.parse_raw(quantum_program)
 
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.33.0'
+SEMVER_VERSION = '0.35.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel, validator
 from classiq.interface.backend import pydantic_backend
 from classiq.interface.backend.quantum_backend_providers import (
     EXACT_SIMULATORS,
+    AliceBobBackendNames,
     AmazonBraketBackendNames,
     AzureQuantumBackendNames,
     ClassiqAerBackendNames,
@@ -55,6 +56,19 @@ class BackendPreferences(BaseModel):
 AWS_DEFAULT_JOB_TIMEOUT_SECONDS = int(timedelta(minutes=5).total_seconds())
 
 
+class AliceBobBackendPreferences(BackendPreferences):
+    backend_service_provider: ProviderTypeVendor.ALICE_BOB
+    api_key: pydantic_backend.PydanticAliceBobApiKeyType = pydantic.Field(
+        ..., description="AliceBob API key"
+    )
+
+    @pydantic.root_validator(pre=True)
+    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(
+            values, "backend_service_provider", ProviderVendor.ALICE_AND_BOB
+        )
+
+
 class ClassiqBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.CLASSIQ
 
@@ -214,6 +228,7 @@ BackendPreferencesTypes = Union[
     AwsBackendPreferences,
     IonqBackendPreferences,
     GCPBackendPreferences,
+    AliceBobBackendPreferences,
 ]
 
 __all__ = [
@@ -230,6 +245,8 @@ __all__ = [
     "IonqBackendNames",
     "ClassiqNvidiaBackendNames",
     "GCPBackendPreferences",
+    "AliceBobBackendPreferences",
+    "AliceBobBackendNames",
 ]
 
 

classiq/interface/backend/pydantic_backend.py

@@ -6,7 +6,9 @@ import pydantic
 AZURE_QUANTUM_RESOURCE_ID_REGEX = r"^/subscriptions/([a-fA-F0-9-]*)/resourceGroups/([^\s/]*)/providers/Microsoft\.Quantum/Workspaces/([^\s/]*)$"
 
 _IONQ_API_KEY_LENGTH: int = 32
+_ALICE_BOB_API_KEY_LENGTH: int = 72
 INVALID_API_KEY: str = _IONQ_API_KEY_LENGTH * "a"
+INVALID_API_KEY_ALICE_BOB: str = _ALICE_BOB_API_KEY_LENGTH * "a"
 MAX_EXECUTION_TIMEOUT_SECONDS = timedelta(hours=4).total_seconds()
 
 if TYPE_CHECKING:
@@ -18,6 +20,7 @@ if TYPE_CHECKING:
     PydanticIonQApiKeyType = str
     PydanticArgumentNameType = str
     PydanticExecutionParameter = str
+    PydanticAliceBobApiKeyType = str
 else:
     # TODO Simplify regular expressions in this file
 
@@ -32,6 +35,11 @@ else:
     PydanticIonQApiKeyType = pydantic.constr(
         regex=f"[A-Za-z0-9]{{{_IONQ_API_KEY_LENGTH}}}"
     )
+
+    PydanticAliceBobApiKeyType = pydantic.constr(
+        regex=f"[A-Za-z0-9]{{{_ALICE_BOB_API_KEY_LENGTH}}}"
+    )
+
     PydanticExecutionTimeout = pydantic.conint(gt=0, le=MAX_EXECUTION_TIMEOUT_SECONDS)
 
     PydanticArgumentNameType = pydantic.constr(regex="[_a-zA-Z][_a-zA-Z0-9]*")

classiq/interface/backend/quantum_backend_providers.py

@@ -16,6 +16,8 @@ class ProviderVendor(StrEnum):
     AMAZON_BRAKET = "Amazon Braket"
     IONQ = "IonQ"
     GOOGLE = "Google"
+    ALICE_AND_BOB = "Alice and Bob"
+    OQC = "OQC"
 
 
 class ProviderTypeVendor:
@@ -25,6 +27,8 @@ class ProviderTypeVendor:
     AMAZON_BRAKET = Literal[ProviderVendor.AMAZON_BRAKET]
     IONQ = Literal[ProviderVendor.IONQ]
     GOOGLE = Literal[ProviderVendor.GOOGLE]
+    ALICE_BOB = Literal[ProviderVendor.ALICE_AND_BOB]
+    OQC = Literal[ProviderVendor.OQC]
 
 
 class ClassiqAerBackendNames(StrEnum):
@@ -143,6 +147,17 @@ class GoogleNvidiaBackendNames(StrEnum):
     CUQUANTUM = "cuquantum"
 
 
+class AliceBobBackendNames(StrEnum):
+    PHYSICAL_CATS_40 = "EMU:40Q:PHYSICAL_CATS"
+    PERFECT_QUBITS = "EMU:20Q:PERFECT_QUBITS"
+    LOGICAL_TARGET = "EMU:40Q:LOGICAL_TARGET"
+    PHYSICAL_CATS_6 = "EMU:6Q:PHYSICAL_CATS"
+    LOGICAL_EARLY = "EMU:15Q:LOGICAL_EARLY"
+    LESCANNE = "EMU:1Q:LESCANNE_2020"
+    TRANSMONS = "EMU:7Q:TRANSMONS"
+    FATCAT = "QPU:1Q:FATCAT_0"
+
+
 EXACT_SIMULATORS = {
     IonqBackendNames.SIMULATOR,
     AzureQuantumBackendNames.IONQ_SIMULATOR,
@@ -156,7 +171,6 @@ EXACT_SIMULATORS = {
 
 AllIBMQBackendNames = IBMQHardwareNames
 
-
 AllBackendsNameByVendor = Union[
     AllIBMQBackendNames,
     AzureQuantumBackendNames,

classiq/interface/chemistry/ground_state_problem.py

@@ -64,7 +64,7 @@ class GroundStateProblem(HashablePydanticBaseModel):
 
 
 class MoleculeProblem(GroundStateProblem):
-    molecule: Molecule = pydantic.Field(remove_hierarchy=True)
+    molecule: Molecule
     basis: str = pydantic.Field(default="sto3g", description="Molecular basis set")
     freeze_core: bool = pydantic.Field(default=False)
     remove_orbitals: List[int] = pydantic.Field(