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

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

@@ -0,0 +1,75 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Union
+
+from sympy import Integer
+
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.expressions.expression_types import ExpressionValue
+    from classiq.interface.generator.functions.concrete_types import (
+        ConcreteClassicalType,
+    )
+
+
+class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
+    def __init__(
+        self, handle: HandleBinding, element_type: "ConcreteClassicalType", length: int
+    ) -> None:
+        super().__init__(handle)
+        self._element_type = element_type
+        self._length = length
+
+    @property
+    def fields(self) -> Mapping[str, "ExpressionValue"]:
+        return {"len": self._length}
+
+    @property
+    def type_name(self) -> str:
+        return "Array"
+
+    def __getitem__(self, key: Union[slice, int, Integer]) -> ClassicalProxy:
+        return (
+            self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
+        )
+
+    def _get_slice(self, slice_: slice) -> ClassicalProxy:
+        start = int(slice_.start)
+        stop = int(slice_.stop)
+        if start >= stop:
+            raise ClassiqValueError("Array slice has non-positive length")
+        if start < 0 or stop > self._length:
+            raise ClassiqValueError("Array slice is out of bounds")
+        return ClassicalArrayProxy(
+            SlicedHandleBinding(
+                base_handle=self.handle,
+                start=Expression(expr=str(start)),
+                end=Expression(expr=str(stop)),
+            ),
+            self._element_type,
+            stop - start,
+        )
+
+    def _get_subscript(self, index_: Union[int, Integer]) -> ClassicalProxy:
+        index = int(index_)
+        if index < 0:
+            raise ClassiqValueError(
+                "Array index is out of bounds (negative indices are not supported)"
+            )
+        if index >= self._length:
+            raise ClassiqValueError("Array index is out of bounds")
+        return self._element_type.get_classical_proxy(
+            SubscriptHandleBinding(
+                base_handle=self._handle, index=Expression(expr=str(index_))
+            )
+        )

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

@@ -0,0 +1,26 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.expressions.expression_types import ExpressionValue
+    from classiq.interface.model.handle_binding import HandleBinding
+
+
+class ClassicalProxy:
+    def __init__(self, handle: "HandleBinding") -> None:
+        self._handle = handle
+
+    @property
+    def handle(self) -> "HandleBinding":
+        return self._handle
+
+    def __str__(self) -> str:
+        return str(self.handle)
+
+    @property
+    def fields(self) -> Mapping[str, "ExpressionValue"]:
+        raise NotImplementedError
+
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError

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

@@ -0,0 +1,32 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+from sympy import Symbol
+
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.model.handle_binding import HandleBinding
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.expressions.expression_types import ExpressionValue
+    from classiq.interface.generator.functions.classical_type import ClassicalType
+
+
+class ClassicalScalarProxy(Symbol, ClassicalProxy):
+    def __new__(
+        cls, handle: HandleBinding, *args: Any, **assumptions: bool
+    ) -> "ClassicalScalarProxy":
+        return super().__new__(cls, str(handle), **assumptions)
+
+    def __init__(self, handle: HandleBinding, classical_type: "ClassicalType") -> None:
+        super().__init__(handle)
+        self._classical_type = classical_type
+
+    @property
+    def fields(self) -> Mapping[str, "ExpressionValue"]:
+        return {}
+
+    @property
+    def type_name(self) -> str:
+        return type(self._classical_type).__name__

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

@@ -0,0 +1,31 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.expressions.expression_types import ExpressionValue
+    from classiq.interface.generator.types.struct_declaration import StructDeclaration
+
+
+class ClassicalStructProxy(NonSymbolicExpr, ClassicalProxy):
+    def __init__(self, handle: HandleBinding, decl: "StructDeclaration") -> None:
+        super().__init__(handle)
+        self._decl = 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)
+            )
+            for field_name, field_type in self._decl.variables.items()
+        }
+
+    @property
+    def type_name(self) -> str:
+        return f"Struct {self._decl.name}"

classiq/interface/generator/expressions/{qmod_qarray_proxy.py → proxies/quantum/qmod_qarray_proxy.py}

@@ -6,7 +6,9 @@ from sympy import Integer
 from classiq.interface.exceptions import 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
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,

classiq/interface/generator/expressions/{qmod_qscalar_proxy.py → proxies/quantum/qmod_qscalar_proxy.py}

@@ -4,7 +4,9 @@ from typing import Any
 from sympy import Symbol
 
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 
 

classiq/interface/generator/expressions/{qmod_qstruct_proxy.py → proxies/quantum/qmod_qstruct_proxy.py}

@@ -2,7 +2,9 @@ from collections.abc import Mapping
 from typing import TYPE_CHECKING
 
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,

classiq/interface/generator/functions/classical_type.py

@@ -1,39 +1,51 @@
-from typing import TYPE_CHECKING, Any, Literal, Union
+from typing import TYPE_CHECKING, Any, Literal
 
 import pydantic
-from pydantic import ConfigDict
-from sympy import IndexedBase, Symbol
+from pydantic import ConfigDict, PrivateAttr
+from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
-from classiq.interface.generator.expressions.expression_types import RuntimeExpression
+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.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.handle_binding import HandleBinding
 
 if TYPE_CHECKING:
     from classiq.interface.generator.functions.concrete_types import (
         ConcreteClassicalType,
     )
 
-CLASSICAL_ATTRIBUTES = {"len", "size", "is_signed", "fraction_digits"}
-
-NamedSymbol = Union[IndexedBase, Symbol]
-
 
 class ClassicalType(HashableASTNode):
-    def as_symbolic(self, name: str) -> Union[NamedSymbol, list[NamedSymbol]]:
-        return Symbol(name)
+    _is_generative: bool = PrivateAttr(default=False)
 
     model_config = ConfigDict(extra="forbid")
 
     def __str__(self) -> str:
         return str(type(self).__name__)
 
+    def set_generative(self) -> Self:
+        self._is_generative = True
+        return self
+
+    @property
+    def is_generative(self) -> bool:
+        return self._is_generative
+
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        return ClassicalScalarProxy(handle, self)
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
 
-    def as_symbolic(self, name: str) -> Symbol:
-        return Symbol(name, integer=True)
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
@@ -43,9 +55,6 @@ class Integer(ClassicalType):
 class Real(ClassicalType):
     kind: Literal["real"]
 
-    def as_symbolic(self, name: str) -> Symbol:
-        return Symbol(name, real=True)
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
@@ -65,14 +74,14 @@ class ClassicalList(ClassicalType):
     kind: Literal["list"]
     element_type: "ConcreteClassicalType"
 
-    def as_symbolic(self, name: str) -> Symbol:
-        return IndexedBase(name)
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "list")
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        raise NotImplementedError
+
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -82,20 +91,23 @@ class StructMetaType(ClassicalType):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "type_proxy")
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        raise NotImplementedError
+
 
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
     size: pydantic.PositiveInt
 
-    def as_symbolic(self, name: str) -> list:
-        return [self.element_type.as_symbolic(f"{name}_{i}") for i in range(self.size)]
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        return ClassicalArrayProxy(handle, self.element_type, self.size)
+
 
 class OpaqueHandle(ClassicalType):
     pass
@@ -137,12 +149,5 @@ class IQAERes(OpaqueHandle):
         return values_with_discriminator(values, "kind", "iqae_result")
 
 
-def as_symbolic(symbols: dict[str, ClassicalType]) -> dict[str, RuntimeExpression]:
-    return {
-        param_name: param_type.as_symbolic(param_name)
-        for param_name, param_type in symbols.items()
-    }
-
-
 class QmodPyObject:
     pass

classiq/interface/generator/functions/type_name.py

@@ -4,7 +4,15 @@ from typing import TYPE_CHECKING, Any, Literal, Optional
 import pydantic
 
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
+    QmodQStructProxy,
+)
 from classiq.interface.generator.functions.classical_type import (
     ClassicalType,
 )
@@ -16,6 +24,7 @@ from classiq.interface.model.quantum_type import (
 
 if TYPE_CHECKING:
     from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+    from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
 
 class TypeName(ClassicalType, QuantumType):
@@ -24,6 +33,9 @@ class TypeName(ClassicalType, QuantumType):
     _assigned_fields: Optional[Mapping[str, "ConcreteQuantumType"]] = (
         pydantic.PrivateAttr(default=None)
     )
+    _classical_struct_decl: Optional["StructDeclaration"] = pydantic.PrivateAttr(
+        default=None
+    )
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -40,7 +52,7 @@ class TypeName(ClassicalType, QuantumType):
             )
 
     def get_proxy(self, handle: "HandleBinding") -> "QmodQStructProxy":
-        from classiq.interface.generator.expressions.qmod_qstruct_proxy import (
+        from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
             QmodQStructProxy,
         )
 
@@ -81,6 +93,18 @@ class TypeName(ClassicalType, QuantumType):
             field_type.is_evaluated for field_type in self.fields.values()
         )
 
+    @property
+    def has_classical_struct_decl(self) -> bool:
+        return self._classical_struct_decl is not None
+
+    def set_classical_struct_decl(self, decl: "StructDeclaration") -> None:
+        self._classical_struct_decl = decl
+
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        if self._classical_struct_decl is None:
+            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
+        return ClassicalStructProxy(handle, self._classical_struct_decl)
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -1,17 +1,29 @@
 import logging
+import re
 from typing import Literal, Optional, Union
 
 import pydantic
-from pydantic import ConfigDict
+from pydantic import ConfigDict, Field
 from typing_extensions import TypeAlias
 
+from classiq.interface.debug_info.back_ref_util import is_allocate_or_free_by_backref
 from classiq.interface.enum_utils import StrEnum
+from classiq.interface.generator.compiler_keywords import (
+    generate_original_function_name,
+)
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
-from classiq.interface.model.statement_block import StatementBlock
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+from classiq.interface.model.statement_block import (
+    ConcreteQuantumStatement,
+    QuantumFunctionCall,
+    StatementBlock,
+)
 
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_capture_name,
@@ -24,6 +36,11 @@ ParameterName = str
 IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["__"] = "__"
+QASM_SEPARATOR = "_"
+SPLIT_MARKER: str = "part"
+PART_SUFFIX_REGEX = re.compile(
+    rf".+{QASM_SEPARATOR}{SPLIT_MARKER}{QASM_SEPARATOR}(\d+)$"
+)
 
 VISUALIZATION_HIDE_LIST = [
     "apply_to_all",
@@ -120,34 +137,83 @@ class OperationLevel(StrEnum):
     UNKNOWN = "UNKNOWN"
 
 
-class OperationParameter(pydantic.BaseModel):
-    label: str
-    value: Optional[str] = None
+class StatementType(StrEnum):
+    CONTROL = "control"
+    POWER = "power"
+    INVERT = "invert"
+    WITHIN_APPLY = "within_apply"
+    ASSIGNMENT = "assignment"
+    REPEAT = "repeat"
 
 
 class FunctionDebugInfoInterface(pydantic.BaseModel):
-    generated_function: Optional[GeneratedFunction] = pydantic.Field(default=None)
+    generated_function: Optional[GeneratedFunction] = Field(default=None)
     children: list["FunctionDebugInfoInterface"]
     relative_qubits: tuple[int, ...]
-    absolute_qubits: Optional[tuple[int, ...]] = pydantic.Field(default=None)
-    is_basis_gate: Optional[bool] = pydantic.Field(default=None)
-    is_inverse: bool = pydantic.Field(default=False)
-    is_allocate_or_free: bool = pydantic.Field(default=False)
-    level: OperationLevel = pydantic.Field(default=OperationLevel.UNKNOWN)
-    parameters: list[OperationParameter] = list()
-    port_to_passed_variable_map: dict[str, str] = pydantic.Field(default={})
-    release_by_inverse: bool = pydantic.Field(default=False)
-    back_refs: StatementBlock = pydantic.Field(default_factory=list)
+    absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
+    is_basis_gate: Optional[bool] = Field(default=None)
+    is_inverse: bool = Field(default=False)
+    is_allocate_or_free: bool = Field(default=False)
+    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
+    port_to_passed_variable_map: dict[str, str] = Field(default={})
+    release_by_inverse: bool = Field(default=False)
+    back_refs: StatementBlock = Field(default_factory=list)
 
     model_config = ConfigDict(extra="allow")
     # Temporary field to store the override debug info for parallel old/new visualization
     override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
+    @property
+    def is_allocate_or_free_(self) -> bool:
+        """
+        temporary measure to handle the fact that in the current release we do not have
+        the backref, and therefore fallback to the old field of is_allocate_or_free
+        """
+        return (
+            is_allocate_or_free_by_backref(self.back_refs)
+            if bool(self.back_refs)
+            else self.is_allocate_or_free
+        )
+
     @property
     def name(self) -> str:
-        if self.generated_function is None:
-            return ""
-        return self.generated_function.name
+        generated_name = self.generated_function.name if self.generated_function else ""
+        # Temp fix for currently "supported" statements (same as for level_ property)
+        if generated_name in {StatementType.CONTROL, StatementType.POWER}:
+            return generated_name
+        if self.first_back_ref and isinstance(self.first_back_ref, QuantumFunctionCall):
+            name = generate_original_function_name(self.first_back_ref.func_name)
+            if part_match := PART_SUFFIX_REGEX.match(generated_name):
+                suffix = f" [{part_match.group(1)}]"
+            else:
+                suffix = ""
+            return f"{name}{suffix}"
+        return generated_name
+
+    @property
+    def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:
+        return self.back_refs[0] if self.back_refs else None
+
+    @property
+    def level_(self) -> OperationLevel:
+        # Temp fix for currently "supported" statements
+        if self.name in {StatementType.CONTROL, StatementType.POWER}:
+            return OperationLevel.QMOD_STATEMENT
+
+        back_ref = self.first_back_ref
+        if back_ref is None:
+            # This is the expected behavior for the case where there's not back ref.
+            # We will use it once we can rely on the existence of the back ref in
+            # all expected cases (non-engine calls)
+            # return OperationLevel.ENGINE_FUNCTION_CALL
+            return self.level
+        if isinstance(back_ref, QuantumFunctionCall):
+            return OperationLevel.QMOD_FUNCTION_CALL
+        # Temp "fix" for assignment statements until we have a way to fully
+        # distinguish them and to properly display them
+        if isinstance(back_ref, QuantumExpressionOperation):
+            return OperationLevel.ENGINE_FUNCTION_CALL
+        return OperationLevel.QMOD_STATEMENT
 
     @property
     def registers(self) -> list[GeneratedRegister]:
@@ -167,15 +233,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             return list()
         return self.generated_function.control_states
 
-    @staticmethod
-    def create_parameters_from_dict(
-        parameters: dict[str, str],
-    ) -> list[OperationParameter]:
-        return [
-            OperationParameter(label=key, value=value)
-            for key, value in parameters.items()
-        ]
-
     def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":
         if self.absolute_qubits is None:
             return self

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

@@ -47,6 +47,7 @@ class QuantumFormat(StrEnum):
     IONQ = "ionq"
     CIRQ_JSON = "cirq_json"
     QASM_CIRQ_COMPATIBLE = "qasm_cirq_compatible"
+    EXECUTION_SERIALIZATION = "_execution_serialization"
 
 
 _SERVICE_PROVIDER_TO_FORMAT: dict[Provider, QuantumFormat] = {

classiq/interface/generator/quantum_program.py

@@ -117,7 +117,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         instruction_set: Optional[QuantumInstructionSet] = None,
     ) -> quantum_code.QuantumCode:
         initial_values = initial_values or self.initial_values
-
         if instruction_set is not None:
             code, syntax = (
                 self.program_circuit.get_code(instruction_set),

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -150,6 +150,7 @@ class Optimizer(IntEnum):
     L_BFGS_B = 3
     NELDER_MEAD = 4
     ADAM = 5
+    SLSQP = 6
 
 
 class Pauli(IntEnum):

classiq/interface/generator/types/enum_declaration.py

@@ -75,7 +75,7 @@ class EnumDeclaration(HashableASTNode):
 
 
 def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:
-    members: list[Enum] = list(enum_type)
+    members = _get_members(enum_type)
     return EnumDeclaration(
         name=enum_type.__name__,
         members={
@@ -83,3 +83,14 @@ def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:
             for member in sorted(members, key=lambda member: member.value)
         },
     )
+
+
+def _get_members(enum_type: EnumMeta) -> list[Enum]:
+    members: list[Enum] = list(enum_type)
+    for member in members:
+        if not isinstance(member.value, int):
+            raise ClassiqValueError(
+                f"Member {member.name!r} of enum {enum_type.__name__!r} has a "
+                f"non-integer value {member.value!r}"
+            )
+    return members

classiq/interface/ide/visual_model.py

@@ -7,7 +7,6 @@ from pydantic import ConfigDict
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.generated_circuit_data import (
     OperationLevel,
-    OperationParameter,
 )
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.helpers.versioned_model import VersionedModel
@@ -114,7 +113,6 @@ class Operation(pydantic.BaseModel):
     control_qubits: tuple[int, ...] = pydantic.Field(default_factory=tuple)
     auxiliary_qubits: tuple[int, ...]
     target_qubits: tuple[int, ...]
-    parameters: list[OperationParameter] = pydantic.Field(default_factory=list)
     operation_level: OperationLevel
     operation_type: OperationType = pydantic.Field(
         description="Identifies unique operations that are visualized differently"

classiq/interface/model/native_function_definition.py

@@ -10,13 +10,6 @@ if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
 
-class FunctionSynthesisData(pydantic.BaseModel):
-    should_synthesize_separately: bool = pydantic.Field(
-        default=False,
-        description="Whether the function should be synthesized separately.",
-    )
-
-
 class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     """
     Facilitates the creation of a user-defined composite function
@@ -28,6 +21,3 @@ class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     body: "StatementBlock" = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )
-    synthesis_data: FunctionSynthesisData = pydantic.Field(
-        default_factory=FunctionSynthesisData, deprecated=True, exclude=True
-    )

classiq/interface/model/quantum_statement.py

@@ -27,7 +27,7 @@ class QuantumStatement(ASTNode):
         *,
         update: Optional[dict[str, Any]] = None,
         deep: bool = False,
-        keep_uuid: bool = False
+        keep_uuid: bool = False,
     ) -> Self:
         if not keep_uuid:
             update = update or dict()