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

classiq/open_library/functions/discrete_sine_cosine_transform.py

@@ -1,13 +1,11 @@
 from classiq.open_library.functions.qft_functions import qft
-from classiq.open_library.functions.utility_functions import (
-    apply_to_all,
-    modular_increment,
-)
+from classiq.open_library.functions.utility_functions import apply_to_all
 from classiq.qmod.builtins.functions.standard_gates import PHASE, H, S, X, Z
 from classiq.qmod.builtins.operations import (
     allocate,
     bind,
     control,
+    inplace_add,
     invert,
     repeat,
     within_apply,
@@ -30,8 +28,13 @@ def _qct_d_operator(x: QNum, q: QBit) -> None:
 
 @qfunc
 def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
-    control(q == 1, lambda: apply_to_all(X, x))
-    control(q == 1, lambda: modular_increment(1, x))
+    control(
+        q == 1,
+        lambda: [  # type:ignore[arg-type]
+            apply_to_all(X, x),
+            inplace_add(1, x),  # type:ignore[arg-type, func-returns-value]
+        ],
+    )
 
 
 def _t_operator(x: QArray) -> None:
@@ -63,7 +66,7 @@ def _d1_operator(x: QArray[QBit], q: QBit) -> None:
 
 
 def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
-    control(q == 1, lambda: modular_increment(1, x))
+    control(q == 1, lambda: inplace_add(1, x))  # type:ignore[arg-type]
 
 
 def _j_operator(q: QBit) -> None:
@@ -76,7 +79,7 @@ def _b_t_operator(q: QBit) -> None:
 
 
 def _d0dt_operator(x: QArray, q: QBit) -> None:
-    x_num: QNum = QNum("x_num", x.len, False, 0)
+    x_num: QNum = QNum(size=x.len)
     bind(x, x_num)
     _b_t_operator(q)
     control(x_num == 0, lambda: _j_operator(q))
@@ -140,7 +143,7 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
         x: The LSB part of the qubit array to apply the transform to.
         q: The MSB of the qubit array to apply the transform to.
     """
-    extended_state: QArray = QArray("extended_state")
+    extended_state: QArray = QArray()
     _vn_operator(x, q)
     bind([x, q], extended_state)
     qft(extended_state)
@@ -159,8 +162,8 @@ def qct_type2(x: QArray[QBit]) -> None:
     Args:
         x: The qubit array to apply the transform to.
     """
-    q = QBit("q")
-    within_apply(lambda: allocate(1, q), lambda: qct_qst_type2(x, q))
+    q = QBit()
+    within_apply(lambda: allocate(q), lambda: qct_qst_type2(x, q))
 
 
 @qfunc
@@ -174,8 +177,8 @@ def qst_type2(x: QArray[QBit]) -> None:
     Args:
         x: The qubit array to apply the transform to.
     """
-    q = QBit("q")
+    q = QBit()
     within_apply(
-        lambda: (allocate(1, q), X(q)),  # type:ignore[arg-type]
+        lambda: (allocate(q), X(q)),  # type:ignore[arg-type]
         lambda: qct_qst_type2(x, q),
     )

classiq/open_library/functions/grover.py

@@ -40,9 +40,9 @@ def phase_oracle(
         predicate: A predicate function that takes a QArray of QBits and sets a single QBit |1> if the predicate is true, and |0> otherwise.
         target: The target QArray of QBits to apply the phase oracle to.
     """
-    aux = QBit("aux")
+    aux = QBit()
     within_apply(
-        within=lambda: (allocate(1, aux), X(aux), H(aux)),  # type:ignore[arg-type]
+        within=lambda: (allocate(aux), X(aux), H(aux)),  # type:ignore[arg-type]
         apply=lambda: predicate(target, aux),
     )
 
@@ -64,8 +64,8 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     Args:
         packed_vars: The quantum state to reflect.
     """
-    msbs: QNum = QNum("msbs", packed_vars.len - 1, False, 0)
-    lsb = QBit("lsb")
+    msbs: QNum = QNum(size=packed_vars.len - 1)
+    lsb = QBit()
     bind(packed_vars, [msbs, lsb])
     within_apply(
         lambda: (X(lsb), H(lsb)),  # type:ignore[arg-type]
@@ -126,7 +126,7 @@ def grover_operator(
         packed_vars: The state to which to apply the grover operator.
     """
     oracle(packed_vars)
-    grover_diffuser(lambda qba: space_transform(qba), packed_vars)
+    grover_diffuser(space_transform, packed_vars)
     U(0, 0, 0, pi, packed_vars[0])
 
 
@@ -149,9 +149,5 @@ def grover_search(
     hadamard_transform(packed_vars)
     power(
         reps,
-        lambda: grover_operator(
-            lambda qba: oracle(qba),
-            lambda qba: hadamard_transform(qba),
-            packed_vars,
-        ),
+        lambda: grover_operator(oracle, hadamard_transform, packed_vars),
     )

classiq/open_library/functions/modular_exponentiation.py

@@ -11,24 +11,18 @@ from classiq.qmod.builtins.operations import (
 )
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.symbolic import min, mod_inverse
 
 
 @qfunc
 def _check_msb(ref: CInt, x: QArray[QBit], aux: QBit) -> None:
     within_apply(
-        lambda: invert(lambda: qft_no_swap(x)), lambda: _ctrl_x(ref, x[0], aux)
+        lambda: invert(lambda: qft_no_swap(x)),
+        lambda: control(x[0] == ref, lambda: X(aux)),
     )
 
 
-@qfunc
-def _ctrl_x(
-    ref: CInt, ctrl: QNum, aux: QBit
-) -> None:  # TODO: remove qfunc when expressions of QBit is supported
-    control(ctrl == ref, lambda: X(aux))
-
-
 @qfunc
 def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     """
@@ -72,12 +66,12 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
         c2: a control qubit.
 
     """
-    ctrl: QArray[QBit] = QArray("ctrl")
-    aux = QBit("aux")
+    ctrl: QArray[QBit] = QArray()
+    aux = QBit()
 
     within_apply(
         lambda: (  # type:ignore[arg-type]
-            allocate(1, aux),
+            allocate(aux),
             bind([c1, c2], ctrl),  # type:ignore[func-returns-value]
         ),
         lambda: (  # type:ignore[arg-type]
@@ -162,7 +156,7 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
         x: The quantum factor.
         ctrl: The control bit.
     """
-    b: QArray[QBit] = QArray("b")
+    b: QArray[QBit] = QArray()
 
     within_apply(
         lambda: allocate(x.len + 1, b),

classiq/open_library/functions/state_preparation.py

@@ -3,12 +3,9 @@ from typing import Literal
 
 from classiq.interface.exceptions import ClassiqDeprecationWarning
 
-from classiq.open_library.functions.utility_functions import (
-    hadamard_transform,
-    modular_increment,
-)
+from classiq.open_library.functions.utility_functions import hadamard_transform
 from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
-from classiq.qmod.builtins.operations import allocate, control, if_, repeat
+from classiq.qmod.builtins.operations import allocate, control, if_, inplace_add, repeat
 from classiq.qmod.cparam import CBool, CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
@@ -48,7 +45,7 @@ def allocate_num(
     allocate(num_qubits, out)
 
 
-def prepare_uniform_trimmed_state_apply_rotation(
+def _prepare_uniform_trimmed_state_apply_rotation(
     size_lsb: CInt, lsbs_val: CInt, rotation_var: QBit
 ) -> None:
     # max hold for the case where the value is on the left side
@@ -68,7 +65,7 @@ def _prepare_uniform_trimmed_state_step(
         lsbs_val != 0,  # stop condition
         lambda: control(
             ctrl_var == ctrl_val,
-            lambda: prepare_uniform_trimmed_state_apply_rotation(
+            lambda: _prepare_uniform_trimmed_state_apply_rotation(
                 size_lsb, lsbs_val, rotation_var
             ),
         ),
@@ -102,7 +99,7 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
     if_(
         m < 2**q.len,
         # initial step without control
-        lambda: prepare_uniform_trimmed_state_apply_rotation(
+        lambda: _prepare_uniform_trimmed_state_apply_rotation(
             q.len - 1,  # type:ignore[arg-type]
             m,
             q[q.len - 1],
@@ -122,7 +119,7 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
 
 
 @qfunc
-def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> None:
+def prepare_uniform_interval_state(start: CInt, end: CInt, q: QNum) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -144,7 +141,7 @@ def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> N
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
     prepare_uniform_trimmed_state(end - start, q)
-    modular_increment(start, q)
+    inplace_add(start, q)
 
 
 @qfunc
@@ -199,7 +196,9 @@ def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
 
 
 @qfunc
-def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) -> None:
+def prepare_bell_state(
+    state_num: CInt, qpair: Output[QArray[QBit, Literal[2]]]
+) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -207,7 +206,7 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
     Args:
         state_num: The number of the Bell state to be prepared. Must be an integer between 0 and 3.
-        q: The quantum variable that will receive the initialized state. Must be uninitialized.
+        qpair: The quantum variable that will receive the initialized state. Must be uninitialized.
 
     Bell States:
         The four Bell states are defined as follows (each state correlates to an integer between 0 and 3 as defined by the `state_num` argument):
@@ -241,11 +240,11 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
 
     """
-    allocate(2, q)
-    if_(logical_or(state_num == 1, state_num == 3), lambda: X(q[0]))
-    if_(logical_or(state_num == 2, state_num == 3), lambda: X(q[1]))
-    H(q[0])
-    CX(q[0], q[1])
+    allocate(qpair)
+    if_(logical_or(state_num == 1, state_num == 3), lambda: X(qpair[0]))
+    if_(logical_or(state_num == 2, state_num == 3), lambda: X(qpair[1]))
+    H(qpair[0])
+    CX(qpair[0], qpair[1])
 
 
 @qfunc

classiq/open_library/functions/swap_test.py

@@ -21,7 +21,7 @@ def swap_test(state1: QArray[QBit], state2: QArray[QBit], test: Output[QBit]) ->
         state2: A quantum state to check its overlap with state1.
         test: A qubit for which the probability of measuring 0 is $0.5*(|\\langle state1 | state2 \\rangle |^2+1)$
     """
-    allocate(1, test)
+    allocate(test)
     H(test)
     control(test, lambda: repeat(state1.len, lambda i: SWAP(state1[i], state2[i])))
     H(test)

classiq/open_library/functions/utility_functions.py

@@ -1,5 +1,8 @@
+import warnings
 from typing import Annotated
 
+from classiq.interface.exceptions import ClassiqDeprecationWarning
+
 from classiq.open_library.functions.qft_functions import qft
 from classiq.qmod.builtins.functions.standard_gates import PHASE, H
 from classiq.qmod.builtins.operations import bind, repeat, within_apply
@@ -44,7 +47,7 @@ def hadamard_transform(target: QArray[QBit]) -> None:
         target:  qubits to apply to Hadamard transform to.
 
     """
-    apply_to_all(H, target)
+    repeat(target.len, lambda index: H(target[index]))
 
 
 @qfunc
@@ -69,7 +72,12 @@ def modular_increment(a: CInt, x: QNum) -> None:
         x: A quantum number that is assumed to be non-negative integer.
 
     """
-    array_cast: QArray = QArray("array_cast")
+    warnings.warn(
+        "Function 'modular_increment' is deprecated. Use in-place-add statement in the form '<var> += <expression>'  or 'inplace_add(<expression>, <var>)' instead.",
+        ClassiqDeprecationWarning,
+        stacklevel=1,
+    )
+    array_cast: QArray = QArray()
     within_apply(
         lambda: (  # type:ignore[arg-type]
             bind(x, array_cast),  # type:ignore[func-returns-value]

classiq/qmod/builtins/functions/chemistry.py

@@ -1,5 +1,3 @@
-from typing import Literal
-
 from classiq.qmod.builtins.structs import (
     FockHamiltonianProblem,
     MoleculeProblem,
@@ -13,12 +11,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 def molecule_ucc(
     molecule_problem: MoleculeProblem,
     excitations: CArray[CInt],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -27,12 +20,7 @@ def molecule_ucc(
 def molecule_hva(
     molecule_problem: MoleculeProblem,
     reps: CInt,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -40,12 +28,7 @@ def molecule_hva(
 @qfunc(external=True)
 def molecule_hartree_fock(
     molecule_problem: MoleculeProblem,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -54,12 +37,7 @@ def molecule_hartree_fock(
 def fock_hamiltonian_ucc(
     fock_hamiltonian_problem: FockHamiltonianProblem,
     excitations: CArray[CInt],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -68,12 +46,7 @@ def fock_hamiltonian_ucc(
 def fock_hamiltonian_hva(
     fock_hamiltonian_problem: FockHamiltonianProblem,
     reps: CInt,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -81,11 +54,6 @@ def fock_hamiltonian_hva(
 @qfunc(external=True)
 def fock_hamiltonian_hartree_fock(
     fock_hamiltonian_problem: FockHamiltonianProblem,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass

classiq/qmod/quantum_expandable.py

@@ -1,5 +1,6 @@
 import inspect
 from abc import ABC
+from collections.abc import Generator, Iterable
 from dataclasses import is_dataclass
 from enum import Enum as PythonEnum
 from types import TracebackType
@@ -67,7 +68,10 @@ from classiq.qmod.qmod_variable import (
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.type_attribute_remover import decl_without_type_attributes
-from classiq.qmod.utilities import mangle_keyword, qmod_val_to_expr_str
+from classiq.qmod.utilities import (
+    mangle_keyword,
+    qmod_val_to_expr_str,
+)
 
 ArgType = Union[CParam, QVar, QCallable]
 
@@ -371,11 +375,14 @@ def prepare_arg(
 def _validate_classical_arg(
     arg: Any, arg_decl: AnonClassicalParameterDeclaration, func_name: Optional[str]
 ) -> None:
-    is_native_or_compatible_type = not isinstance(
-        arg, (*NativePythonClassicalTypes, CParam, SymbolicExpr, Basic, PythonEnum)
-    ) and not is_dataclass(
-        arg
-    )  # type: ignore[unreachable]
+    is_native_or_compatible_type = (
+        not isinstance(
+            arg,
+            (*NativePythonClassicalTypes, CParam, SymbolicExpr, Basic, PythonEnum),
+        )
+        and not _is_legal_iterable(arg)
+        and not is_dataclass(arg)  # type: ignore[unreachable]
+    )
     try:
         is_pydantic_classical_type = isinstance(
             arg, pydantic.BaseModel
@@ -481,3 +488,20 @@ def _create_quantum_function_call(
     return QuantumFunctionCall(
         function=function_ident, positional_args=prepared_args, source_ref=source_ref_
     )
+
+
+_FORBIDDEN_ITERABLES = (set, dict, str, Generator)
+
+
+def _is_legal_iterable(arg: Any) -> bool:
+    if not isinstance(arg, Iterable) or isinstance(arg, _FORBIDDEN_ITERABLES):
+        return False
+    return all(_is_legal_iterable_element(e) for e in arg)
+
+
+def _is_legal_iterable_element(arg: Any) -> bool:
+    if isinstance(arg, _FORBIDDEN_ITERABLES):
+        return False
+    if isinstance(arg, Iterable):
+        return all(_is_legal_iterable_element(e) for e in arg)
+    return True

classiq/qmod/semantics/validation/types_validation.py

@@ -16,7 +16,7 @@ TYPE_EXISTS_ERROR_MESSAGE = "Type {!r} already exists"
 
 
 def check_duplicate_types(
-    types: Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]]
+    types: Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]],
 ) -> None:
     known_types = {type_.name for type_ in BUILTIN_ENUM_DECLARATIONS.values()}
     known_types |= {type_.name for type_ in BUILTIN_STRUCT_DECLARATIONS.values()}

classiq/qmod/symbolic.py

@@ -1,4 +1,5 @@
 import sys
+from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -296,7 +297,7 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
 
 
 def subscript(
-    amplitudes: Union[list[float], list[CReal], list[CParamScalar], CArray[CReal]],
+    amplitudes: Union[Sequence[Union[float, CReal, CParamScalar]], CArray[CReal]],
     index: QNum,
 ) -> CParamScalar:
     return CParamScalar(expr=f"{amplitudes}[{index}]")

classiq/qmod/utilities.py

@@ -3,6 +3,7 @@ import inspect
 import itertools
 import keyword
 import sys
+from collections.abc import Iterable
 from enum import Enum as PythonEnum
 from types import FrameType
 from typing import Any, ForwardRef, Literal, Optional, get_args, get_origin, overload
@@ -101,7 +102,7 @@ def qmod_val_to_expr_str(val: Any) -> str:
         )
         return f"struct_literal({val.struct_declaration.name}, {kwargs_str})"
 
-    if isinstance(val, list):
+    if isinstance(val, Iterable):
         elements_str = ", ".join([qmod_val_to_expr_str(elem) for elem in val])
         return f"[{elements_str}]"
 

classiq/qmod/write_qmod.py

@@ -1,10 +1,11 @@
 import json
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Union
 
 from classiq.interface.model.model import Model, SerializedModel
 
 from classiq.qmod.native.pretty_printer import DSLPrettyPrinter
+from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 _QMOD_SUFFIX = "qmod"
@@ -12,7 +13,7 @@ _SYNTHESIS_OPTIONS_SUFFIX = "synthesis_options.json"
 
 
 def write_qmod(
-    serialized_model: SerializedModel,
+    model: Union[SerializedModel, QFunc, GenerativeQFunc],
     name: str,
     directory: Optional[Path] = None,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
@@ -22,7 +23,7 @@ def write_qmod(
     The native Qmod file may be uploaded to the Classiq IDE.
 
     Args:
-        serialized_model: The serialized model to write as a native Qmod file and synthesis options file.
+        model: The entry point of the Qmod model - a qfunc named 'main' (or alternatively the output of 'create_model').
         name: The name to save the file by.
         directory: The directory to save the files in. If None, the current working directory is used.
         decimal_precision: The number of decimal places to use for numbers, set to 4 by default.
@@ -30,13 +31,15 @@ def write_qmod(
     Returns:
         None
     """
-
-    model = Model.model_validate_json(serialized_model)
+    if isinstance(model, (QFunc, GenerativeQFunc)):
+        model_obj = model.create_model()
+    else:
+        model_obj = Model.model_validate_json(model)
     pretty_printed_model = DSLPrettyPrinter(decimal_precision=decimal_precision).visit(
-        model
+        model_obj
     )
 
-    synthesis_options = model.model_dump(
+    synthesis_options = model_obj.model_dump(
         include={"constraints", "preferences"}, exclude_none=True
     )
 

classiq/synthesis.py

@@ -1,4 +1,4 @@
-from typing import Any, NewType, Optional
+from typing import Any, NewType, Optional, Union
 
 import pydantic
 
@@ -12,6 +12,8 @@ from classiq.interface.model.model import Model, SerializedModel
 from classiq import QuantumProgram
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
+from classiq.qmod.create_model_function import create_model
+from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
 
 SerializedQuantumProgram = NewType("SerializedQuantumProgram", str)
 
@@ -69,19 +71,30 @@ async def synthesize_async(
 
 
 def synthesize(
-    serialized_model: SerializedModel, auto_show: bool = False
+    model: Union[SerializedModel, QFunc, GenerativeQFunc],
+    auto_show: bool = False,
+    constraints: Optional[Constraints] = None,
+    preferences: Optional[Preferences] = None,
 ) -> SerializedQuantumProgram:
     """
     Synthesize a model with the Classiq engine to receive a quantum program.
     [More details](https://docs.classiq.io/latest/reference-manual/synthesis/)
 
     Args:
-        serialized_model: A model object serialized as a string.
-        auto_show: boolean. whether to call `show` on the output
+        model: The entry point of the Qmod model - a qfunc named 'main' (or alternatively the output of 'create_model').
+        auto_show: Whether to 'show' the synthesized model (False by default).
+        constraints: Constraints for the synthesis of the model. See Constraints (Optional).
+        preferences: Preferences for the synthesis of the model. See Preferences (Optional).
 
     Returns:
         SerializedQuantumProgram: Quantum program serialized as a string. (See: QuantumProgram)
     """
+    if isinstance(model, (QFunc, GenerativeQFunc)):
+        serialized_model = create_model(
+            model, constraints=constraints, preferences=preferences
+        )
+    else:
+        serialized_model = model
     result = async_utils.run(synthesize_async(serialized_model))
     if auto_show:
         show(result)
@@ -91,7 +104,7 @@ def synthesize(
 def set_preferences(
     serialized_model: SerializedModel,
     preferences: Optional[Preferences] = None,
-    **kwargs: Any
+    **kwargs: Any,
 ) -> SerializedModel:
     """
     Overrides the preferences of a (serialized) model and returns the updated model.
@@ -139,7 +152,7 @@ def update_preferences(
 def set_constraints(
     serialized_model: SerializedModel,
     constraints: Optional[Constraints] = None,
-    **kwargs: Any
+    **kwargs: Any,
 ) -> SerializedModel:
     """
     Overrides the constraints of a (serialized) model and returns the updated model.
@@ -187,7 +200,7 @@ def update_constraints(
 def set_execution_preferences(
     serialized_model: SerializedModel,
     execution_preferences: Optional[ExecutionPreferences] = None,
-    **kwargs: Any
+    **kwargs: Any,
 ) -> SerializedModel:
     """
     Overrides the execution preferences of a (serialized) model and returns the updated model.

{classiq-0.67.0.dist-info → classiq-0.68.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.67.0
+Version: 0.68.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary