classiq 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

classiq/qmod/qmod_variable.py

@@ -1,17 +1,15 @@
 import abc
 import sys
+from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
 from typing import (  # type: ignore[attr-defined]
     TYPE_CHECKING,
+    Annotated,
     Any,
     ForwardRef,
     Generic,
-    Iterator,
     Literal,
-    Mapping,
     Optional,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     _GenericAlias,
@@ -20,7 +18,7 @@ from typing import (  # type: ignore[attr-defined]
     get_origin,
 )
 
-from typing_extensions import Annotated, ParamSpec, Self, _AnnotatedAlias
+from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
@@ -127,7 +125,7 @@ class QVar(Symbolic):
         raise NotImplementedError()
 
     @staticmethod
-    def from_type_hint(type_hint: Any) -> Optional[Type["QVar"]]:
+    def from_type_hint(type_hint: Any) -> Optional[type["QVar"]]:
         if _is_input_output_typehint(type_hint):
             return QVar.from_type_hint(type_hint.__args__[0])
         type_ = get_origin(type_hint) or type_hint
@@ -322,7 +320,7 @@ class QNum(Generic[_P], QScalar):
         super().__init__(name, _expr_str=_expr_str, depth=3)
 
     @classmethod
-    def _get_attributes(cls, type_hint: Any) -> Tuple[Any, Any, Any]:
+    def _get_attributes(cls, type_hint: Any) -> tuple[Any, Any, Any]:
         type_args = version_portable_get_args(type_hint)
         if len(type_args) == 0:
             return None, None, None
@@ -413,6 +411,9 @@ class QArray(ArrayBase[_P], QVar):
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
         )
 
+    def __setitem__(self, *args: Any) -> None:
+        pass
+
     def _get_subscript(self, index: Union[slice, int, SymbolicExpr]) -> Any:
         if isinstance(index, SymbolicExpr) and index.is_quantum:
             raise ClassiqValueError("Non-classical parameter for slicing")
@@ -492,7 +493,7 @@ class QArray(ArrayBase[_P], QVar):
             return CParamScalar(f"get_field({self}, 'len')")
 
     @classmethod
-    def _get_attributes(cls, type_hint: Any) -> Tuple[Type[QVar], Any]:
+    def _get_attributes(cls, type_hint: Any) -> tuple[type[QVar], Any]:
         type_args = version_portable_get_args(type_hint)
         if len(type_args) == 0:
             return QBit, None
@@ -505,7 +506,7 @@ class QArray(ArrayBase[_P], QVar):
                 "QArray receives two type arguments: QArray[element_type: QVar, "
                 "length: int | CInt]"
             )
-        return cast(Tuple[Type[QVar], Any], type_args)
+        return cast(tuple[type[QVar], Any], type_args)
 
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
@@ -597,7 +598,7 @@ class QStruct(QVar):
         base_handle = HandleBinding(name=origin) if isinstance(origin, str) else origin
         with _no_current_expandable():
             field_vars = {
-                field_name: cast(Type[QVar], field_class).to_qvar(
+                field_name: cast(type[QVar], field_class).to_qvar(
                     FieldHandleBinding(base_handle=base_handle, field=field_name),
                     field_type,
                     f"get_field({expr_str if expr_str is not None else str(origin)}, '{field_name}')",

classiq/qmod/quantum_expandable.py

@@ -9,10 +9,7 @@ from typing import (
     Any,
     Callable,
     ClassVar,
-    Dict,
-    List,
     Optional,
-    Type,
     Union,
     cast,
     overload,
@@ -74,15 +71,15 @@ ArgType = Union[CParam, QVar, QCallable]
 
 
 class QExpandable(QCallable, QExpandableInterface, ABC):
-    STACK: ClassVar[List["QExpandable"]] = list()
+    STACK: ClassVar[list["QExpandable"]] = list()
 
     def __init__(self, py_callable: Callable) -> None:
         self._qmodule: ModelStateContainer = QMODULE
         self._py_callable: Callable = py_callable
-        self._body: List[QuantumStatement] = list()
+        self._body: list[QuantumStatement] = list()
 
     @property
-    def body(self) -> List[QuantumStatement]:
+    def body(self) -> list[QuantumStatement]:
         return self._body
 
     def __enter__(self) -> Self:
@@ -93,7 +90,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
@@ -107,7 +104,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
             with self, generative_mode_context(False):
                 self._py_callable(*self._get_positional_args())
 
-    def infer_rename_params(self) -> Optional[List[str]]:
+    def infer_rename_params(self) -> Optional[list[str]]:
         return None
 
     def add_local_handle(
@@ -125,8 +122,8 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
     def append_statement_to_body(self, stmt: QuantumStatement) -> None:
         self._body.append(stmt)
 
-    def _get_positional_args(self) -> List[ArgType]:
-        result: List[ArgType] = []
+    def _get_positional_args(self) -> list[ArgType]:
+        result: list[ArgType] = []
         rename_params = self.infer_rename_params()
         if rename_params is not None and len(rename_params) != len(
             self.func_decl.positional_arg_declarations
@@ -179,7 +176,7 @@ class QLambdaFunction(QExpandable):
         if not is_generative_mode():
             super().expand()
 
-    def infer_rename_params(self) -> List[str]:
+    def infer_rename_params(self) -> list[str]:
         return inspect.getfullargspec(self._py_callable).args
 
 
@@ -313,7 +310,7 @@ def prepare_arg(
                     f"Quantum operand {param_name!r} cannot be initialized with a "
                     f"list of non-callables"
                 )
-            val = cast(List[Union[QCallable, Callable[[Any], None]]], val)
+            val = cast(list[Union[QCallable, Callable[[Any], None]]], val)
             return [prepare_arg(arg_decl, v, func_name, param_name) for v in val]
 
         if not isinstance(val, QCallable):
@@ -391,8 +388,8 @@ def _get_operand_hint(
 
 
 def _prepare_args(
-    decl: AnonQuantumFunctionDeclaration, arg_list: List[Any], kwargs: Dict[str, Any]
-) -> List[ArgValue]:
+    decl: AnonQuantumFunctionDeclaration, arg_list: list[Any], kwargs: dict[str, Any]
+) -> list[ArgValue]:
     _apply_control_backward_compatibility(decl, kwargs)
     result = []
     for idx, arg_decl in enumerate(decl.positional_arg_declarations):
@@ -417,7 +414,7 @@ def _prepare_args(
 
 
 def _apply_control_backward_compatibility(
-    decl: AnonQuantumFunctionDeclaration, kwargs: Dict[str, Any]
+    decl: AnonQuantumFunctionDeclaration, kwargs: dict[str, Any]
 ) -> None:
     from classiq.qmod.builtins.functions import __all__ as builtin_functions
 

classiq/qmod/quantum_function.py

@@ -3,15 +3,15 @@ import functools
 from dataclasses import is_dataclass
 from enum import EnumMeta
 from inspect import isclass
-from typing import Any, Callable, Dict, List, Optional, Tuple, get_origin
+from typing import Any, Callable, Optional, get_origin
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import (
-    FunctionSynthesisData,
     NativeFunctionDefinition,
 )
 from classiq.interface.model.quantum_function_declaration import (
@@ -35,7 +35,7 @@ class QFunc(QExpandable):
         _validate_no_gen_params(py_callable.__annotations__)
         super().__init__(py_callable)
         functools.update_wrapper(self, py_callable)
-        self._synthesis_data: Optional[FunctionSynthesisData] = None
+        self.compilation_metadata: Optional[CompilationMetadata] = None
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
@@ -45,12 +45,19 @@ class QFunc(QExpandable):
         )
 
     @property
-    def synthesis_data(self) -> Optional[FunctionSynthesisData]:
-        return self._synthesis_data
-
-    @synthesis_data.setter
-    def synthesis_data(self, value: FunctionSynthesisData) -> None:
-        self._synthesis_data = value
+    def should_synthesize_separately(self) -> bool:
+        if self.compilation_metadata is None:
+            return False
+        return self.compilation_metadata.should_synthesize_separately
+
+    @should_synthesize_separately.setter
+    def should_synthesize_separately(self, value: bool) -> None:
+        if self.compilation_metadata is None:
+            self.compilation_metadata = CompilationMetadata(
+                should_synthesize_separately=value
+            )
+        else:
+            self.compilation_metadata.should_synthesize_separately = value
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         super().__call__(*args, **kwargs)
@@ -62,15 +69,19 @@ class QFunc(QExpandable):
         execution_preferences: Optional[ExecutionPreferences] = None,
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
+        functions_compilation_metadata: Optional[dict[str, CompilationMetadata]] = None,
     ) -> Model:
+        if functions_compilation_metadata is None:
+            functions_compilation_metadata = dict()
         self._qmodule.enum_decls = dict()
         self._qmodule.type_decls = dict()
         self._qmodule.qstruct_decls = dict()
         self._qmodule.native_defs = dict()
         self._qmodule.constants = dict()
+        self._qmodule.functions_compilation_metadata = functions_compilation_metadata
         QConstant.set_current_model(self._qmodule)
         self.expand()
-        model_extra_settings: List[Tuple[str, Any]] = [
+        model_extra_settings: list[tuple[str, Any]] = [
             ("constraints", constraints),
             ("execution_preferences", execution_preferences),
             ("preferences", preferences),
@@ -86,6 +97,7 @@ class QFunc(QExpandable):
             enums=list(self._qmodule.enum_decls.values()),
             types=list(self._qmodule.type_decls.values()),
             qstructs=list(self._qmodule.qstruct_decls.values()),
+            functions_compilation_metadata=self._qmodule.functions_compilation_metadata,
             **{key: value for key, value in model_extra_settings if value},
         )
 
@@ -94,18 +106,12 @@ class QFunc(QExpandable):
             return
         super().expand()
         self._qmodule.native_defs[self.func_decl.name] = NativeFunctionDefinition(
-            **{
-                **self.func_decl.model_dump(),
-                **{
-                    "body": self.body,
-                    "synthesis_data": (
-                        self.synthesis_data
-                        if self.synthesis_data is not None
-                        else FunctionSynthesisData()
-                    ),
-                },
-            },
+            **{**self.func_decl.model_dump(), **{"body": self.body}}
         )
+        if self.compilation_metadata is not None:
+            self._qmodule.functions_compilation_metadata[self.func_decl.name] = (
+                self.compilation_metadata
+            )
 
     def _add_constants_from_classical_code(
         self, classical_execution_function: CFunc
@@ -137,6 +143,7 @@ class ExternalQFunc(QTerminalCallable):
     _decl: NamedParamsQuantumFunctionDeclaration
 
     def __init__(self, py_callable: Callable) -> None:
+        self._py_callable = py_callable
         decl = infer_func_decl(py_callable)
 
         py_callable.__annotations__.pop("return", None)
@@ -153,6 +160,12 @@ class ExternalQFunc(QTerminalCallable):
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self._decl
 
+    def get_implementation(self) -> NativeFunctionDefinition:
+        model = QFunc(self._py_callable).create_model()
+        return [
+            func for func in model.functions if func.name == self._py_callable.__name__
+        ][0]
+
 
 class GenerativeQFunc(QExpandable):
     def __init__(
@@ -183,7 +196,7 @@ class IllegalParamsError(ClassiqError):
         super().__init__(message + self._HINT)
 
 
-def _validate_no_gen_params(annotations: Dict[str, Any]) -> None:
+def _validate_no_gen_params(annotations: dict[str, Any]) -> None:
     _illegal_params = {
         name: annotation
         for name, annotation in annotations.items()

classiq/qmod/semantics/annotation.py

@@ -1,4 +1,4 @@
-from typing import Mapping
+from collections.abc import Mapping
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall

classiq/qmod/semantics/error_manager.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Iterator, List, Optional, Type
+from typing import Optional
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import CLASSIQ_SLACK_COMMUNITY_LINK
@@ -16,9 +17,9 @@ class ErrorManager:
         if hasattr(self, "_instantiated"):
             return
         self._instantiated = True
-        self._errors: List[SourceReferencedError] = []
-        self._current_nodes_stack: List[ASTNode] = []
-        self._call_stack: List[str] = []
+        self._errors: list[SourceReferencedError] = []
+        self._current_nodes_stack: list[ASTNode] = []
+        self._call_stack: list[str] = []
         self._ignore_errors: bool = False
 
     @contextmanager
@@ -31,7 +32,7 @@ class ErrorManager:
             self._ignore_errors = previous
 
     @property
-    def annotated_errors(self) -> List[str]:
+    def annotated_errors(self) -> list[str]:
         return [str(error) for error in self._errors]
 
     def add_error(self, error: str) -> None:
@@ -48,7 +49,7 @@ class ErrorManager:
                 )
             )
 
-    def get_errors(self) -> List[SourceReferencedError]:
+    def get_errors(self) -> list[SourceReferencedError]:
         return self._errors
 
     def clear(self) -> None:
@@ -58,7 +59,7 @@ class ErrorManager:
     def has_errors(self) -> bool:
         return len(self._errors) > 0
 
-    def report_errors(self, error_type: Type[Exception]) -> None:
+    def report_errors(self, error_type: type[Exception]) -> None:
         if self.has_errors():
             errors = self.annotated_errors
             self.clear()

classiq/qmod/semantics/static_semantics_visitor.py

@@ -1,15 +1,8 @@
+from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from typing import (
     Any,
-    Dict,
-    Iterator,
-    List,
-    Mapping,
     Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
 )
 
 from classiq.interface.exceptions import ClassiqSemanticError
@@ -59,6 +52,7 @@ from classiq.qmod.semantics.validation.func_call_validation import (
     validate_call_arguments,
 )
 from classiq.qmod.semantics.validation.handle_validation import resolve_handle
+from classiq.qmod.semantics.validation.main_validation import validate_main_function
 from classiq.qmod.semantics.validation.types_validation import (
     check_cstruct_has_fields,
     check_duplicate_types,
@@ -79,10 +73,10 @@ class StaticScope:
 
     def __init__(
         self,
-        parameters: List[str],
-        operands: Dict[str, QuantumOperandDeclaration],
-        variables_to_states: Dict[str, HandleState],
-        variables_to_types: Dict[str, ConcreteQuantumType],
+        parameters: list[str],
+        operands: dict[str, QuantumOperandDeclaration],
+        variables_to_states: dict[str, HandleState],
+        variables_to_types: dict[str, ConcreteQuantumType],
     ) -> None:
         self.parameters = parameters
         self.operands = operands
@@ -94,9 +88,9 @@ class StaticSemanticsVisitor(Visitor):
     def __init__(
         self,
         functions_dict: Mapping[str, QuantumFunctionDeclaration],
-        constants: List[str],
+        constants: list[str],
     ) -> None:
-        self._scope: List[StaticScope] = []
+        self._scope: list[StaticScope] = []
         self._error_manager = ErrorManager()
         self._functions_dict = functions_dict
         self._constants = constants
@@ -122,6 +116,7 @@ class StaticSemanticsVisitor(Visitor):
                 check_qstruct_flexibility(qstruct)
         for cstruct in model.types:
             check_cstruct_has_fields(cstruct)
+        validate_main_function(model.main_func)
         self.visit_BaseModel(model)
 
     def visit_NativeFunctionDefinition(
@@ -141,7 +136,7 @@ class StaticSemanticsVisitor(Visitor):
             parameter_declaration_names = [
                 decl.name for decl in func_def.positional_arg_declarations
             ]
-            seen_names: Set[str] = set()
+            seen_names: set[str] = set()
             for name in parameter_declaration_names:
                 if name in seen_names:
                     self._error_manager.add_error(
@@ -254,12 +249,12 @@ class StaticSemanticsVisitor(Visitor):
 
     def _get_renamed_parameters(
         self, lambda_func: QuantumLambdaFunction
-    ) -> Tuple[List[str], Dict[str, QuantumOperandDeclaration], List[PortDeclaration]]:
-        renamed_parameters: List[str] = []
-        renamed_operands: Dict[str, QuantumOperandDeclaration] = {}
-        renamed_ports: List[PortDeclaration] = []
+    ) -> tuple[list[str], dict[str, QuantumOperandDeclaration], list[PortDeclaration]]:
+        renamed_parameters: list[str] = []
+        renamed_operands: dict[str, QuantumOperandDeclaration] = {}
+        renamed_ports: list[PortDeclaration] = []
         for idx, param in enumerate(lambda_func.func_decl.positional_arg_declarations):
-            param_name = lambda_func.get_rename_params()[idx]
+            param_name = lambda_func.pos_rename_params[idx]
             if isinstance(param, AnonClassicalParameterDeclaration):
                 renamed_parameters.append(param_name)
             elif isinstance(param, AnonQuantumOperandDeclaration):
@@ -375,7 +370,7 @@ def resolve_function_calls(
 
 
 def static_semantics_analysis_pass(
-    model: Model, error_type: Optional[Type[Exception]] = ClassiqSemanticError
+    model: Model, error_type: Optional[type[Exception]] = ClassiqSemanticError
 ) -> None:
     StaticSemanticsVisitor(
         {**BUILTIN_FUNCTION_DECLARATIONS, **model.function_dict},
@@ -385,7 +380,7 @@ def static_semantics_analysis_pass(
         ErrorManager().report_errors(error_type)
 
 
-EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
+EXPECTED_TERMINAL_STATES: dict[PortDeclarationDirection, HandleState] = {
     PortDeclarationDirection.Output: HandleState.INITIALIZED,
     PortDeclarationDirection.Inout: HandleState.INITIALIZED,
 }
@@ -393,8 +388,8 @@ EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
 
 def initialize_variables_to_state(
     port_declarations: Sequence[PortDeclaration],
-) -> Dict[str, HandleState]:
-    variables_to_state: Dict[str, HandleState] = dict()
+) -> dict[str, HandleState]:
+    variables_to_state: dict[str, HandleState] = dict()
 
     for port_decl in port_declarations:
         variables_to_state[port_decl.name] = (

classiq/qmod/semantics/validation/constants_validation.py

@@ -1,4 +1,4 @@
-from typing import Sequence
+from collections.abc import Sequence
 
 from classiq.interface.generator.constant import Constant
 

classiq/qmod/semantics/validation/func_call_validation.py

@@ -1,4 +1,4 @@
-from typing import List, Mapping
+from collections.abc import Mapping
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
@@ -83,7 +83,7 @@ def _check_operand_against_declaration(
 
 
 def check_no_overlapping_quantum_args(
-    args: List[HandleBinding], func_name: str
+    args: list[HandleBinding], func_name: str
 ) -> None:
     for idx, arg in enumerate(args):
         for other_arg in args[idx + 1 :]:

classiq/qmod/semantics/validation/main_validation.py

@@ -0,0 +1,33 @@
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+)
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_declaration import PositionalArg
+
+from classiq import ClassicalParameterDeclaration
+from classiq.qmod.semantics.error_manager import append_error
+
+
+def validate_main_function(func: NativeFunctionDefinition) -> None:
+    for param in func.positional_arg_declarations:
+        _validate_main_param(param)
+
+
+def _validate_main_param(param: PositionalArg) -> None:
+    if isinstance(param, ClassicalParameterDeclaration):
+        _validate_main_classical_param_type(param.classical_type, param.name)
+
+
+def _validate_main_classical_param_type(
+    param: ConcreteClassicalType, param_name: str
+) -> None:
+    if isinstance(param, ClassicalList):
+        append_error(
+            param,
+            f"Classical array parameter {param_name!r} of function 'main' must must "
+            f"specify array length",
+        )
+    if isinstance(param, ClassicalArray):
+        _validate_main_classical_param_type(param.element_type, param_name)

classiq/qmod/semantics/validation/types_validation.py

@@ -1,4 +1,5 @@
-from typing import Sequence, Union
+from collections.abc import Sequence
+from typing import Union
 
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration

classiq/qmod/symbolic.py

@@ -2,10 +2,7 @@ import sys
 from typing import (
     TYPE_CHECKING,
     Any,
-    List,
     Optional,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     overload,
@@ -41,10 +38,10 @@ def symbolic_function(*args: Any, return_type: None = None) -> CParamScalar: ...
 
 
 @overload
-def symbolic_function(*args: Any, return_type: Type[T]) -> T: ...
+def symbolic_function(*args: Any, return_type: type[T]) -> T: ...
 
 
-def symbolic_function(*args: Any, return_type: Optional[Type[T]] = None) -> CParam:
+def symbolic_function(*args: Any, return_type: Optional[type[T]] = None) -> CParam:
     qmodule = (
         model_state_container.QMODULE
     )  # FIXME: https://classiq.atlassian.net/browse/CAD-15126
@@ -266,7 +263,7 @@ def catalan(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def Piecewise(*args: Tuple[SymbolicTypes, SymbolicTypes]) -> CParamScalar:  # noqa: N802
+def Piecewise(*args: tuple[SymbolicTypes, SymbolicTypes]) -> CParamScalar:  # noqa: N802
     return symbolic_function(*args)
 
 
@@ -299,7 +296,7 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
 
 
 def subscript(
-    amplitudes: Union[List[float], List[CReal], List[CParamScalar], CArray[CReal]],
+    amplitudes: Union[list[float], list[CReal], list[CParamScalar], CArray[CReal]],
     index: QNum,
 ) -> CParamScalar:
     return CParamScalar(expr=f"{amplitudes}[{index}]")
@@ -373,5 +370,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/symbolic_type.py

@@ -1,5 +1,5 @@
-from typing import Tuple, Union
+from typing import Union
 
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
-SymbolicTypes = Union[SymbolicExpr, int, float, bool, Tuple["SymbolicTypes", ...]]
+SymbolicTypes = Union[SymbolicExpr, int, float, bool, tuple["SymbolicTypes", ...]]

classiq/qmod/synthesize_separately.py

@@ -1,14 +1,13 @@
 from typing import Union
 
 from classiq.interface.exceptions import ClassiqError
-from classiq.interface.model.native_function_definition import FunctionSynthesisData
 
 from classiq.qmod.quantum_function import ExternalQFunc, GenerativeQFunc, QFunc
 
 
 def synthesize_separately(qfunc: Union[QFunc, GenerativeQFunc, ExternalQFunc]) -> QFunc:
     if isinstance(qfunc, QFunc):
-        qfunc.synthesis_data = FunctionSynthesisData(should_synthesize_separately=True)
+        qfunc.should_synthesize_separately = True
         return qfunc
     if isinstance(qfunc, GenerativeQFunc):
         raise ClassiqError("Generative functions can not be synthesized separately")

{classiq-0.53.0.dist-info → classiq-0.55.0.dist-info}/METADATA

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