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

classiq/_internals/api_wrapper.py

@@ -7,6 +7,10 @@ import classiq.interface.pyomo_extension  # noqa: F401 - patches pyomo to add fe
 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
@@ -25,6 +29,7 @@ class HTTPMethod(StrEnum):
     # Partial backport from Python 3.11
     GET = "GET"
     POST = "POST"
+    PATCH = "PATCH"
 
 
 class StatusType(Protocol):
@@ -44,13 +49,19 @@ def _parse_job_response(
 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(
@@ -59,9 +70,14 @@ 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}")
@@ -108,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

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/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/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.34.0'
+SEMVER_VERSION = '0.35.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/quantum_backend_providers.py

@@ -17,6 +17,7 @@ class ProviderVendor(StrEnum):
     IONQ = "IonQ"
     GOOGLE = "Google"
     ALICE_AND_BOB = "Alice and Bob"
+    OQC = "OQC"
 
 
 class ProviderTypeVendor:
@@ -27,6 +28,7 @@ class ProviderTypeVendor:
     IONQ = Literal[ProviderVendor.IONQ]
     GOOGLE = Literal[ProviderVendor.GOOGLE]
     ALICE_BOB = Literal[ProviderVendor.ALICE_AND_BOB]
+    OQC = Literal[ProviderVendor.OQC]
 
 
 class ClassiqAerBackendNames(StrEnum):

classiq/interface/execution/jobs.py

@@ -0,0 +1,28 @@
+from datetime import datetime
+from typing import List, Optional
+
+from pydantic import BaseModel, Extra
+
+from classiq.interface.jobs import JobStatus
+
+
+class ExecutionJobDetailsV1(BaseModel, extra=Extra.ignore):
+    id: str
+
+    name: Optional[str]
+    start_time: datetime
+    end_time: Optional[datetime]
+
+    provider: Optional[str]
+    backend_name: Optional[str]
+
+    status: JobStatus
+
+    num_shots: Optional[int]
+    program_id: Optional[str]
+
+    error: Optional[str]
+
+
+class ExecutionJobsQueryResultsV1(BaseModel, extra=Extra.ignore):
+    results: List[ExecutionJobDetailsV1]

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -50,6 +50,7 @@ SupportedNodesTypes = Union[
     ast.RShift,
     ast.Call,
     ast.Mult,
+    ast.Pow,
 ]
 
 DEFAULT_SUPPORTED_NODE_TYPES = get_args(SupportedNodesTypes)

classiq/interface/generator/arith/arithmetic_param_getters.py

@@ -25,6 +25,7 @@ from classiq.interface.generator.arith.binary_ops import (
     Modulo,
     Multiplier,
     NotEqual,
+    Power,
     RegisterOrInt,
     RShift,
     Subtractor,
@@ -155,6 +156,16 @@ def multiplier_params_getter(
     return Multiplier(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
 
 
+def power_params_getter(
+    left_arg: RegisterArithmeticInfo,
+    right_arg: int,
+    output_size: Optional[int] = None,
+    inplace_arg: Optional[str] = None,
+    target: Optional[RegisterArithmeticInfo] = None,
+) -> ArithmeticOperationParams:
+    return Power(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
+
+
 def min_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
@@ -367,4 +378,5 @@ params_getter_map: Dict[str, ParamsGetter] = dict(
     Mod=modulo_params_getter,
     min=min_params_getter,
     max=max_params_getter,
+    Pow=power_params_getter,
 )

classiq/interface/generator/arith/binary_ops.py

@@ -413,6 +413,40 @@ class LessEqual(Comparator):
     output_name = "is_less_equal"
 
 
+class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
+    output_name = "powered"
+
+    @pydantic.validator("right_arg", pre=True)
+    def _validate_legal_power(cls, right_arg: Any) -> pydantic.PositiveInt:
+        if not float(right_arg).is_integer():
+            raise ValueError("Power must be an integer")
+        if right_arg <= 0:
+            raise ValueError("Power must be greater than one")
+        return int(right_arg)
+
+    def _get_result_bounds(self) -> Tuple[float, float]:
+        if (self.right_arg % 2) or min(self.left_arg.bounds) >= 0:
+            return (
+                self.left_arg.bounds[0] ** self.right_arg,
+                self.left_arg.bounds[1] ** self.right_arg,
+            )
+        return 0.0, max(abs(bound) for bound in self.left_arg.bounds) ** self.right_arg
+
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        if self.output_size:
+            return RegisterArithmeticInfo(size=self.output_size)
+
+        fraction_places: int = self.left_arg.fraction_places * self.right_arg
+        bounds = self._get_result_bounds()
+        size = number_utils.bounds_to_integer_part_size(*bounds) + fraction_places
+        return RegisterArithmeticInfo(
+            size=size,
+            is_signed=self.left_arg.is_signed and (self.right_arg % 2 == 1),
+            fraction_places=fraction_places,
+            bounds=bounds,
+        )
+
+
 class EffectiveUnaryOpParams(
     InplacableBinaryOpParams[RegisterArithmeticInfo, RightDataT], Generic[RightDataT]
 ):

classiq/interface/generator/expressions/expression.py

@@ -82,3 +82,6 @@ class Expression(HashablePydanticBaseModel):
 
     class Config:
         frozen = True
+
+    def __str__(self) -> str:
+        return self.expr

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -1,6 +1,16 @@
-class QmodSizedProxy:
-    def __init__(self, size: int) -> None:
+from sympy import Symbol
+
+
+class QmodSizedProxy(Symbol):
+    def __new__(cls, name, **assumptions):
+        return super().__new__(cls, name, **assumptions)
+
+    def __init__(self, name: str, size: int) -> None:
         self._size = size
 
+    @property
+    def size(self) -> int:
+        return self.args[0]
+
     def __len__(self) -> int:
         return self._size

classiq/interface/generator/function_param_list_without_self_reference.py

@@ -18,6 +18,7 @@ from classiq.interface.generator.arith.binary_ops import (
     Modulo,
     Multiplier,
     NotEqual,
+    Power,
     RShift,
     Subtractor,
 )
@@ -136,6 +137,7 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 WeightedAdder,
                 LinearPauliRotations,
                 Multiplier,
+                Power,
                 LinearGCI,
                 HartreeFock,
                 UCC,

classiq/interface/generator/function_params.py

@@ -102,6 +102,10 @@ GenerationOnlyExpressionSupportedNodeTypes = Union[
     ast.Slice,
     ast.keyword,
     ast.Attribute,
+    ast.BoolOp,
+    ast.Or,
+    ast.And,
+    ast.Not,
 ]
 
 GenerationExpressionSupportedNodeTypes = Union[

classiq/interface/generator/functions/core_lib_declarations/quantum_functions/std_lib_functions.py

@@ -34,6 +34,32 @@ QFT = QuantumFunctionDeclaration.parse_raw(
 }"""
 )
 
+STANDARD_QPE = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "standard_qpe",
+    "param_decls": {
+        "precision": {
+            "kind": "int"
+        }
+    },
+    "port_declarations": {
+        "phase": {
+            "name": "phase",
+            "size": {
+                "expr": "precision"
+            },
+            "direction": "inout"
+        }
+    },
+    "operand_declarations": {
+        "unitary": {
+            "name": "unitary"
+        }
+    },
+    "positional_arg_declarations": []
+}"""
+)
+
 QPE = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qpe",
@@ -660,6 +686,7 @@ FULL_HEA = QuantumFunctionDeclaration.parse_raw(
 __all__ = [
     "QFT_STEP",
     "QFT",
+    "STANDARD_QPE",
     "QPE",
     "SINGLE_PAULI",
     "LINEAR_PAULI_ROTATIONS",

classiq/interface/generator/model/preferences/preferences.py

@@ -65,6 +65,8 @@ class TranspilationOption(StrEnum):
     AUTO_OPTIMIZE = "auto optimize"
     LIGHT = "light"
     MEDIUM = "medium"
+    INTENSIVE = "intensive"
+    CUSTOM = "custom"
 
     def __bool__(self) -> bool:
         return self != TranspilationOption.NONE

classiq/interface/hardware.py

@@ -14,6 +14,7 @@ class Provider(StrEnum):
     CLASSIQ = "Classiq"
     GOOGLE = "Google"
     ALICE_AND_BOB = "Alice and Bob"
+    OQC = "OQC"
 
     @property
     def id(self):

classiq/interface/model/bind_operation.py

@@ -1,8 +1,12 @@
 from typing import Mapping
 
+import pydantic
+
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_statement import QuantumOperation
 
+from classiq.exceptions import ClassiqValueError
+
 BIND_INPUT_NAME = "bind_input"
 BIND_OUTPUT_NAME = "bind_output"
 
@@ -18,3 +22,9 @@ class BindOperation(QuantumOperation):
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return {BIND_OUTPUT_NAME: self.out_handle}
+
+    @pydantic.validator("in_handle", "out_handle")
+    def validate_handle(cls, handle: HandleBinding) -> HandleBinding:
+        if not handle.is_bindable():
+            raise ClassiqValueError(f"Cannot bind '{handle}'")  # noqa: B907
+        return handle

classiq/interface/model/handle_binding.py

@@ -10,6 +10,12 @@ class HandleBinding(BaseModel):
         frozen = True
         extra = Extra.forbid
 
+    def __str__(self) -> str:
+        return self.name
+
+    def is_bindable(self) -> bool:
+        return True
+
 
 class SubscriptHandleBinding(HandleBinding):
     index: Expression
@@ -18,6 +24,12 @@ class SubscriptHandleBinding(HandleBinding):
         frozen = True
         extra = Extra.forbid
 
+    def __str__(self) -> str:
+        return f"{self.name}[{self.index}]"
+
+    def is_bindable(self) -> bool:
+        return False
+
 
 class SlicedHandleBinding(HandleBinding):
     start: Expression
@@ -26,3 +38,9 @@ class SlicedHandleBinding(HandleBinding):
     class Config:
         frozen = True
         extra = Extra.forbid
+
+    def __str__(self) -> str:
+        return f"{self.name}[{self.start}:{self.end}]"
+
+    def is_bindable(self) -> bool:
+        return False

classiq/interface/model/model.py

@@ -54,8 +54,8 @@ TYPE_NAME_CONFLICT_USER = (
 )
 
 
-def _create_default_functions() -> List[NativeFunctionDefinition]:
-    return [NativeFunctionDefinition(name=MAIN_FUNCTION_NAME)]
+def _create_empty_main_function() -> NativeFunctionDefinition:
+    return NativeFunctionDefinition(name=MAIN_FUNCTION_NAME)
 
 
 class VersionedSerializedModel(VersionedModel):
@@ -71,7 +71,7 @@ class Model(VersionedModel):
 
     # Must be validated before logic_flow
     functions: List[NativeFunctionDefinition] = pydantic.Field(
-        default_factory=_create_default_functions,
+        default_factory=list,
         description="The user-defined custom type library.",
     )
 
@@ -119,6 +119,15 @@ class Model(VersionedModel):
     def function_dict(self) -> Dict[str, QuantumFunctionDeclaration]:
         return nameables_to_dict(self.functions)
 
+    @pydantic.validator("functions", always=True)
+    def _add_empty_main(
+        cls, functions: List[NativeFunctionDefinition]
+    ) -> List[NativeFunctionDefinition]:
+        function_dict = nameables_to_dict(functions)
+        if MAIN_FUNCTION_NAME not in function_dict:
+            functions.append(_create_empty_main_function())
+        return functions
+
     @pydantic.root_validator()
     def validate_static_correctness(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         functions: Optional[List[QuantumFunctionDeclaration]] = values.get("functions")

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -40,7 +40,8 @@ class AmplitudeLoadingOperation(QuantumExpressionOperation):
     ) -> Mapping[
         str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
     ]:
-        assert len(self.var_handles) > 0
+        if len(self.var_handles) == 0:
+            return dict()
         return {AMPLITUDE_IO_NAME: self.var_handles[0]}
 
     def initialize_var_types(self, var_types: Dict[str, QuantumType]) -> None:

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -24,7 +24,9 @@ class ArithmeticOperation(QuantumExpressionOperation):
 
     def initialize_var_types(self, var_types: Dict[str, QuantumType]) -> None:
         super().initialize_var_types(var_types)
-        self._result_type = compute_arithmetic_result_type(self.expr_str, var_types)
+        self._result_type = compute_arithmetic_result_type(
+            self.expression.expr, var_types
+        )
 
     @property
     def wiring_inouts(