classiq 0.56.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

classiq/analyzer/show_interactive_hack.py

@@ -10,7 +10,7 @@ from classiq._internals.async_utils import syncify_function
 from classiq.analyzer.url_utils import circuit_page_uri, client_ide_base_url
 
 
-async def handle_remote_app(circuit: QuantumProgram, dispaly_url: bool = False) -> None:
+async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -> None:
     if circuit.outputs.get(QuantumFormat.QASM) is None:
         raise ClassiqAnalyzerVisualizationError(
             "Missing QASM transpilation: visualization is only supported "
@@ -23,14 +23,26 @@ async def handle_remote_app(circuit: QuantumProgram, dispaly_url: bool = False)
         circuit_page_uri(circuit_id=circuit_dataid.id, circuit_version=circuit.version),
     )
 
-    if dispaly_url:
+    if display_url:
         print(f"Opening: {app_url}")  # noqa: T201
 
     webbrowser.open_new_tab(app_url)
 
 
-async def _show_interactive(self: QuantumProgram, dispaly_url: bool = False) -> None:
-    await handle_remote_app(self, dispaly_url)
+async def _show_interactive(self: QuantumProgram, display_url: bool = True) -> None:
+    """
+    Displays the interactive representation of the quantum program in the Classiq IDE.
+
+    Args:
+        self:
+            The serialized quantum program to be displayed.
+        display_url:
+            Whether to print the url
+
+    Links:
+        [Visualization tool](https://docs.classiq.io/latest/reference-manual/analyzer/quantum-program-visualization-tool/)
+    """
+    await handle_remote_app(self, display_url)
 
 
 QuantumProgram.show = syncify_function(_show_interactive)  # type: ignore[attr-defined]

classiq/executor.py

@@ -46,7 +46,7 @@ def execute(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
     Returns:
         ExecutionJob: The result of the execution.
 
-    For examples please see [Execution Documentation](https://docs.classiq.io/latest/user-guide/executor/)
+    For examples please see [Execution Documentation](https://docs.classiq.io/latest/user-guide/execution/)
     """
     return async_utils.run(execute_async(quantum_program))
 

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

classiq/interface/executor/execution_request.py

@@ -46,16 +46,16 @@ class QuantumProgramExecutionRequest(ExecutionRequest):
 class ExecutionJobDetails(VersionedModel):
     id: str
 
-    name: Optional[str]
+    name: Optional[str] = Field(default=None)
     start_time: datetime
-    end_time: Optional[datetime]
+    end_time: Optional[datetime] = Field(default=None)
 
-    provider: Optional[str]
-    backend_name: Optional[str]
+    provider: Optional[str] = Field(default=None)
+    backend_name: Optional[str] = Field(default=None)
 
     status: JobStatus
 
-    num_shots: Optional[int]
+    num_shots: Optional[int] = Field(default=None)
     program_id: Optional[str] = Field(default=None)
 
     error: Optional[str] = Field(default=None)

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -16,9 +16,6 @@ DEFAULT_SUPPORTED_FUNC_NAMES: set[str] = {"CLShift", "CRShift", "min", "max"}
 DEFAULT_EXPRESSION_TYPE = "arithmetic"
 IDENITIFIER_REGEX = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
 
-_REPEATED_VARIABLES_ERROR_MESSAGE: str = (
-    "Repeated variables in the beginning of an arithmetic expression are not allowed."
-)
 ValidKeyValuePairs: TypeAlias = dict[str, set[str]]
 
 SupportedNodesTypes = Union[
@@ -107,13 +104,25 @@ class ExpressionValidator(ast.NodeVisitor):
             raise ClassiqArithmeticError("Must call `validate` before getting ast_obj")
         return self._ast_obj
 
-    @staticmethod
-    def _check_repeated_variables(variables: tuple[Any, Any]) -> None:
+    def _check_repeated_variables(
+        self, variables: tuple[Any, Any], expr: ast.AST, error_suffix: str
+    ) -> None:
+        if (
+            isinstance(expr, ast.BinOp)
+            and isinstance(expr.op, ast.Pow)
+            and ast.Pow not in self.supported_nodes
+        ):
+            raise ClassiqValueError(
+                "Raising to a power (<var> ** <exp>) and multiplying a variable by "
+                "itself (<var> * <var>) are not supported"
+            )
         if (
             all(isinstance(var, ast.Name) for var in variables)
             and variables[0].id == variables[1].id
         ):
-            raise ClassiqValueError(_REPEATED_VARIABLES_ERROR_MESSAGE)
+            raise ClassiqValueError(
+                f"Expression {ast.unparse(expr)!r} is not supported ({error_suffix})"
+            )
 
     @staticmethod
     def _check_multiple_comparators(node: ast.Compare) -> None:
@@ -135,7 +144,11 @@ class ExpressionValidator(ast.NodeVisitor):
         )
 
     def validate_Compare(self, node: ast.Compare) -> None:  # noqa: N802
-        self._check_repeated_variables((node.left, node.comparators[0]))
+        self._check_repeated_variables(
+            (node.left, node.comparators[0]),
+            node,
+            "both sides of the comparison are identical",
+        )
         self._check_multiple_comparators(node)
 
     def visit_Compare(self, node: ast.Compare) -> None:
@@ -143,7 +156,9 @@ class ExpressionValidator(ast.NodeVisitor):
         self.generic_visit(node)
 
     def validate_BinOp(self, node: ast.BinOp) -> None:  # noqa: N802
-        self._check_repeated_variables((node.left, node.right))
+        self._check_repeated_variables(
+            (node.left, node.right), node, "both sides of the operation are identical"
+        )
 
     def visit_BinOp(self, node: ast.BinOp) -> None:
         self.validate_BinOp(node)
@@ -151,7 +166,11 @@ class ExpressionValidator(ast.NodeVisitor):
 
     def validate_Call(self, node: ast.Call) -> None:  # noqa: N802
         if len(node.args) >= 2:
-            self._check_repeated_variables((node.args[0], node.args[1]))
+            self._check_repeated_variables(
+                (node.args[0], node.args[1]),
+                node,
+                "the first two call arguments are identical",
+            )
         node_id = AstNodeRewrite().extract_node_id(node)
         if node_id not in self._supported_functions:
             raise ClassiqValueError(f"{node_id} not in supported functions")

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -1,5 +1,6 @@
 # This file was generated automatically - do not edit manually
 
+
 from enum import IntEnum
 
 

classiq/model_expansions/closure.py

@@ -21,6 +21,7 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
+    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -213,26 +214,43 @@ def _generate_arg_id(
     arg_name = arg_declaration.name
     if isinstance(arg_declaration, ClassicalParameterDeclaration):
         return {arg_name: evaluated_classical_param_to_str(arg_value)}
-    return {arg_name: _evaluated_arg_to_str(arg_value)}
+    if isinstance(arg_declaration, PortDeclaration):
+        return {arg_name: _evaluated_port_to_str(arg_value)}
+    if isinstance(arg_declaration, QuantumOperandDeclaration):
+        return {arg_name: _evaluated_operand_to_str(arg_value)}
 
 
-@singledispatch
 def _evaluated_arg_to_str(arg: Any) -> str:
     if isinstance(arg, str):
         return arg
     return str(uuid.uuid4())
 
 
-@_evaluated_arg_to_str.register
+@singledispatch
+def _evaluated_port_to_str(arg: Any) -> str:
+    return _evaluated_arg_to_str(arg)
+
+
+@_evaluated_port_to_str.register
 def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
     return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
 
 
-@_evaluated_arg_to_str.register
+@_evaluated_port_to_str.register
 def _evaluated_symbol_to_str(port: Symbol) -> str:
     return repr(port)
 
 
-@_evaluated_arg_to_str.register
-def _evaluated_operand_to_str(operand: FunctionClosure) -> str:
+@singledispatch
+def _evaluated_operand_to_str(arg: Any) -> str:
+    return _evaluated_arg_to_str(arg)
+
+
+@_evaluated_operand_to_str.register
+def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
     return operand.closure_id
+
+
+@_evaluated_operand_to_str.register
+def _evaluated_list_operands_to_str(operands: list) -> str:
+    return json.dumps([_evaluated_operand_to_str(ope) for ope in operands])

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -0,0 +1,207 @@
+from collections.abc import Sequence
+from typing import (
+    Generic,
+    cast,
+)
+
+from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.generator.generated_circuit_data import OperationLevel
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.capturing.propagated_var_stack import (
+    validate_args_are_not_propagated,
+)
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.evaluators.argument_types import (
+    add_information_from_output_arguments,
+)
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_parameter_types_from_args,
+)
+from classiq.model_expansions.function_builder import (
+    FunctionContext,
+)
+from classiq.model_expansions.generative_functions import emit_operands_as_declarative
+from classiq.model_expansions.quantum_operations.emitter import (
+    Emitter,
+    QuantumStatementT,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.qmod.builtins.functions import allocate, free
+
+
+class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT]):
+    @staticmethod
+    def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
+        # This protects shadowing of captured variables (i.e, bad user code) by wrapping the body in a function
+        # I'm sure there are better ways to handle it, but this is the simplest way to do it for now
+        return any(isinstance(stmt, VariableDeclarationStatement) for stmt in body)
+
+    def _create_expanded_wrapping_function(
+        self, name: str, body: Sequence[QuantumStatement]
+    ) -> QuantumFunctionCall:
+        wrapping_function = FunctionClosure.create(
+            name=name, body=body, scope=Scope(parent=self._current_scope)
+        )
+        return self._create_quantum_function_call(wrapping_function, list())
+
+    def _emit_quantum_function_call(
+        self, function: FunctionClosure, args: list[ArgValue]
+    ) -> QuantumFunctionCall:
+        call = self._create_quantum_function_call(function, args)
+        self._builder.emit_statement(call)
+        return call
+
+    def _create_quantum_function_call(
+        self, function: FunctionClosure, args: list[ArgValue]
+    ) -> QuantumFunctionCall:
+        evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
+        new_declaration = self._prepare_fully_typed_declaration(
+            function, evaluated_args
+        )
+        new_positional_arg_decls = new_declaration.positional_arg_declarations
+        is_atomic = function.is_atomic
+        new_function_name = function.name
+        if not is_atomic:  # perform monomorphization per interpreted parameters set
+            self._add_params_to_scope(
+                new_positional_arg_decls, evaluated_args, function
+            )
+            context = self._expand_operation(
+                function.with_new_declaration(new_declaration)
+            )
+            function_context = cast(FunctionContext, context)
+            closure_id = function_context.closure.closure_id
+            function_def = self._expanded_functions.get(closure_id)
+            if function_def is None:
+                function_def = self._builder.create_definition(function_context)
+                self._expanded_functions[closure_id] = function_def
+                self._top_level_scope[function_def.name] = Evaluated(
+                    value=function_context.closure.with_new_declaration(function_def)
+                )
+            new_declaration = function_def
+            new_function_name = function_def.name
+            compilation_metadata = self._functions_compilation_metadata.get(
+                function.name
+            )
+            if compilation_metadata is not None:
+                self._expanded_functions_compilation_metadata[new_function_name] = (
+                    compilation_metadata
+                )
+
+        new_positional_args = self._get_new_positional_args(
+            evaluated_args, is_atomic, new_positional_arg_decls
+        )
+        new_call = QuantumFunctionCall(
+            function=new_function_name,
+            positional_args=new_positional_args,
+        )
+        is_allocate_or_free = (
+            new_call.func_name == allocate.func_decl.name
+            or new_call.func_name == free.func_decl.name
+        )
+        parameters = {
+            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, ClassicalParameterDeclaration)
+        }
+
+        port_to_passed_variable_map = {
+            arg_decl.name: str(evaluated_arg.value.handle)
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, PortDeclaration)
+        }
+        self._interpreter._model.debug_info[new_call.uuid] = FunctionDebugInfo(
+            name=new_call.func_name,
+            level=OperationLevel.QMOD_FUNCTION_CALL,
+            parameters=parameters,
+            is_allocate_or_free=is_allocate_or_free,
+            port_to_passed_variable_map=port_to_passed_variable_map,
+        )
+        new_call.set_func_decl(new_declaration)
+        return new_call
+
+    @staticmethod
+    def _add_params_to_scope(
+        parameters: Sequence[PositionalArg],
+        arguments: Sequence[Evaluated],
+        closure: FunctionClosure,
+    ) -> None:
+        for parameter, argument in zip(parameters, arguments):
+            if isinstance(argument.value, QuantumSymbol):
+                assert isinstance(parameter, PortDeclaration)
+                closure.scope[parameter.name] = Evaluated(
+                    QuantumSymbol(
+                        handle=HandleBinding(name=parameter.name),
+                        quantum_type=parameter.quantum_type,
+                    ),
+                    defining_function=closure,
+                )
+            else:
+                closure.scope[parameter.name] = argument
+
+    def _get_new_positional_args(
+        self,
+        evaluated_args: list[Evaluated],
+        is_atomic: bool,
+        new_positional_arg_decls: Sequence[PositionalArg],
+    ) -> list[ArgValue]:
+        evaluated_args = add_information_from_output_arguments(
+            new_positional_arg_decls, evaluated_args
+        )
+        if is_atomic:
+            return [
+                emit_operands_as_declarative(self._interpreter, param, arg)
+                for param, arg in zip(new_positional_arg_decls, evaluated_args)
+            ]
+
+        positional_args = [
+            arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
+        ]
+
+        propagated_variables = self._propagated_var_stack.get_propagated_variables(
+            flatten=True
+        )
+        validate_args_are_not_propagated(positional_args, propagated_variables)
+        positional_args.extend(propagated_variables)
+
+        return positional_args
+
+    def _prepare_fully_typed_declaration(
+        self, function: FunctionClosure, evaluated_args: list[Evaluated]
+    ) -> NamedParamsQuantumFunctionDeclaration:
+        """
+        Given, for example,
+        def my_func(x: int, q: QArray["x"], p: QArray[]) -> None:
+        ...
+        def main(...):
+            ...
+            allocate(5, s)
+            my_func(3, r, s)
+        The code below will evaluate x to be 3, q to be of size 3 and p to be of size 5.
+        Note that it requires a scope for the parameter declaration space, which is
+        different from the call scope. For example, the former uses r,s and the latter
+        uses p, q.
+        """
+        with self._scope_guard(Scope(parent=self._current_scope)):
+            # The signature scope is passed as a separate argument to avoid contaminating the statement execution scope
+            return NamedParamsQuantumFunctionDeclaration(
+                name=function.name,
+                positional_arg_declarations=evaluate_parameter_types_from_args(
+                    function,
+                    function.signature_scope,
+                    evaluated_args,
+                ),
+            )

classiq/model_expansions/quantum_operations/classicalif.py

@@ -5,7 +5,7 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.closure import FunctionClosure
-from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.scope import Scope
 
 
@@ -16,7 +16,7 @@ def _is_all_identity_calls(body: Sequence[QuantumStatement]) -> bool:
     )
 
 
-class ClassicalIfEmitter(Emitter[ClassicalIf]):
+class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
     def emit(self, classical_if: ClassicalIf, /) -> None:
         with self._propagated_var_stack.capture_variables(classical_if):
             self._emit_propagated(classical_if)

classiq/model_expansions/quantum_operations/control.py

@@ -26,7 +26,6 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
-    QuantumType,
 )
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -47,6 +46,7 @@ from classiq.model_expansions.quantum_operations.expression_operation import (
     ExpressionOperationEmitter,
 )
 from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.transformers.var_splitter import SymbolParts
 from classiq.qmod.builtins.functions.standard_gates import X
 
 
@@ -54,7 +54,9 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
         condition = self._evaluate_op_expression(control)
 
-        arrays_with_subscript = self._get_symbols_to_split(condition)
+        arrays_with_subscript = self.split_symbols(
+            condition, self._counted_name_allocator.allocate
+        )
         if len(arrays_with_subscript) > 0:
             if control.is_generative():
                 with self._propagated_var_stack.capture_variables(control):
@@ -308,12 +310,12 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             raise ClassiqExpansionError(_condition_err_msg(condition_val))
 
     def _get_updated_op_split_symbols(
-        self, op: Control, symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]]
+        self, op: Control, symbol_parts: SymbolParts
     ) -> Control:
-        new_body = self._rewrite(op.body, symbol_mapping)
+        new_body = self.rewrite(op.body, symbol_parts)
         new_else = None
         if op.else_block is not None:
-            new_else = self._rewrite(op.else_block, symbol_mapping)
+            new_else = self.rewrite(op.else_block, symbol_parts)
         return op.model_copy(update=dict(body=new_body, else_block=new_else))