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

classiq/qmod/builtins/functions/standard_gates.py

@@ -405,7 +405,7 @@ def RZZ(theta: CReal, target: QArray[QBit, Literal[2]]) -> None:
 
 
 @qfunc(external=True)
-def CH(control: QBit, target: QBit) -> None:
+def CH(ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -423,7 +423,7 @@ def CH(control: QBit, target: QBit) -> None:
     $$
 
     Args:
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the Hadamard gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -432,7 +432,7 @@ def CH(control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CX(control: QBit, target: QBit) -> None:
+def CX(ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -450,7 +450,7 @@ def CX(control: QBit, target: QBit) -> None:
     $$
 
     Args:
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the Pauli-X gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -459,7 +459,7 @@ def CX(control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CY(control: QBit, target: QBit) -> None:
+def CY(ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -477,7 +477,7 @@ def CY(control: QBit, target: QBit) -> None:
     $$
 
     Args:
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the Pauli-Y gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -486,7 +486,7 @@ def CY(control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CZ(control: QBit, target: QBit) -> None:
+def CZ(ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -504,7 +504,7 @@ def CZ(control: QBit, target: QBit) -> None:
     $$
 
     Args:
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the Pauli-Z gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -513,7 +513,7 @@ def CZ(control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRX(theta: CReal, control: QBit, target: QBit) -> None:
+def CRX(theta: CReal, ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -532,7 +532,7 @@ def CRX(theta: CReal, control: QBit, target: QBit) -> None:
 
     Args:
         theta: The rotation angle in radians.
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the RX gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -541,7 +541,7 @@ def CRX(theta: CReal, control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRY(theta: CReal, control: QBit, target: QBit) -> None:
+def CRY(theta: CReal, ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -569,7 +569,7 @@ def CRY(theta: CReal, control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRZ(theta: CReal, control: QBit, target: QBit) -> None:
+def CRZ(theta: CReal, ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -597,7 +597,7 @@ def CRZ(theta: CReal, control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CPHASE(theta: CReal, control: QBit, target: QBit) -> None:
+def CPHASE(theta: CReal, ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -707,7 +707,7 @@ def U(theta: CReal, phi: CReal, lam: CReal, gam: CReal, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CCX(control: QArray[QBit, Literal[2]], target: QBit) -> None:
+def CCX(ctrl: QArray[QBit, Literal[2]], target: QBit) -> None:
     """
     [Qmod core-library function]
 

classiq/qmod/builtins/functions/variational.py

@@ -0,0 +1,37 @@
+from classiq.qmod.cparam import CReal
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray
+from classiq.qmod.qmod_variable import Output, QArray, QBit
+
+
+@qfunc(external=True)
+def encode_in_angle(data: CArray[CReal], qba: Output[QArray[QBit]]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Creates an angle encoding of n data points on n qubits.
+
+    Applies RY($\\pi$data[i]) on qba[i].
+
+    Args:
+        data: A classical array representing the data to encode.
+        qba: The array of qubits on which the data is encoded.
+    """
+    pass
+
+
+@qfunc(external=True)
+def encode_on_bloch(data: CArray[CReal], qba: Output[QArray]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Creates a dense angle encoding of n data points on n//2 qubits.
+
+    Encodes pairs of data points on a Bloch sphere, via RX($\\pi$data[2*i])RZ($\\pi$data[2*i+1]) on qba[i].
+    If the length of the data is odd then RX($\\pi$data[i]) is applied on the last qubit.
+
+    Args:
+        data: A classical array representing the data to encode.
+        qba: The QArray of QBits on which the data is encoded.
+    """
+    pass

classiq/qmod/create_model_function.py

@@ -155,9 +155,9 @@ def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Mo
 
 
 def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
+
     gen_functions = list(GEN_QFUNCS) + [
-        GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
-        for dec_func in DEC_QFUNCS
+        _get_gen_from_dec(dec_func) for dec_func in DEC_QFUNCS
     ]
     return [
         (
@@ -165,7 +165,7 @@ def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
             if gen_func.func_decl.name != MAIN_FUNCTION_NAME
             else GenerativeQFunc(
                 gen_func._py_callable,
-                gen_func.func_decl.copy(update={"name": GEN_MAIN_NAME}),
+                gen_func.func_decl.model_copy(update={"name": GEN_MAIN_NAME}),
             )
         )
         for gen_func in gen_functions
@@ -173,6 +173,16 @@ def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
     ]
 
 
+def _get_gen_from_dec(dec_func: QFunc) -> GenerativeQFunc:
+    synthesis_data = dec_func.synthesis_data
+    if synthesis_data is not None and synthesis_data.should_synthesize_separately:
+        raise ClassiqError(
+            """The model contains generative functions,
+            which cannot coexist with functions marked for separate synthesis"""
+        )
+    return GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
+
+
 def _interpret_generative_model(
     gen_model: Model, gen_functions: List[GenerativeQFunc]
 ) -> Dict[str, NativeFunctionDefinition]:
@@ -188,9 +198,9 @@ def _interpret_generative_model(
     expanded_gen_main_name = cast(
         QuantumFunctionCall, functions_dict[MAIN_FUNCTION_NAME].body[0]
     ).func_name
-    functions_dict[MAIN_FUNCTION_NAME] = functions_dict[expanded_gen_main_name].copy(
-        update={"name": MAIN_FUNCTION_NAME}
-    )
+    functions_dict[MAIN_FUNCTION_NAME] = functions_dict[
+        expanded_gen_main_name
+    ].model_copy(update={"name": MAIN_FUNCTION_NAME})
     functions_dict.pop(expanded_gen_main_name)
 
     return functions_dict

classiq/qmod/qmod_parameter.py

@@ -44,7 +44,9 @@ class CParamList(CParam):
         self._list_type = list_type
 
     def __getitem__(self, key: Any) -> CParam:
+        param_type = self._list_type.element_type
         if isinstance(key, slice):
+            param_type = self._list_type
             start = key.start if key.start is not None else ""
             stop = key.stop if key.stop is not None else ""
             if key.step is not None:
@@ -53,7 +55,7 @@ class CParamList(CParam):
                 key = f"{start}:{stop}"
         return create_param(
             f"({self})[{key}]",
-            self._list_type.element_type,
+            param_type,
             qmodule=self._qmodule,
         )
 

classiq/qmod/quantum_expandable.py

@@ -1,4 +1,5 @@
 import inspect
+import warnings
 from abc import ABC
 from dataclasses import is_dataclass
 from enum import Enum as PythonEnum
@@ -17,12 +18,16 @@ from typing import (
     overload,
 )
 
+import pydantic
 from sympy import Basic
 from typing_extensions import Self
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.concrete_types import PythonClassicalTypes
+from classiq.interface.generator.functions.concrete_types import (
+    NativePythonClassicalTypes,
+    PythonClassicalPydanticTypes,
+)
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
 )
@@ -334,15 +339,24 @@ 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]
+    try:
+        is_pydantic_classical_type = isinstance(
+            arg, pydantic.BaseModel
+        ) and not isinstance(arg, PythonClassicalPydanticTypes)
+    except ClassiqValueError:
+        is_pydantic_classical_type = False
+
+    is_incompatible_symbolic_expr = isinstance(arg, SymbolicExpr) and arg.is_quantum
+
     if (
-        not isinstance(
-            arg, (*PythonClassicalTypes, CParam, SymbolicExpr, Basic, PythonEnum)
-        )
-        and not is_dataclass(arg)  # type:ignore[unreachable]
-        or isinstance(arg, SymbolicExpr)
-        and arg.is_quantum
-    ):
-        func_name_message = "" if func_name is None else f" of function {func_name!r}"
+        is_native_or_compatible_type or is_pydantic_classical_type
+    ) or is_incompatible_symbolic_expr:
+        func_name_message = f" of function {func_name!r}" if func_name else ""
         raise ClassiqValueError(
             f"Argument {str(arg)!r} to parameter {arg_decl.name!r}{func_name_message} "
             f"has incompatible type; expected "
@@ -379,6 +393,7 @@ def _get_operand_hint(
 def _prepare_args(
     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):
         arg = None
@@ -401,6 +416,24 @@ def _prepare_args(
     return result
 
 
+def _apply_control_backward_compatibility(
+    decl: AnonQuantumFunctionDeclaration, kwargs: Dict[str, Any]
+) -> None:
+    from classiq.qmod.builtins.functions import __all__ as builtin_functions
+
+    if decl.name in builtin_functions and "control" in kwargs:
+        warnings.warn(
+            f"Parameter 'control' of function {decl.name!r} has been renamed to "
+            f"'ctrl'. Parameter 'control' will no longer be supported starting on "
+            f"4/11/24 at the earliest.\nHint: Change {decl.name}(control=...) to "
+            f"{decl.name}(ctrl=...).",
+            ClassiqDeprecationWarning,
+            stacklevel=6,
+        )
+        kwargs["ctrl"] = kwargs["control"]
+        kwargs.pop("control")
+
+
 def _create_quantum_function_call(
     decl_: QuantumFunctionDeclaration,
     index_: Optional[Union[CParamScalar, int]] = None,

classiq/qmod/quantum_function.py

@@ -10,7 +10,10 @@ from classiq.interface.executor.execution_preferences import ExecutionPreference
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.model.model import Model
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.native_function_definition import (
+    FunctionSynthesisData,
+    NativeFunctionDefinition,
+)
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
 )
@@ -32,6 +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
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
@@ -40,6 +44,14 @@ class QFunc(QExpandable):
             infer_func_decl(self._py_callable, qmodule=self._qmodule),
         )
 
+    @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 __call__(self, *args: Any, **kwargs: Any) -> None:
         super().__call__(*args, **kwargs)
         self.expand()
@@ -82,7 +94,17 @@ class QFunc(QExpandable):
             return
         super().expand()
         self._qmodule.native_defs[self.func_decl.name] = NativeFunctionDefinition(
-            **{**self.func_decl.dict(), **{"body": self.body}}
+            **{
+                **self.func_decl.model_dump(),
+                **{
+                    "body": self.body,
+                    "synthesis_data": (
+                        self.synthesis_data
+                        if self.synthesis_data is not None
+                        else FunctionSynthesisData()
+                    ),
+                },
+            },
         )
 
     def _add_constants_from_classical_code(

classiq/qmod/semantics/static_semantics_visitor.py

@@ -209,7 +209,9 @@ class StaticSemanticsVisitor(Visitor):
                         **self.current_scope.operands,
                     },
                 )
-            elif isinstance(op, InplaceBinaryOperation):
+            elif isinstance(op, InplaceBinaryOperation) and isinstance(
+                op.value, HandleBinding
+            ):
                 check_no_overlapping_quantum_args(
                     [op.target, op.value], op.operation.value
                 )

classiq/qmod/synthesize_separately.py

@@ -0,0 +1,16 @@
+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)
+        return qfunc
+    if isinstance(qfunc, GenerativeQFunc):
+        raise ClassiqError("Generative functions can not be synthesized separately")
+    if isinstance(qfunc, ExternalQFunc):
+        raise ClassiqError("External functions can not be synthesized separately")

classiq/qmod/type_attribute_remover.py

@@ -10,7 +10,7 @@ def decl_without_type_attributes(
     operand_declaration: AnonQuantumOperandDeclaration,
 ) -> AnonQuantumOperandDeclaration:
     remover = AttributeRemover()
-    return operand_declaration.copy(
+    return operand_declaration.model_copy(
         update=dict(
             positional_arg_declarations=[
                 remover.visit(arg) if isinstance(arg, PortDeclaration) else arg

classiq/qmod/write_qmod.py

@@ -31,14 +31,12 @@ def write_qmod(
         None
     """
 
-    model = Model.parse_raw(serialized_model)
+    model = Model.model_validate_json(serialized_model)
     pretty_printed_model = DSLPrettyPrinter(decimal_precision=decimal_precision).visit(
         model
     )
 
-    synthesis_options = model.dict(
-        include={"constraints", "preferences"}, exclude_unset=True
-    )
+    synthesis_options = model.model_dump(include={"constraints", "preferences"})
 
     synthesis_options_path = Path(f"{name}.{_SYNTHESIS_OPTIONS_SUFFIX}")
     if directory is not None:

classiq/synthesis.py

@@ -32,8 +32,8 @@ def show(quantum_program: SerializedQuantumProgram) -> None:
         [Visualization tool](https://docs.classiq.io/latest/reference-manual/analyzer/quantum-program-visualization-tool/)
     """
     try:
-        circuit = QuantumProgram.parse_raw(quantum_program)
-    except pydantic.error_wrappers.ValidationError as exc:
+        circuit = QuantumProgram.model_validate_json(quantum_program)
+    except pydantic.ValidationError as exc:
         raise ClassiqValueError(CANT_PARSE_QUANTUM_PROGRAM_MSG) from exc
     circuit.show()  # type: ignore[attr-defined]
 
@@ -42,7 +42,7 @@ async def quantum_program_from_qasm_async(qasm: str) -> SerializedQuantumProgram
     quantum_program = await ApiWrapper.get_generated_circuit_from_qasm(
         QasmCode(code=qasm)
     )
-    return SerializedQuantumProgram(quantum_program.json())
+    return SerializedQuantumProgram(quantum_program.model_dump_json())
 
 
 def quantum_program_from_qasm(qasm: str) -> SerializedQuantumProgram:
@@ -61,9 +61,9 @@ def quantum_program_from_qasm(qasm: str) -> SerializedQuantumProgram:
 async def synthesize_async(
     serialized_model: SerializedModel,
 ) -> SerializedQuantumProgram:
-    model = pydantic.parse_raw_as(Model, serialized_model)
+    model = Model.model_validate_json(serialized_model)
     quantum_program = await ApiWrapper.call_generation_task(model)
-    return SerializedQuantumProgram(quantum_program.json(indent=2))
+    return SerializedQuantumProgram(quantum_program.model_dump_json(indent=2))
 
 
 def synthesize(
@@ -109,7 +109,7 @@ def set_preferences(
                 "Missing preferences. Either pass `Preferences` object or pass keywords"
             )
 
-    model = pydantic.parse_raw_as(Model, serialized_model)
+    model = Model.model_validate_json(serialized_model)
     model.preferences = preferences
     return model.get_model()
 
@@ -127,11 +127,10 @@ def update_preferences(
     Returns:
         SerializedModel: The updated model with the new preferences applied.
     """
-    model = pydantic.parse_raw_as(Model, serialized_model)
+    model = Model.model_validate_json(serialized_model)
 
     for key, value in kwargs.items():
         setattr(model.preferences, key, value)
-
     return model.get_model()
 
 
@@ -158,7 +157,7 @@ def set_constraints(
                 "Missing constraints. Either pass `Constraints` object or pass keywords"
             )
 
-    model = pydantic.parse_raw_as(Model, serialized_model)
+    model = Model.model_validate_json(serialized_model)
     model.constraints = constraints
     return model.get_model()
 
@@ -176,11 +175,10 @@ def update_constraints(
     Returns:
         SerializedModel: The updated model with the new constraints applied.
     """
-    model = pydantic.parse_raw_as(Model, serialized_model)
+    model = Model.model_validate_json(serialized_model)
 
     for key, value in kwargs.items():
         setattr(model.constraints, key, value)
-
     return model.get_model()
 
 
@@ -208,7 +206,7 @@ def set_execution_preferences(
                 "Missing execution_preferences. Either pass `ExecutionPreferences` object or pass keywords"
             )
 
-    model = pydantic.parse_raw_as(Model, serialized_model)
+    model = Model.model_validate_json(serialized_model)
     model.execution_preferences = execution_preferences
     return model.get_model()
 
@@ -226,7 +224,7 @@ def update_execution_preferences(
     Returns:
         SerializedModel: The updated model with the new execution_preferences applied.
     """
-    model = pydantic.parse_raw_as(Model, serialized_model)
+    model = Model.model_validate_json(serialized_model)
 
     for key, value in kwargs.items():
         setattr(model.execution_preferences, key, value)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.51.1
+Version: 0.53.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary
@@ -46,7 +46,8 @@ Requires-Dist: numpy (>=1.26.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: packaging (>=23.2,<24.0)
 Requires-Dist: pandas (>=1.4.0,<3.0.0)
 Requires-Dist: plotly (>=5.7.0,<6.0.0)
-Requires-Dist: pydantic (>=1.9.1,<2.0.0)
+Requires-Dist: pydantic (>=2.9.0,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
 Requires-Dist: scipy (>=1.10.0,<2.0.0) ; python_version < "3.12"
 Requires-Dist: scipy (>=1.11.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: sympy (>=1.13.0,<2.0.0)