classiq 0.70.0__py3-none-any.whl → 0.71.0__py3-none-any.whl

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

classiq/interface/debug_info/debug_info.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.generated_circuit_data import (
     OperationLevel,
     StatementType,
 )
+from classiq.interface.model.block import Block
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 
 ParameterValue = Union[float, int, str, None]
@@ -84,6 +85,9 @@ def get_back_refs(
 ) -> list[ConcreteQuantumStatement]:
     back_refs: list[ConcreteQuantumStatement] = []
     while (node := debug_info.node) is not None:
+        #  For backwards compatibility, we make sure that the back_ref is not a block
+        #  Remove this check when we start saving blocks in the debug info collection.
+        assert not isinstance(node, Block)
         back_refs.insert(0, node)
         if node.back_ref is None:
             break

classiq/interface/generator/expressions/expression_constants.py

@@ -20,6 +20,3 @@ BOOLEAN_LITERALS = {"True", "False"}
 FORBIDDEN_LITERALS: set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
 CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
 RESERVED_EXPRESSIONS: frozenset[str] = frozenset({"i"})
-CPARAM_EXECUTION_SUFFIX_PATTERN = (
-    rf"({CPARAM_EXECUTION_SUFFIX}|^({'|'.join(RESERVED_EXPRESSIONS)}))(_\d+)*$"
-)

classiq/interface/generator/expressions/expression_types.py

@@ -21,10 +21,12 @@ RuntimeConstant = Union[
     list,
     bool,
     QmodStructInstance,
-    QmodSizedProxy,
     TypeProxy,
     HandleIdentifier,
+]
+Proxies = Union[
+    QmodSizedProxy,
     ClassicalProxy,
 ]
 RuntimeExpression = Union[Expr, Boolean]
-ExpressionValue = Union[RuntimeConstant, RuntimeExpression]
+ExpressionValue = Union[RuntimeConstant, Proxies, RuntimeExpression]

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -38,6 +38,10 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
     def type_name(self) -> str:
         return "Array"
 
+    @property
+    def length(self) -> int:
+        return self._length
+
     def __getitem__(self, key: Union[slice, int, Integer]) -> ClassicalProxy:
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)

classiq/interface/generator/expressions/proxies/classical/classical_struct_proxy.py

@@ -17,11 +17,15 @@ class ClassicalStructProxy(NonSymbolicExpr, ClassicalProxy):
         super().__init__(handle)
         self._decl = decl
 
+    @property
+    def struct_declaration(self) -> "StructDeclaration":
+        return self._decl
+
     @property
     def fields(self) -> Mapping[str, "ExpressionValue"]:
         return {
             field_name: field_type.get_classical_proxy(
-                FieldHandleBinding(base_handle=self.handle, field_name=field_name)
+                FieldHandleBinding(base_handle=self.handle, field=field_name)
             )
             for field_name, field_type in self._decl.variables.items()
         }

classiq/interface/generator/expressions/proxies/classical/utils.py

@@ -0,0 +1,34 @@
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalType,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+
+
+def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
+    if isinstance(proxy, ClassicalScalarProxy):
+        classical_type = proxy._classical_type
+    elif isinstance(proxy, ClassicalArrayProxy):
+        classical_type = ClassicalArray(
+            element_type=proxy._element_type, size=proxy.length
+        )
+    elif isinstance(proxy, ClassicalStructProxy):
+        classical_type = TypeName(name=proxy._decl.name)
+    else:
+        raise ClassiqInternalExpansionError(
+            f"Unrecognized classical proxy {type(proxy).__name__}"
+        )
+    return classical_type

classiq/interface/generator/functions/classical_type.py

@@ -98,7 +98,7 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    size: pydantic.PositiveInt
+    size: int
 
     @pydantic.model_validator(mode="before")
     @classmethod

classiq/interface/generator/functions/type_name.py

@@ -1,9 +1,11 @@
 from collections.abc import Mapping
+from itertools import chain
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
 
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -97,6 +99,12 @@ class TypeName(ClassicalType, QuantumType):
     def has_classical_struct_decl(self) -> bool:
         return self._classical_struct_decl is not None
 
+    @property
+    def classical_struct_decl(self) -> "StructDeclaration":
+        if self._classical_struct_decl is None:
+            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
+        return self._classical_struct_decl
+
     def set_classical_struct_decl(self, decl: "StructDeclaration") -> None:
         self._classical_struct_decl = decl
 
@@ -105,6 +113,14 @@ class TypeName(ClassicalType, QuantumType):
             raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
         return ClassicalStructProxy(handle, self._classical_struct_decl)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return list(
+            chain.from_iterable(
+                field_type.expressions for field_type in self.fields.values()
+            )
+        )
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/functions/type_qualifier.py

@@ -0,0 +1,7 @@
+from classiq.interface.enum_utils import StrEnum
+
+
+class TypeQualifier(StrEnum):
+    Const = "const"
+    QFree = "qfree"
+    Quantum = "quantum"

classiq/interface/generator/generated_circuit_data.py

@@ -83,7 +83,7 @@ class GeneratedRegister(pydantic.BaseModel):
     @staticmethod
     def demangle_name(name: str) -> str:
         if is_captured_var_name(name):
-            return demangle_capture_name(name)
+            name = demangle_capture_name(name)
         return demangle_name(name)
 
 

classiq/interface/generator/quantum_function_call.py

@@ -40,7 +40,10 @@ from classiq.interface.generator.slice_parsing_utils import (
     SLICING,
     parse_io_slicing,
 )
-from classiq.interface.generator.synthesis_execution_parameter import PydanticPowerType
+from classiq.interface.generator.synthesis_execution_parameter import (
+    ClassicalArg,
+    PydanticPowerType,
+)
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.hashable_pydantic_base_model import (
@@ -148,6 +151,10 @@ class SynthesisQuantumFunctionCall(BaseModel):
         description="The name of the function instance. "
         "If not set, determined automatically.",
     )
+    caller_parameters: Optional[list[str]] = pydantic.Field(default=None)
+    parameter_assignments: Optional[dict[str, ClassicalArg]] = pydantic.Field(
+        default=None
+    )
     source_id: Optional[UUID] = pydantic.Field(default=None)
     arithmetic_id: Optional[str] = pydantic.Field(default=None)
     inverse_op_id: Optional[UUID] = pydantic.Field(default=None)

classiq/interface/generator/synthesis_execution_parameter.py

@@ -6,3 +6,4 @@ from classiq.interface.backend.pydantic_backend import PydanticExecutionParamete
 
 PydanticIntSynthesisExecutionParameter = Union[PydanticExecutionParameter, int]
 PydanticPowerType: TypeAlias = PydanticIntSynthesisExecutionParameter
+ClassicalArg = Union[float, str]

classiq/interface/generator/types/compilation_metadata.py

@@ -4,3 +4,4 @@ from pydantic import BaseModel, Field, NonNegativeInt
 class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
     occurrences_number: NonNegativeInt = Field(default=1)
+    atomic_qualifiers: list[str] = Field(default_factory=list)

classiq/interface/ide/visual_model.py

@@ -97,6 +97,7 @@ class AtomicGate(StrEnum):
     SWAP = "SWAP"
     IDENTITY = "IDENTITY"
     U = "U"
+    RESET = "RESET"
 
     @property
     def is_control_gate(self) -> bool:

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "8"
+INTERFACE_VERSION = "9"

classiq/interface/model/allocate.py

@@ -14,3 +14,10 @@ class Allocate(QuantumOperation):
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return {"out": self.target}
+
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = []
+        if self.size is not None:
+            exprs.append(self.size)
+        return exprs

classiq/interface/model/block.py

@@ -0,0 +1,12 @@
+from typing import TYPE_CHECKING, Literal
+
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Block(QuantumOperation):
+    kind: Literal["Block"]
+
+    statements: "StatementBlock"

classiq/interface/model/classical_if.py

@@ -17,3 +17,7 @@ class ClassicalIf(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["then", "else_"])
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.condition]

classiq/interface/model/inplace_binary_operation.py

@@ -41,3 +41,7 @@ class InplaceBinaryOperation(QuantumOperation):
                 )
             )
         return readable_inouts
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.value] if isinstance(self.value, Expression) else []

classiq/interface/model/model.py

@@ -103,7 +103,9 @@ class Model(VersionedModel, ASTNode):
     functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
         default_factory=dict
     )
-    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = None
+    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = pydantic.Field(
+        default=None, exclude=True
+    )
 
     @property
     def main_func(self) -> NativeFunctionDefinition:

classiq/interface/model/phase_operation.py

@@ -9,3 +9,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 class PhaseOperation(QuantumExpressionOperation):
     kind: Literal["PhaseOperation"]
     theta: Expression
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return super().expressions + [self.theta]

classiq/interface/model/port_declaration.py

@@ -8,6 +8,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteQuantum
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
 
@@ -15,6 +16,8 @@ from classiq.interface.model.parameter import Parameter
 class AnonPortDeclaration(Parameter):
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
+    # TODO remove default after BWC-breaking version
+    type_qualifier: TypeQualifier = pydantic.Field(default=TypeQualifier.Quantum)
     kind: Literal["PortDeclaration"]
 
     @pydantic.model_validator(mode="before")

classiq/interface/model/power.py

@@ -16,3 +16,7 @@ class Power(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.power]

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -46,6 +46,10 @@ class QuantumExpressionOperation(QuantumOperation):
     def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
         return nameables_to_dict(self.var_handles)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.expression]
+
 
 class QuantumAssignmentOperation(QuantumExpressionOperation):
     result_var: ConcreteHandleBinding = pydantic.Field(

classiq/interface/model/quantum_function_call.py

@@ -170,6 +170,10 @@ class QuantumFunctionCall(QuantumOperation):
             param for param in self.positional_args if isinstance(param, HandleBinding)
         ]
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return [arg for arg in self.positional_args if isinstance(arg, Expression)]
+
     def _get_handles_by_direction(
         self, direction: PortDeclarationDirection
     ) -> list[tuple[int, AnonPortDeclaration, HandleBinding]]:

classiq/interface/model/quantum_function_declaration.py

@@ -87,7 +87,7 @@ class AnonQuantumFunctionDeclaration(FunctionDeclaration):
         ]
 
     @property
-    def param_names(self) -> Sequence[str]:
+    def param_names(self) -> list[str]:
         return [param.get_name() for param in self.param_decls]
 
     @property

classiq/interface/model/quantum_statement.py

@@ -8,6 +8,7 @@ from pydantic import ConfigDict
 from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
@@ -39,6 +40,10 @@ class QuantumStatement(ASTNode):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", cls.__name__)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return []
+
 
 @dataclass
 class HandleMetadata:

classiq/interface/model/quantum_type.py

@@ -71,6 +71,10 @@ class QuantumType(HashableASTNode):
     def is_evaluated(self) -> bool:
         raise NotImplementedError
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return []
+
 
 class QuantumScalar(QuantumType):
     def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
@@ -174,6 +178,13 @@ class QuantumBitvector(QuantumType):
             and self.element_type.is_evaluated
         )
 
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = self.element_type.expressions
+        if self.length is not None:
+            exprs.append(self.length)
+        return exprs
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -265,6 +276,17 @@ class QuantumNumeric(QuantumScalar):
             self.fraction_digits is not None and not self.fraction_digits.is_evaluated()
         )
 
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = []
+        if self.size is not None:
+            exprs.append(self.size)
+        if self.is_signed is not None:
+            exprs.append(self.is_signed)
+        if self.fraction_digits is not None:
+            exprs.append(self.fraction_digits)
+        return exprs
+
 
 class RegisterQuantumType(BaseModel):
     quantum_types: "ConcreteQuantumType"

classiq/interface/model/repeat.py

@@ -17,3 +17,7 @@ class Repeat(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.count]

classiq/interface/model/statement_block.py

@@ -4,6 +4,7 @@ from pydantic import Field
 
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
@@ -41,12 +42,14 @@ ConcreteQuantumStatement = Annotated[
         Control,
         WithinApply,
         PhaseOperation,
+        Block,
     ],
     Field(..., discriminator="kind"),
 ]
 
 StatementBlock = list[ConcreteQuantumStatement]
 
+Block.model_rebuild()
 Control.model_rebuild()
 QuantumLambdaFunction.model_rebuild()
 Repeat.model_rebuild()

classiq/interface/model/variable_declaration_statement.py

@@ -1,5 +1,6 @@
 from typing import Literal
 
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
@@ -8,3 +9,7 @@ from classiq.interface.model.quantum_variable_declaration import (
 
 class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
     kind: Literal["VariableDeclarationStatement"]
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return self.quantum_type.expressions