classiq 0.64.0__py3-none-any.whl → 0.65.1__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -22,6 +22,7 @@ from classiq.interface.execution.jobs import (
     ExecutionJobDetailsV1,
     ExecutionJobsQueryResultsV1,
 )
+from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import execution_request
 from classiq.interface.generator import quantum_program as generator_result
 from classiq.interface.hardware import HardwareInformation, Provider
@@ -120,6 +121,35 @@ class ApiWrapper:
         )
         return _parse_job_response(result, generator_result.QuantumProgram)
 
+    @classmethod
+    async def call_create_execution_session(
+        cls,
+        circuit: generator_result.QuantumProgram,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> str:
+        raw_result = await cls._call_task_pydantic(
+            http_method=HTTPMethod.POST,
+            url=routes.EXECUTION_SESSIONS_PREFIX,
+            model=circuit,
+            http_client=http_client,
+        )
+        return raw_result["id"]
+
+    @classmethod
+    async def call_create_session_job(
+        cls,
+        session_id: str,
+        primitives_input: PrimitivesInput,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> execution_request.ExecutionJobDetails:
+        data = await cls._call_task_pydantic(
+            http_method=HTTPMethod.POST,
+            url=routes.EXECUTION_SESSIONS_PREFIX + f"/{session_id}",
+            model=primitives_input,
+            http_client=http_client,
+        )
+        return execution_request.ExecutionJobDetails.model_validate(data)
+
     @classmethod
     async def call_convert_quantum_program(
         cls,

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -7,6 +7,8 @@ from classiq.interface.chemistry.fermionic_operator import (
     FermionicOperator,
     SummedFermionicOperator,
 )
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.qmod.builtins.structs import (
     MoleculeProblem as QmodMoleculeProblem,
     Molecule as QmodMolecule,
@@ -441,16 +443,13 @@ def _get_chemistry_quantum_main(
     use_hartree_fock: bool,
     ansatz_parameters: AnsatzParameters,
 ) -> NativeFunctionDefinition:
-    body = []
+    body: list[QuantumStatement] = []
     body.append(
-        QuantumFunctionCall(
-            function="allocate",
-            positional_args=[
-                Expression(
-                    expr=f"get_field(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'), 'len')"
-                ),
-                HandleBinding(name="qbv"),
-            ],
+        Allocate(
+            size=Expression(
+                expr=f"get_field(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'), 'len')"
+            ),
+            target=HandleBinding(name="qbv"),
         ),
     )
     if use_hartree_fock:

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -14,6 +14,7 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -89,12 +90,9 @@ def construct_combi_opt_py_model(
                     ),
                 ],
                 body=[
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr="get_field(target, 'len')"),
-                            HandleBinding(name="target"),
-                        ],
+                    Allocate(
+                        size=Expression(expr="get_field(target, 'len')"),
+                        target=HandleBinding(name="target"),
                     ),
                     QuantumFunctionCall(
                         function="qaoa_penalty",

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -21,11 +21,8 @@ from classiq.open_library.functions.utility_functions import (
     apply_to_all,
     hadamard_transform,
 )
-from classiq.qmod.builtins.functions import (
-    RX,
-    allocate,
-)
-from classiq.qmod.builtins.operations import phase, repeat
+from classiq.qmod.builtins.functions import RX
+from classiq.qmod.builtins.operations import allocate, phase, repeat
 from classiq.qmod.cparam import CReal
 from classiq.qmod.create_model_function import create_model
 from classiq.qmod.qfunc import qfunc

classiq/applications/finance/finance_model_constructor.py

@@ -9,6 +9,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
@@ -78,19 +79,13 @@ def construct_finance_model(
                 ],
                 body=[
                     VariableDeclarationStatement(name="unitary_port"),
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr=f"{num_unitary_qubits}"),
-                            HandleBinding(name="unitary_port"),
-                        ],
+                    Allocate(
+                        size=Expression(expr=f"{num_unitary_qubits}"),
+                        target=HandleBinding(name="unitary_port"),
                     ),
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr=f"{phase_port_size}"),
-                            HandleBinding(name="phase_port"),
-                        ],
+                    Allocate(
+                        size=Expression(expr=f"{phase_port_size}"),
+                        target=HandleBinding(name="phase_port"),
                     ),
                     QuantumFunctionCall(
                         function="qmci",

classiq/applications/grover/grover_model_constructor.py

@@ -2,6 +2,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
 from classiq.interface.model.model import Model, SerializedModel
@@ -121,12 +122,9 @@ def construct_grover_model(
                 ),
                 body=[
                     VariableDeclarationStatement(name="packed_vars"),
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr=f"{num_qubits}"),
-                            HandleBinding(name="packed_vars"),
-                        ],
+                    Allocate(
+                        size=Expression(expr=f"{num_qubits}"),
+                        target=HandleBinding(name="packed_vars"),
                     ),
                     QuantumFunctionCall(
                         function="grover_search",

classiq/applications/qsvm/qsvm_model_constructor.py

@@ -6,11 +6,13 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.qmod.builtins.enums import Pauli, QSVMFeatureMapEntanglement
 from classiq.qmod.utilities import qmod_val_to_expr_str
@@ -61,7 +63,7 @@ def _pauli_feature_map_function_params(
 
 def get_qsvm_qmain_body(
     feature_map_function_name: str, **kwargs: Any
-) -> list[QuantumFunctionCall]:
+) -> list[QuantumStatement]:
     if feature_map_function_name == "bloch_sphere_feature_map":
         params, size_expr = _bloch_sphere_feature_map_function_params(**kwargs)
     elif feature_map_function_name == "pauli_feature_map":
@@ -70,9 +72,9 @@ def get_qsvm_qmain_body(
         raise ClassiqValueError(INVALID_FEATURE_MAP_FUNC_NAME_MSG)
 
     return [
-        QuantumFunctionCall(
-            function="allocate",
-            positional_args=[Expression(expr=size_expr), HandleBinding(name="qbv")],
+        Allocate(
+            size=Expression(expr=size_expr),
+            target=HandleBinding(name="qbv"),
         ),
         QuantumFunctionCall(
             function=feature_map_function_name,

classiq/execution/execution_session.py

@@ -1,6 +1,5 @@
 import json
 import random
-from functools import cached_property
 from types import TracebackType
 from typing import Callable, Optional, Union, cast
 
@@ -110,6 +109,8 @@ class ExecutionSession:
 
         self._async_client = client().async_client()
 
+        self._session_id: str | None = None
+
     def __enter__(self) -> "ExecutionSession":
         return self
 
@@ -127,22 +128,22 @@ class ExecutionSession:
         """
         async_utils.run(self._async_client.aclose())
 
-    @cached_property
-    def _execution_input(self) -> dict:
-        return async_utils.run(
-            ApiWrapper.call_convert_quantum_program(self.program, self._async_client)
-        )
+    def get_session_id(self) -> str:
+        if self._session_id is None:
+            self._session_id = async_utils.run(
+                ApiWrapper.call_create_execution_session(
+                    self.program, self._async_client
+                )
+            )
+        return self._session_id
 
     def _execute(self, primitives_input: PrimitivesInput) -> ExecutionJob:
         primitives_input.random_seed = self._random_seed
         self._random_seed = self._rng.randint(0, 2**32 - 1)
-        execution_input = self._execution_input.copy()
-        # The use of `model_dump_json` is necessary for complex numbers serialization
-        execution_input["primitives_input"] = json.loads(
-            primitives_input.model_dump_json()
-        )
         result = async_utils.run(
-            ApiWrapper.call_execute_execution_input(execution_input, self._async_client)
+            ApiWrapper.call_create_session_job(
+                self.get_session_id(), primitives_input, self._async_client
+            )
         )
         return ExecutionJob(details=result)
 
@@ -360,7 +361,7 @@ class ExecutionSession:
             output_name: The name of the register to filter
             condition: Filter out values of the statevector for which this callable is False
         """
-        if "_execution_input" in self.__dict__:
+        if self._session_id is not None:
             raise ClassiqError(
                 "set_measured_state_filter must be called before use of the first primitive (sample, estimate...)"
             )

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

classiq/interface/backend/backend_preferences.py

@@ -22,7 +22,7 @@ from classiq.interface.backend.quantum_backend_providers import (
     ProviderTypeVendor,
     ProviderVendor,
 )
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning
 from classiq.interface.hardware import Provider
 
 
@@ -225,14 +225,6 @@ class AwsBackendPreferences(BackendPreferences):
         description="Run through Classiq's credentials while using user's allocated budget.",
     )
 
-    @pydantic.field_validator("s3_bucket_name", mode="before")
-    @classmethod
-    def _validate_s3_bucket_name(cls, s3_bucket_name: str) -> str:
-        s3_bucket_name = s3_bucket_name.strip()
-        if not s3_bucket_name.startswith("amazon-braket-"):
-            raise ClassiqValueError('S3 bucket name should start with "amazon-braket-"')
-        return s3_bucket_name
-
 
 class IBMBackendProvider(BaseModel):
     """

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -3,7 +3,10 @@ from typing import TYPE_CHECKING, Any, Union
 
 from sympy import Integer
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+    ClassiqValueError,
+)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
@@ -18,12 +21,7 @@ if TYPE_CHECKING:
 
 
 ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
-SLICE_OUT_OF_BOUNDS_MSG = "Slice indices out of bounds"
-SUBSCRIPT_OUT_OF_BOUNDS_MSG = "Subscript index out of bounds"
 ILLEGAL_SLICE_MSG = "Quantum array slice must be of the form [<int-value>:<int-value>]."
-ILLEGAL_SLICE_BOUNDS_MSG = (
-    "The quantum array slice start value ({}) must be lower than its stop value ({})."
-)
 
 
 class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
@@ -48,7 +46,7 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
         if isinstance(index, Integer):
             index = int(index)
         if index < 0 or index >= self._length:
-            raise ClassiqValueError(SUBSCRIPT_OUT_OF_BOUNDS_MSG)
+            raise ClassiqInternalExpansionError
 
         return self._element_type.get_proxy(
             SubscriptHandleBinding(
@@ -66,12 +64,12 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
             slice_ = slice(slice_.start, int(slice_.stop))
         if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
             raise ClassiqValueError(ILLEGAL_SLICE_MSG)
-        if slice_.start >= slice_.stop:
-            raise ClassiqValueError(
-                ILLEGAL_SLICE_BOUNDS_MSG.format(slice_.start, slice_.stop)
-            )
-        if slice_.start < 0 or slice_.stop > self._length:
-            raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
+        if (
+            slice_.start >= slice_.stop
+            or slice_.start < 0
+            or slice_.stop > self._length
+        ):
+            raise ClassiqInternalExpansionError
 
         return QmodQArrayProxy(
             SlicedHandleBinding(

classiq/interface/generator/functions/type_name.py

@@ -75,6 +75,12 @@ class TypeName(ClassicalType, QuantumType):
             field_type.is_instantiated for field_type in self.fields.values()
         )
 
+    @property
+    def is_evaluated(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_evaluated for field_type in self.fields.values()
+        )
+
 
 class Enum(TypeName):
     pass

classiq/interface/model/allocate.py

@@ -0,0 +1,16 @@
+from collections.abc import Mapping
+from typing import Literal, Optional
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+
+class Allocate(QuantumOperation):
+    kind: Literal["Allocate"]
+    size: Optional[Expression] = None
+    target: ConcreteHandleBinding
+
+    @property
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
+        return {"out": self.target}

classiq/interface/model/quantum_type.py

@@ -63,6 +63,10 @@ class QuantumType(HashableASTNode):
     def is_instantiated(self) -> bool:
         raise NotImplementedError
 
+    @property
+    def is_evaluated(self) -> bool:
+        raise NotImplementedError
+
 
 class QuantumScalar(QuantumType):
     def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
@@ -96,6 +100,10 @@ class QuantumBit(QuantumScalar):
     def is_instantiated(self) -> bool:
         return True
 
+    @property
+    def is_evaluated(self) -> bool:
+        return True
+
 
 class QuantumBitvector(QuantumType):
     element_type: "ConcreteQuantumType" = Field(
@@ -154,6 +162,14 @@ class QuantumBitvector(QuantumType):
     def is_instantiated(self) -> bool:
         return self.length is not None and self.element_type.is_instantiated
 
+    @property
+    def is_evaluated(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.element_type.is_evaluated
+        )
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -227,6 +243,16 @@ class QuantumNumeric(QuantumScalar):
     def is_instantiated(self) -> bool:
         return self.size is not None
 
+    @property
+    def is_evaluated(self) -> bool:
+        if self.size is None or not self.size.is_evaluated():
+            return False
+        if self.is_signed is not None and not self.is_signed.is_evaluated():
+            return False
+        return not (
+            self.fraction_digits is not None and not self.fraction_digits.is_evaluated()
+        )
+
 
 class RegisterQuantumType(BaseModel):
     quantum_types: "ConcreteQuantumType"

classiq/interface/model/statement_block.py

@@ -2,6 +2,7 @@ from typing import Annotated, Union
 
 from pydantic import Field
 
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -26,6 +27,7 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 ConcreteQuantumStatement = Annotated[
     Union[
+        Allocate,
         QuantumFunctionCall,
         ArithmeticOperation,
         AmplitudeLoadingOperation,

classiq/interface/server/routes.py

@@ -1,6 +1,7 @@
 ANALYZER_PREFIX = "/analyzer"
 CHEMISTRY_PREFIX = "/chemistry"
 EXECUTION_PREFIX = "/execution"
+EXECUTION_SESSIONS_PREFIX = EXECUTION_PREFIX + "/sessions"
 CONVERSION_PREFIX = "/conversion"
 PROVIDERS_PREFIX = "/providers"
 

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -1,3 +1,4 @@
+from collections.abc import Sequence
 from typing import Optional
 
 from classiq.interface.exceptions import (
@@ -11,6 +12,8 @@ from classiq.interface.generator.functions.type_name import (
 )
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.inplace_binary_operation import BinaryOperation
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
@@ -227,3 +230,10 @@ def get_inplace_op_scalar_as_numeric(
             fraction_digits=Expression(expr="0"),
         )
     raise ClassiqInternalExpansionError(f"Unexpected scalar type {var.quantum_type}")
+
+
+def is_signature_monomorphic(params: Sequence[PositionalArg]) -> bool:
+    return all(
+        isinstance(param, PortDeclaration) and param.quantum_type.is_evaluated
+        for param in params
+    )

classiq/model_expansions/function_builder.py

@@ -29,7 +29,14 @@ from classiq.model_expansions.capturing.captured_vars import (
     CapturedVars,
     validate_captured_directions,
 )
-from classiq.model_expansions.closure import Closure, FunctionClosure
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+    GenerativeFunctionClosure,
+)
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    is_signature_monomorphic,
+)
 from classiq.model_expansions.scope import Scope
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
@@ -200,16 +207,7 @@ class OperationBuilder:
     def create_definition(
         self, function_context: FunctionContext
     ) -> NativeFunctionDefinition:
-        name = function_context.name
-        if name != MAIN_FUNCTION_NAME:
-            for _ in self.current_scope:
-                name = self._counted_name_allocator.allocate(
-                    f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}"
-                )
-                if name not in self.current_scope:
-                    break
-            else:
-                raise ClassiqInternalExpansionError("Could not allocate function name")
+        name = self._get_expanded_function_name(function_context)
         new_parameters: list[PortDeclaration] = [
             param
             for param in function_context.positional_arg_declarations
@@ -221,3 +219,29 @@ class OperationBuilder:
             body=function_context.body,
             positional_arg_declarations=new_parameters,
         )
+
+    def _get_expanded_function_name(self, function_context: FunctionContext) -> str:
+        name = function_context.name
+
+        if name == MAIN_FUNCTION_NAME:
+            return name
+
+        if name in self.current_scope:
+            orig_func = self.current_scope[name].value
+            if (
+                isinstance(orig_func, FunctionClosure)
+                and not isinstance(orig_func, GenerativeFunctionClosure)
+                and is_signature_monomorphic(orig_func.positional_arg_declarations)
+            ):
+                return name
+
+        for _ in self.current_scope:
+            name = self._counted_name_allocator.allocate(
+                f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}"
+            )
+            if name not in self.current_scope:
+                break
+        else:
+            raise ClassiqInternalExpansionError("Could not allocate function name")
+
+        return name

classiq/model_expansions/generative_functions.py

@@ -30,11 +30,13 @@ from classiq.qmod.quantum_expandable import (
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
-from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
+from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
 
 
 class LenList(list):
@@ -94,7 +96,7 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
 
 
 class _InterpreterExpandable(QFunc):
-    def __init__(self, interpreter: "BaseInterpreter"):
+    def __init__(self, interpreter: "GenerativeInterpreter"):
         super().__init__(lambda: None)
         self._interpreter = interpreter
 
@@ -137,7 +139,7 @@ class _InterpreterExpandable(QFunc):
 
 
 def emit_generative_statements(
-    interpreter: "BaseInterpreter",
+    interpreter: "GenerativeInterpreter",
     operation: GenerativeClosure,
     args: list[Evaluated],
 ) -> None: