classiq 0.89.0__py3-none-any.whl → 0.90.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -1,5 +1,6 @@
 import inspect
 import sys
+import warnings
 from collections.abc import Mapping
 from types import FrameType
 from typing import (
@@ -12,7 +13,7 @@ from typing import (
     overload,
 )
 
-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.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -516,27 +517,54 @@ def invert(stmt_block: Union[QCallable, Callable[[], Statements]]) -> None:
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(invert_stmt)
 
 
+@overload
+def phase(phase_expr: Union[SymbolicExpr, float], theta: float = 1.0) -> None:
+    pass
+
+
+@overload
+def phase(*, expr: Union[SymbolicExpr, float], theta: float = 1.0) -> None:
+    pass
+
+
 @suppress_return_value
-def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
+def phase(
+    phase_expr: Union[SymbolicExpr, float, None] = None,
+    theta: float = 1.0,
+    expr: Any = None,
+) -> None:
     """
-    Applies a state-dependent phase shift to the quantum state.
+    Applies a state-dependent or fixed phase shift (Z rotation) to the quantum state.
 
-    This operation multiplies each basis state |x> by a complex phase factor `theta * expr(x)`,
-    where `expr` is a symbolic expression dependent on the state value `x`, and `theta` is a scalar multiplier.
+    This operation multiplies each computational-basis state $|x_1,x_2,\\ldots,x_n\\rangle$
+    by a complex phase factor $\\theta * \\text{phase_expr}(x_1,x_2,\\ldots,x_n)$, where
+    `phase_expr` is a symbolic expression that contains quantum variables $x_1,x_2,\\ldots,x_n$,
+    and `theta` is a scalar multiplier. If `phase_expr` contains no quantum variables,
+    all states are rotated by the same fixed angle.
 
     Args:
-        expr: A symbolic expression that evaluates to an angle (in radians) as a function of the quantum state value `x`.
-        theta: (Optional) A scalar multiplier for the evaluated expression. Defaults to 1.0.
+        phase_expr: A symbolic expression that evaluates to an angle (in radians) as a function of the state of the quantum variables occurring in it, if any, or otherwise a fixed value. Execution parameters are only allowed if no quantum variables occur in the expression.
+        theta: (Optional, allowed only together with quantum expressions) A scalar multiplier for the evaluated expression, optionally containing execution parameters. Defaults to 1.0.
 
     Note:
-        The `phase` operation is equivalent to a Z-rotation up to a global phase. It is commonly used
-        to apply relative phase shifts conditioned on the quantum state.
+        The `phase` statement is a generalization of the `PHASE()` atomic function, and
+        they are equivalent when the phase_expr is a single-qubit variable.
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if expr is not None:
+        warnings.warn(
+            "Parameter 'expr' of function 'phase' has been renamed to "
+            "'phase_expr'. Parameter 'expr' will no longer be supported starting on "
+            "2025-09-19 at the earliest.\nHint: Change `phase(expr=..., theta=...)` to "
+            "`phase(phase_expr=..., theta=...)` or `phase(..., ...)`.",
+            category=ClassiqDeprecationWarning,
+            stacklevel=2,
+        )
+        phase_expr = expr
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         PhaseOperation(
-            expression=Expression(expr=str(expr)),
+            expression=Expression(expr=str(phase_expr)),
             theta=Expression(expr=str(theta)),
             source_ref=source_ref,
         )

classiq/qmod/generative.py

@@ -4,10 +4,8 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.qmod.cparam import CParamScalar
 
 if TYPE_CHECKING:
@@ -47,6 +45,6 @@ def get_frontend_interpreter() -> "GenerativeInterpreter":
 
 def interpret_expression(expr: str) -> Any:
     val = get_frontend_interpreter().evaluate(Expression(expr=expr)).value
-    if isinstance(val, AnyClassicalValue):
+    if isinstance(val, QmodAnnotatedExpression):
         return CParamScalar(str(val))
     return val

classiq/qmod/native/pretty_printer.py

@@ -312,7 +312,7 @@ class DSLPrettyPrinter(ModelVisitor):
         return control
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
-        theta = f", {self.visit(op.theta)}" if op.theta else ""
+        theta = f", {self.visit(op.theta)}" if op.theta.expr != "1.0" else ""
         phase = f"{self._indent}phase ({self.visit(op.expression)}{theta});\n"
         return phase
 

classiq/qmod/pretty_print/pretty_printer.py

@@ -461,7 +461,7 @@ class PythonPrettyPrinter(ModelVisitor):
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
         self._imports["phase"] = 1
-        theta = f", {self.visit(op.theta)}" if op.theta is not None else ""
+        theta = f", {self.visit(op.theta)}" if op.theta.expr != "1.0" else ""
         return f"{self._indent}phase({self.visit(op.expression)}{theta})\n"
 
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:

classiq/qmod/qmod_constant.py

@@ -138,7 +138,7 @@ class QConstant(SymbolicExpr):
                 f"Constant {self.name!r} of type {self._py_type.__name__!r} does not "
                 f"have a 'len' property"
             )
-        len_expr = f"get_field({self.name}, 'len')"
+        len_expr = f"{self.name}.len"
         if is_generative_mode():
             return interpret_expression(len_expr)
         return cast(int, CParamScalar(len_expr))

classiq/qmod/qmod_parameter.py

@@ -100,7 +100,7 @@ class CParamList(CParam):
         if is_generative_mode():
             with generative_mode_context(False):
                 return interpret_expression(str(self.len))
-        return CParamScalar(f"get_field({self}, 'len')")
+        return CParamScalar(f"{self}.len")
 
 
 class CParamStruct(CParam):
@@ -135,7 +135,7 @@ class CParamStruct(CParam):
             )
 
         return create_param(
-            f"get_field({variable_name},{field_name!r})",
+            f"{variable_name}.{field_name}",
             field_type.model_copy(deep=True),
             qmodule=qmodule,
         )

classiq/qmod/qmod_variable.py

@@ -156,7 +156,7 @@ class QVar(Symbolic):
         if is_generative_mode():
             with generative_mode_context(False):
                 return interpret_expression(str(self.size))
-        return CParamScalar(f"get_field({self}, 'size')")
+        return CParamScalar(f"{self}.size")
 
     @property
     def type_name(self) -> str:
@@ -229,8 +229,8 @@ class QScalar(QVar, SymbolicExpr):
 
     def __ior__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
-            raise TypeError(
-                f"Invalid argument {other!r} for out-of-place arithmetic operation"
+            raise ClassiqValueError(
+                f"Invalid argument {str(other)!r} for out-of-place arithmetic operation"
             )
 
         self._insert_arith_operation(
@@ -240,8 +240,8 @@ class QScalar(QVar, SymbolicExpr):
 
     def __ixor__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
-            raise TypeError(
-                f"Invalid argument {other!r} for in-place arithmetic operation"
+            raise ClassiqValueError(
+                f"Invalid argument {str(other)!r} for in-place arithmetic operation"
             )
 
         self._insert_arith_operation(
@@ -251,8 +251,8 @@ class QScalar(QVar, SymbolicExpr):
 
     def __iadd__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
-            raise TypeError(
-                f"Invalid argument {other!r} for in-place arithmetic operation"
+            raise ClassiqValueError(
+                f"Invalid argument {str(other)!r} for in-place arithmetic operation"
             )
 
         self._insert_arith_operation(
@@ -262,8 +262,8 @@ class QScalar(QVar, SymbolicExpr):
 
     def __imul__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
-            raise TypeError(
-                f"Invalid argument {other!r} for out of ampltiude encoding operation"
+            raise ClassiqValueError(
+                f"Invalid argument {str(other)!r} for out of ampltiude encoding operation"
             )
 
         self._insert_amplitude_loading(other, get_source_ref(sys._getframe(1)))
@@ -432,7 +432,7 @@ class QNum(Generic[_P], QScalar):
         name: Union[None, str, HandleBinding] = None,
         size: Union[int, CInt, Expression, SymbolicExpr, None] = None,
         is_signed: Union[bool, CBool, Expression, SymbolicExpr, None] = None,
-        fraction_digits: Union[int, CInt, Expression, None] = None,
+        fraction_digits: Union[int, CInt, Expression, SymbolicExpr, None] = None,
         _expr_str: Optional[str] = None,
     ):
         if size is None and (is_signed is not None or fraction_digits is not None):
@@ -485,14 +485,14 @@ class QNum(Generic[_P], QScalar):
         if is_generative_mode():
             with generative_mode_context(False):
                 return interpret_expression(str(self.fraction_digits))
-        return CParamScalar(f"get_field({self}, 'fraction_digits')")
+        return CParamScalar(f"{self}.fraction_digits")
 
     @property
     def is_signed(self) -> Union[CParamScalar, bool]:
         if is_generative_mode():
             with generative_mode_context(False):
                 return interpret_expression(str(self.is_signed))
-        return CParamScalar(f"get_field({self}, 'is_signed')")
+        return CParamScalar(f"{self}.is_signed")
 
     def get_maximal_bounds(self) -> tuple[float, float]:
         if not is_generative_mode():
@@ -594,7 +594,7 @@ class QArray(ArrayBase[_P], QVar, NonSymbolicExpr):
             if is_generative_mode():
                 with generative_mode_context(False):
                     return interpret_expression(str(self.len))
-            return CParamScalar(f"get_field({self}, 'len')")
+            return CParamScalar(f"{self}.len")
 
     @classmethod
     def to_qvar(
@@ -669,7 +669,7 @@ class QStruct(QVar):
                 field_name: 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}')",
+                    f"{expr_str if expr_str is not None else str(origin)}.{field_name}",
                 )
                 for field_name, (field_class, field_type) in field_types.items()
             }
@@ -723,7 +723,7 @@ def _create_qvar_for_qtype(
                     field_name: _create_qvar_for_qtype(
                         field_type,
                         FieldHandleBinding(base_handle=origin, field=field_name),
-                        f"get_field({expr_str if expr_str is not None else str(origin)}, '{field_name}')",
+                        f"{expr_str if expr_str is not None else str(origin)}.{field_name}",
                     )
                     for field_name, field_type in struct_decl.fields.items()
                 },

classiq/qmod/quantum_expandable.py

@@ -286,7 +286,7 @@ class QTerminalCallable(QCallable):
         def len(self) -> CParamScalar:
             if not self.is_list:
                 raise ClassiqValueError("Cannot get length of a non-list operand")
-            return CParamScalar(f"get_field({self.func_decl.name}, 'len')")
+            return CParamScalar(f"{self.func_decl.name}.len")
 
     @property
     def func_decl(self) -> QuantumFunctionDeclaration:

classiq/synthesis.py

@@ -1,10 +1,14 @@
 from typing import Any, Optional, Union
 
-from classiq.interface.analyzer.result import QasmCode
+from classiq.interface.analyzer.result import QasmCode, QmodCode
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 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.preferences.qasm_to_qmod_params import (
+    QasmToQmodParams,
+    QmodFormat,
+)
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model, SerializedModel
 
 from classiq import QuantumProgram
@@ -87,12 +91,43 @@ def synthesize(
         serialized_model = model_obj.get_model()
     else:
         serialized_model = model
+        if preferences is not None:
+            serialized_model = set_preferences(
+                serialized_model, preferences=preferences
+            )
+        if constraints is not None:
+            serialized_model = set_constraints(
+                serialized_model, constraints=constraints
+            )
     result = async_utils.run(synthesize_async(serialized_model))
     if auto_show:
         show(result)
     return result
 
 
+async def qasm_to_qmod_async(params: QasmToQmodParams) -> QmodCode:
+    return await ApiWrapper.call_qasm_to_qmod_task(params)
+
+
+def qasm_to_qmod(qasm: str, qmod_format: QmodFormat) -> str:
+    """
+    Decompiles QASM to Native/Python Qmod.
+
+    Args:
+        qasm: QASM 2 or QASM 3 code
+        qmod_format: The requested output format
+
+    Returns:
+        The decompiled Qmod program
+    """
+
+    return async_utils.run(
+        qasm_to_qmod_async(
+            QasmToQmodParams(qasm=QasmCode(code=qasm), qmod_format=qmod_format)
+        )
+    ).code
+
+
 def set_preferences(
     serialized_model: SerializedModel,
     preferences: Optional[Preferences] = None,
@@ -241,6 +276,7 @@ def update_execution_preferences(
 
 __all__ = [
     "SerializedModel",
+    "qasm_to_qmod",
     "set_constraints",
     "set_execution_preferences",
     "set_preferences",

classiq/visualization.py

@@ -19,7 +19,7 @@ async def visualize_async(
             raise error
         analyzer_data = await ApiWrapper.get_analyzer_app_data(data_id)
         visual_model = await ApiWrapper.call_visualization_task(analyzer_data)
-    return SerializedVisualModel(visual_model.model_dump_json(indent=2))
+    return SerializedVisualModel(visual_model.model_dump_json())
 
 
 def visualize(

{classiq-0.89.0.dist-info → classiq-0.90.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.89.0
+Version: 0.90.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL