classiq 0.36.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

classiq/execution/jobs.py

@@ -7,9 +7,9 @@ from classiq.interface.execution.jobs import ExecutionJobDetailsV1
 from classiq.interface.executor.execution_request import ExecutionJobDetails
 from classiq.interface.executor.execution_result import ResultsCollection
 from classiq.interface.jobs import JobStatus, JSONObject
-from classiq.interface.server.routes import EXECUTION_JOBS_FULL_PATH
+from classiq.interface.server.routes import EXECUTION_JOBS_NON_VERSIONED_FULL_PATH
 
-from classiq._internals.api_wrapper import ApiWrapper
+from classiq._internals.api_wrapper import CLASSIQ_ACCEPT_HEADER, ApiWrapper
 from classiq._internals.async_utils import syncify_function
 from classiq._internals.client import client
 from classiq._internals.jobs import JobID, JobPoller
@@ -17,6 +17,9 @@ from classiq.exceptions import ClassiqAPIError
 
 _JobDetails = Union[ExecutionJobDetails, ExecutionJobDetailsV1]
 
+_JOB_DETAILS_VERSION = "v1"
+_JOB_RESULT_VERSION = "v1"
+
 
 class ExecutionJob:
     _details: _JobDetails
@@ -98,7 +101,9 @@ class ExecutionJob:
 
         if self._result is None:
             self._result = (
-                await ApiWrapper.call_get_execution_job_result(self._job_id)
+                await ApiWrapper.call_get_execution_job_result(
+                    job_id=self._job_id, version=_JOB_RESULT_VERSION
+                )
             ).results
         return self._result
 
@@ -117,7 +122,11 @@ class ExecutionJob:
                 return True
             return None
 
-        poller = JobPoller(base_url=EXECUTION_JOBS_FULL_PATH)
+        poller = JobPoller(
+            base_url=EXECUTION_JOBS_NON_VERSIONED_FULL_PATH,
+            use_versioned_url=False,
+            additional_headers={CLASSIQ_ACCEPT_HEADER: _JOB_DETAILS_VERSION},
+        )
         await poller.poll(
             job_id=self._job_id,
             response_parser=response_parser,

classiq/executor.py

@@ -1,4 +1,5 @@
 """Executor module, implementing facilities for executing quantum programs using Classiq platform."""
+
 import functools
 from typing import Optional, Tuple, Union
 
@@ -32,8 +33,8 @@ from classiq.synthesis import SerializedQuantumProgram
 
 BatchExecutionResult: TypeAlias = Union[ExecutionDetails, BaseException]
 ProgramAndResult: TypeAlias = Tuple[QuantumProgram, BatchExecutionResult]
-BackendPreferencesProgramAndResult: TypeAlias = Tuple[
-    BackendPreferencesTypes, QuantumProgram, BatchExecutionResult
+BackendPreferencesAndResult: TypeAlias = Tuple[
+    BackendPreferencesTypes, int, BatchExecutionResult
 ]
 _MAX_ARGUMENTS_SIZE = 1024
 

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.36.0'
+SEMVER_VERSION = '0.37.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/analysis_params.py

@@ -51,12 +51,6 @@ class AnalysisHardwareListParams(AnalysisParams, HardwareListParams):
     transpilation_params: AnalysisHardwareTranspilationParams
 
 
-class ResourceEstimatorParams(pydantic.BaseModel):
-    circuit_id: str
-    error_budget: float
-    physical_error_rate: float
-
-
 class HardwareParams(pydantic.BaseModel):
     device: PydanticNonEmptyString = pydantic.Field(default=None, description="Devices")
     provider: AnalyzerProviderVendor

classiq/interface/analyzer/result.py

@@ -136,10 +136,6 @@ class DevicesResult(VersionedModel):
     status: GraphStatus
 
 
-class ResourceEstimatorResult(VersionedModel):
-    report_json: str
-
-
 class QuantumCircuitProperties(pydantic.BaseModel):
     depth: pydantic.NonNegativeInt = pydantic.Field(
         default=..., description="Circuit depth"

classiq/interface/backend/backend_preferences.py

@@ -204,8 +204,8 @@ class GCPBackendPreferences(BackendPreferences):
 
 class OQCBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.OQC
-    oqc_email: str = pydantic.Field(description="OQC Email")
-    oqc_password: str = pydantic.Field(description="OQC email password")
+    username: str = pydantic.Field(description="OQC username")
+    password: str = pydantic.Field(description="OQC password")
 
     @pydantic.root_validator(pre=True)
     def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:

classiq/interface/backend/quantum_backend_providers.py

@@ -16,7 +16,7 @@ class ProviderVendor(StrEnum):
     AMAZON_BRAKET = "Amazon Braket"
     IONQ = "IonQ"
     GOOGLE = "Google"
-    ALICE_AND_BOB = "Alice and Bob"
+    ALICE_AND_BOB = "Alice & Bob"
     OQC = "OQC"
 
 

classiq/interface/execution/resource_estimator.py

@@ -0,0 +1,7 @@
+import pydantic
+
+
+class ResourceEstimatorParams(pydantic.BaseModel):
+    circuit_id: str
+    error_budget: float
+    physical_error_rate: float

classiq/interface/execution/result.py

@@ -0,0 +1,5 @@
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+
+class ResourceEstimatorResult(VersionedModel):
+    report_json: str

classiq/interface/executor/register_initialization.py

@@ -30,7 +30,9 @@ class RegisterInitialization(pydantic.BaseModel):
         initial_condition: int = values.get("initial_condition", 0)
         name: str = values.get("name", "")
 
-        initial_condition_length = number_utils.size(initial_condition)
+        initial_condition_length = number_utils.size(
+            initial_condition, machine_precision=number_utils.MAX_FRACTION_PLACES
+        )
         register_length = len(qubits)
         if initial_condition_length > register_length:
             raise ClassiqStateInitializationError(

classiq/interface/executor/vqe_result.py

@@ -51,6 +51,7 @@ class VQEIntermediateData(BaseModel):
 
 class VQESolverResult(SolverResult, QmodPyObject):
     eigenstate: Dict[str, Complex]
+    reduced_probabilities: Optional[Dict[str, float]] = None
     optimized_circuit_sample_results: ExecutionDetails
     intermediate_results: List[VQEIntermediateData]
     optimal_parameters: Dict[str, float]

classiq/interface/generator/ansatz_library.py

@@ -52,9 +52,9 @@ class RandomTwoQubitGatesArgs(CustomAnsatzArgs):
 
 
 class TwoLocalArgs(CustomAnsatzArgs):
-    rotation_blocks: Optional[
-        Union[RotationBlocksType, List[RotationBlocksType]]
-    ] = RotationBlocksType.ry
+    rotation_blocks: Optional[Union[RotationBlocksType, List[RotationBlocksType]]] = (
+        RotationBlocksType.ry
+    )
     entanglement_blocks: Optional[
         Union[EntanglementBlocksType, List[EntanglementBlocksType]]
     ] = EntanglementBlocksType.cx

classiq/interface/generator/arith/argument_utils.py

@@ -6,10 +6,10 @@ from classiq.interface.generator.arith.register_user_input import RegisterArithm
 RegisterOrConst = Union[RegisterArithmeticInfo, float]
 
 
-def fraction_places(argument: RegisterOrConst) -> int:
+def fraction_places(argument: RegisterOrConst, *, machine_precision: int) -> int:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.fraction_places
-    return number_utils.fraction_places(argument)
+    return number_utils.fraction_places(argument, machine_precision=machine_precision)
 
 
 def integer_part_size(argument: RegisterOrConst) -> int:
@@ -18,10 +18,10 @@ def integer_part_size(argument: RegisterOrConst) -> int:
     return number_utils.integer_part_size(argument)
 
 
-def size(argument: RegisterOrConst) -> int:
+def size(argument: RegisterOrConst, *, machine_precision: int) -> int:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.size
-    return number_utils.size(argument)
+    return number_utils.size(argument, machine_precision=machine_precision)
 
 
 def is_signed(argument: RegisterOrConst) -> bool:

classiq/interface/generator/arith/arithmetic.py

@@ -75,6 +75,7 @@ class Arithmetic(ArithmeticExpressionABC):
 def get_arithmetic_params(
     expr_str: str,
     var_types: Dict[str, QuantumType],
+    machine_precision: int,
     enable_target: bool = False,
 ) -> Arithmetic:
     return Arithmetic(
@@ -86,13 +87,14 @@ def get_arithmetic_params(
         inputs_to_save=set(var_types.keys()),
         # FIXME: generalize inout target to multiple qubits
         target=RegisterArithmeticInfo(size=1) if enable_target else None,
+        machine_precision=machine_precision,
     )
 
 
 def compute_arithmetic_result_type(
-    expr_str: str, var_types: Dict[str, QuantumType]
+    expr_str: str, var_types: Dict[str, QuantumType], machine_precision: int
 ) -> QuantumType:
-    arith_param = get_arithmetic_params(expr_str, var_types)
+    arith_param = get_arithmetic_params(expr_str, var_types, machine_precision)
     return register_info_to_quantum_type(
         arith_param.outputs[ARITHMETIC_EXPRESSION_RESULT_NAME]
     )

classiq/interface/generator/arith/arithmetic_arg_type_validator.py

@@ -10,11 +10,15 @@ from classiq.interface.generator.arith.binary_ops import BOOLEAN_OP_WITH_FRACTIO
 
 from classiq.exceptions import ClassiqArithmeticError
 
-ArgTypeValidator: TypeAlias = Callable[[List[RegisterOrConst]], None]
+ArgTypeValidator: TypeAlias = Callable[[List[RegisterOrConst], int], None]
 
 
-def _validate_bitwise_op_args(args: List[RegisterOrConst]) -> None:
-    if any(fraction_places(arg) > 0 for arg in args):
+def _validate_bitwise_op_args(
+    args: List[RegisterOrConst], machine_precision: int
+) -> None:
+    if any(
+        fraction_places(arg, machine_precision=machine_precision) > 0 for arg in args
+    ):
         raise ClassiqArithmeticError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
 
 
@@ -25,7 +29,9 @@ arg_type_validator_map: Dict[str, ArgTypeValidator] = dict(
 )
 
 
-def validate_operation_arg_types(operation: str, args: List[RegisterOrConst]) -> None:
+def validate_operation_arg_types(
+    operation: str, args: List[RegisterOrConst], machine_precision: int
+) -> None:
     if operation not in arg_type_validator_map:
         return
-    arg_type_validator_map[operation](args)
+    arg_type_validator_map[operation](args, machine_precision)

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -18,7 +18,8 @@ from classiq.interface.generator.arith.ast_node_rewrite import (
 
 from classiq.exceptions import ClassiqArithmeticError
 
-_ILLEGAL_PARSED_GRAPH_ERROR_MESSAGE: str = "parsed graph contains multiple result nodes"
+_MULTIPLE_RESULTS_ERROR_MESSAGE: str = "Expression cannot contain multiple result"
+_TRIVIAL_ARITHMETIC_ERROR_MESSAGE: str = "Expression must be nontrivial"
 _ALLOWED_MULTI_ARGUMENT_FUNCTIONS = ("min", "max")
 Node = Union[str, float, int]
 
@@ -116,8 +117,12 @@ class InDegreeLimiter:
         for node in list(graph.nodes):
             if cls._condition(graph, node):
                 graph = cls._node_conversion(graph, node)
-        if num_of_result_nodes(graph) != 1:
-            raise ClassiqArithmeticError(_ILLEGAL_PARSED_GRAPH_ERROR_MESSAGE)
+
+        num_results = sum(int(graph.out_degree(node) == 0) for node in graph.nodes)
+        if num_results > 1:
+            raise ClassiqArithmeticError(_MULTIPLE_RESULTS_ERROR_MESSAGE)
+        elif num_results == 0:
+            raise ClassiqArithmeticError(_TRIVIAL_ARITHMETIC_ERROR_MESSAGE)
         return graph
 
 
@@ -134,7 +139,3 @@ def parse_expression(
     visitor.validate(expression)
     InDegreeLimiter.graph_conversion(graph=visitor.graph)
     return visitor.graph
-
-
-def num_of_result_nodes(graph: nx.DiGraph) -> int:
-    return sum(int(graph.out_degree(node) == 0) for node in graph.nodes)

classiq/interface/generator/arith/arithmetic_operations.py

@@ -5,6 +5,7 @@ from typing import ClassVar, Iterable, Optional, Tuple
 
 import pydantic
 
+from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import FunctionParams
 
@@ -13,6 +14,7 @@ DEFAULT_GARBAGE_OUT_NAME: str = "extra_qubits"
 
 class ArithmeticOperationParams(FunctionParams):
     output_size: Optional[pydantic.PositiveInt]
+    machine_precision: pydantic.PositiveInt = number_utils.MAX_FRACTION_PLACES
     output_name: ClassVar[str]
     garbage_output_name: ClassVar[str] = DEFAULT_GARBAGE_OUT_NAME
     _result_register: Optional[RegisterArithmeticInfo] = pydantic.PrivateAttr(
@@ -44,6 +46,11 @@ class ArithmeticOperationParams(FunctionParams):
             return suggested_bounds
         return None
 
+    def _compute_fraction_places(self, argument: argument_utils.RegisterOrConst) -> int:
+        return argument_utils.fraction_places(
+            argument, machine_precision=self.machine_precision
+        )
+
     @abc.abstractmethod
     def get_params_inplace_options(self) -> Iterable[ArithmeticOperationParams]:
         pass