classiq 0.43.2__py3-none-any.whl → 0.44.0__py3-none-any.whl

classiq/interface/server/global_versions.py

@@ -1,13 +1,13 @@
-from datetime import datetime
-from typing import Any, Dict
+from datetime import date, datetime
+from typing import Any, Dict, Union
 
 import pydantic
 from pydantic import BaseModel
 
 
 class DeprecationInfo(BaseModel):
-    deprecation_date: datetime = pydantic.Field()
-    removal_date: datetime = pydantic.Field()
+    deprecation_date: Union[date, datetime] = pydantic.Field()
+    removal_date: Union[date, datetime] = pydantic.Field()
 
 
 class GlobalVersions(BaseModel):

classiq/interface/server/routes.py

@@ -72,3 +72,5 @@ CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX
 )
+
+STATIC_SEMANTICS_VALIDATION_PATH = "/validate_static_semantics"

classiq/interface/source_reference.py

@@ -0,0 +1,59 @@
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.helpers.hashable_pydantic_base_model import (
+    HashablePydanticBaseModel,
+)
+
+
+def _identify_ipynb_cell(file_name: str) -> bool:
+    file_path = Path(file_name)
+    base_file = file_path.name
+    if re.fullmatch(r"\d*\.py", base_file) is None:
+        return False
+    parent_folder = file_path.parent
+    return re.fullmatch(r"ipykernel_\d*", parent_folder.name) is not None
+
+
+def _prepare_file_string(file_name: str) -> str:
+    if _identify_ipynb_cell(file_name):
+        return "ipynb cell "
+    return f"file {os.path.basename(file_name)} "
+
+
+class SourceReference(HashablePydanticBaseModel):
+    start_line: int
+    start_column: int
+    end_line: int
+    end_column: int
+    file_name: Optional[str] = pydantic.Field(default=None)
+
+    def __str__(self) -> str:
+        file_string = _prepare_file_string(self.file_name) if self.file_name else ""
+        start_character_string = (
+            f" character {self.start_column + 1}" if self.start_column > 0 else ""
+        )
+        return f"{file_string}line {self.start_line + 1}{start_character_string}"
+
+
+class SourceReferencedError(pydantic.BaseModel):
+    error: str
+    source_ref: Optional[SourceReference] = None
+    function: Optional[str] = None
+
+    def __str__(self) -> str:
+        source_referenced_error = (
+            f"{self.error}\n\t\tat {self.source_ref}"
+            if self.source_ref is not None
+            else self.error
+        )
+        function_scoped_error = (
+            f"{source_referenced_error} in function {self.function}"
+            if self.function is not None
+            else source_referenced_error
+        )
+        return function_scoped_error

classiq/qmod/__init__.py

@@ -6,8 +6,7 @@ from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
 from .qmod_constant import QConstant
 from .qmod_parameter import Array, CArray, CBool, CInt, CReal
-from .qmod_struct import struct
-from .qmod_variable import Input, Output, QArray, QBit, QNum
+from .qmod_variable import Input, Output, QArray, QBit, QNum, QStruct
 from .quantum_callable import QCallable, QCallableList
 from .quantum_function import create_model
 from .write_qmod import write_qmod
@@ -26,11 +25,11 @@ __all__ = [
     "QCallable",
     "QCallableList",
     "QConstant",
+    "QStruct",
     "cfunc",
     "create_model",
     "get_expression_numeric_attributes",
     "qfunc",
-    "struct",
     "symbolic",
     "write_qmod",
 ] + _builtins_all

classiq/qmod/builtins/functions.py

@@ -473,13 +473,6 @@ def exponentiation_with_depth_constraint(
     pass
 
 
-@qfunc(external=True)
-def qft(
-    target: QArray[QBit],
-) -> None:
-    pass
-
-
 @qfunc(external=True)
 def qpe_flexible(
     unitary_with_power: QCallable[CInt],
@@ -624,7 +617,6 @@ def cc_modular_add(
     phi_b: QArray[QBit],
     c1: QBit,
     c2: QBit,
-    aux: QBit,
 ) -> None:
     pass
 
@@ -636,7 +628,6 @@ def c_modular_multiply(
     b: QArray[QBit],
     x: QArray[QBit],
     ctrl: QBit,
-    aux: QBit,
 ) -> None:
     pass
 
@@ -655,7 +646,6 @@ def inplace_c_modular_multiply(
     a: CInt,
     x: QArray[QBit],
     ctrl: QBit,
-    aux: QBit,
 ) -> None:
     pass
 
@@ -793,6 +783,34 @@ def swap_test(
     pass
 
 
+@qfunc(external=True)
+def _prepare_uniform_trimmed_state_step(
+    size_lsb: CInt,
+    ctrl_val: CInt,
+    lsbs_val: CInt,
+    ctrl_var: QNum,
+    rotation_var: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def prepare_uniform_trimmed_state(
+    m: CInt,
+    q: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def prepare_uniform_interval_state(
+    start: CInt,
+    end: CInt,
+    q: QArray[QBit],
+) -> None:
+    pass
+
+
 @qfunc(external=True)
 def prepare_ghz_state(
     size: CInt,
@@ -894,6 +912,13 @@ def modular_increment(
     pass
 
 
+@qfunc(external=True)
+def qft(
+    target: QArray[QBit],
+) -> None:
+    pass
+
+
 __all__ = [
     "permute",
     "apply",
@@ -951,7 +976,6 @@ __all__ = [
     "suzuki_trotter",
     "qdrift",
     "exponentiation_with_depth_constraint",
-    "qft",
     "qpe_flexible",
     "qpe",
     "single_pauli",
@@ -985,6 +1009,9 @@ __all__ = [
     "qaoa_penalty",
     "full_hea",
     "swap_test",
+    "_prepare_uniform_trimmed_state_step",
+    "prepare_uniform_trimmed_state",
+    "prepare_uniform_interval_state",
     "prepare_ghz_state",
     "prepare_exponential_state",
     "prepare_bell_state",
@@ -998,4 +1025,5 @@ __all__ = [
     "qct_type2",
     "qst_type2",
     "modular_increment",
+    "qft",
 ]

classiq/qmod/builtins/operations.py

@@ -1,14 +1,29 @@
 import inspect
 import sys
+import warnings
 from types import FrameType
-from typing import Any, Callable, Final, List, Mapping, Union, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Final,
+    List,
+    Mapping,
+    Optional,
+    Union,
+    overload,
+)
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
 )
+from classiq.interface.generator.functions.classical_type import Integer
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import (
     BinaryOperation,
@@ -25,7 +40,6 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq import Integer
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QVar
 from classiq.qmod.quantum_callable import QCallable
@@ -68,36 +82,51 @@ def if_(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ClassicalIf(
             condition=Expression(expr=str(condition)),
-            then=_operand_to_body(then),
-            else_=_operand_to_body(else_) if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
+            then=_operand_to_body(then, "then"),
+            else_=_operand_to_body(else_, "else") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
             source_ref=source_ref,
         )
     )
 
 
-@overload
+@overload  # FIXME: Remove overloading (CAD-21932)
 def control(
-    ctrl: Union[QBit, QArray[QBit]], operand: Union[QCallable, Callable[[], None]]
+    ctrl: Union[QBit, QArray[QBit]], stmt_block: Union[QCallable, Callable[[], None]]
 ) -> None:
     pass
 
 
 @overload
-def control(ctrl: SymbolicExpr, operand: Union[QCallable, Callable[[], None]]) -> None:
+def control(
+    ctrl: SymbolicExpr, stmt_block: Union[QCallable, Callable[[], None]]
+) -> None:
     pass
 
 
 def control(
     ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
-    operand: Union[QCallable, Callable[[], None]],
+    stmt_block: Optional[Union[QCallable, Callable[[], None]]] = None,
+    operand: Optional[Union[QCallable, Callable[[], None]]] = None,
 ) -> None:
-    _validate_operand(operand)
+    if operand is not None:
+        warnings.warn(
+            "Parameter 'operand' of function 'control' has been renamed to "
+            "'stmt_block'. Parameter 'operand' will be deprecated in a future "
+            "release.\nHint: Change `control(ctrl=..., operand=...)` to "
+            "`control(ctrl=..., stmt_block=...)` or `control(..., ...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        stmt_block = operand
+    if TYPE_CHECKING:
+        assert stmt_block is not None
+    _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         Control(
             expression=Expression(expr=str(ctrl)),
-            body=_operand_to_body(operand),
+            body=_operand_to_body(stmt_block, "stmt_block"),
             source_ref=source_ref,
         )
     )
@@ -135,18 +164,53 @@ def inplace_xor(
     )
 
 
+@overload  # FIXME: Remove overloading (CAD-21932)
 def within_apply(
-    compute: Callable[[], None],
-    action: Callable[[], None],
+    within: Callable[[], None],
+    apply: Callable[[], None],
 ) -> None:
-    _validate_operand(compute)
-    _validate_operand(action)
+    pass
+
+
+@overload
+def within_apply(
+    within: Callable[[], List[None]],
+    apply: Callable[[], List[None]],
+) -> None:
+    pass
+
+
+def within_apply(  # type:ignore[misc]
+    within: Optional[Callable[[], None]] = None,
+    apply: Optional[Callable[[], None]] = None,
+    compute: Optional[Callable[[], None]] = None,
+    action: Optional[Callable[[], None]] = None,
+) -> None:
+    if compute is not None or action is not None:
+        warnings.warn(
+            "Parameters 'compute' and 'action' of function 'within_apply' have "
+            "been renamed to 'within' and 'apply' respectively. Parameters 'compute' "
+            "and 'action' will be deprecated in a future release.\nHint: Change "
+            "`within_apply(compute=..., action=...)` to "
+            "`within_apply(within=..., apply=...)` or `within_apply(..., ...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    if compute is not None:
+        within = compute
+    if action is not None:
+        apply = action
+    if TYPE_CHECKING:
+        assert within is not None
+        assert apply is not None
+    _validate_operand(within)
+    _validate_operand(apply)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         WithinApply(
-            compute=_operand_to_body(compute),
-            action=_operand_to_body(action),
+            compute=_operand_to_body(within, "within"),
+            action=_operand_to_body(apply, "apply"),
             source_ref=source_ref,
         )
     )
@@ -158,13 +222,20 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
     source_ref = get_source_ref(sys._getframe(1))
     iteration_operand = prepare_arg(
         QuantumOperandDeclaration(
-            name=REPEAT_OPERATOR_NAME, param_decls={"index": Integer()}
+            name=REPEAT_OPERATOR_NAME,
+            positional_arg_declarations=[
+                ClassicalParameterDeclaration(name="index", classical_type=Integer()),
+            ],
         ),
         iteration,
         repeat.__name__,
+        "iteration",
     )
     if not isinstance(iteration_operand, QuantumLambdaFunction):
-        raise ClassiqValueError("`repeat`'s `iteration` argument must be a callable.")
+        raise ClassiqValueError(
+            "Argument 'iteration' to 'repeat' should be a callable that takes one integer argument."
+        )
+
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         Repeat(
             iter_var=inspect.getfullargspec(iteration).args[0],
@@ -175,35 +246,93 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
     )
 
 
+@overload  # FIXME: Remove overloading (CAD-21932)
 def power(
-    power: Union[SymbolicExpr, int],
-    operand: Union[QCallable, Callable[[], None]],
+    exponent: SymbolicExpr,
+    stmt_block: Union[QCallable, Callable[[], None]],
 ) -> None:
-    _validate_operand(operand)
+    pass
+
+
+@overload
+def power(
+    exponent: int,
+    stmt_block: Union[QCallable, Callable[[], None]],
+) -> None:
+    pass
+
+
+def power(
+    exponent: Optional[Union[SymbolicExpr, int]] = None,
+    stmt_block: Optional[Union[QCallable, Callable[[], None]]] = None,
+    power: Optional[Union[SymbolicExpr, int]] = None,
+    operand: Optional[Union[QCallable, Callable[[], None]]] = None,
+) -> None:
+    if power is not None or operand is not None:
+        warnings.warn(
+            "Parameters 'exponent' and 'operand' of function 'power' have been "
+            "renamed to 'exponent' and 'stmt_block' respectively. Parameters "
+            "'exponent' and 'operand' will be deprecated in a future release.\nHint: "
+            "Change `power(power=..., operand=...)` to "
+            "`power(exponent=..., stmt_block=...)` or `power(..., ...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    if power is not None:
+        exponent = power
+    if operand is not None:
+        stmt_block = operand
+    if TYPE_CHECKING:
+        assert exponent is not None
+        assert stmt_block is not None
+    _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         Power(
-            power=Expression(expr=str(power)),
-            body=_operand_to_body(operand),
+            power=Expression(expr=str(exponent)),
+            body=_operand_to_body(stmt_block, "stmt_block"),
             source_ref=source_ref,
         )
     )
 
 
+@overload  # FIXME: Remove overloading (CAD-21932)
+def invert(stmt_block: QCallable) -> None:
+    pass
+
+
+@overload
+def invert(stmt_block: Callable[[], None]) -> None:
+    pass
+
+
 def invert(
-    operand: Union[QCallable, Callable[[], None]],
+    stmt_block: Optional[Union[QCallable, Callable[[], None]]] = None,
+    operand: Optional[Union[QCallable, Callable[[], None]]] = None,
 ) -> None:
-    _validate_operand(operand)
+    if operand is not None:
+        warnings.warn(
+            "Parameter 'operand' of function 'invert' has been renamed to "
+            "'stmt_block'. Parameter 'operand' will be deprecated in a future "
+            "release.\nHint: Change `invert(operand=...)` to `invert(stmt_block=...)` "
+            "or `invert(...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        stmt_block = operand
+    if TYPE_CHECKING:
+        assert stmt_block is not None
+    _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        Invert(body=_operand_to_body(operand), source_ref=source_ref)
+        Invert(body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref)
     )
 
 
-def _validate_operand(operand: Any) -> None:
-    if operand is not None:
+def _validate_operand(stmt_block: Any) -> None:
+    if stmt_block is not None:
         return
     currentframe: FrameType = inspect.currentframe()  # type: ignore[assignment]
     operation_frame: FrameType = currentframe.f_back  # type: ignore[assignment]
@@ -215,7 +344,7 @@ def _validate_operand(operand: Any) -> None:
     operand_arg_name = context[0].split("_validate_operand(")[1].split(")")[0]
 
     error_message = (
-        f"{operation_name} is missing required argument for {operand_arg_name}"
+        f"{operation_name!r} is missing required argument for {operand_arg_name!r}."
     )
     error_message += _get_operand_hint(
         operation_name=operation_name,
@@ -236,6 +365,7 @@ def _get_operand_hint_args(
                 else f"{param.name}=..."
             )
             for param in params.values()
+            if param.name != "operand"  # FIXME: Remove compatibility (CAD-21932)
         ]
     )
 
@@ -244,27 +374,28 @@ def _get_operand_hint(
     operation_name: str, operand_arg_name: str, params: Mapping[str, inspect.Parameter]
 ) -> str:
     return (
-        f"\nHint: To create an operand, do not call quantum gates directly "
-        f"`{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'H(q)')})`. "
-        f"Instead, use a lambda function "
-        f"`{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'lambda: H(q)')})` "
-        f"or a quantum function "
-        f"`{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'my_func')})`"
+        f"\nHint: To call a function under {operation_name!r} use a lambda function as in "
+        f"'{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'lambda: f(q)')})' "
+        f"or pass the quantum function directly as in "
+        f"'{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'f')})'."
     )
 
 
-def _operand_to_body(callable_: Union[QCallable, Callable[[], None]]) -> StatementBlock:
+def _operand_to_body(
+    callable_: Union[QCallable, Callable[[], None]], param_name: str
+) -> StatementBlock:
     op_name = sys._getframe(1).f_code.co_name
     if (
         isinstance(callable_, QCallable)
         and len(callable_.func_decl.positional_arg_declarations) > 0
     ):
         raise ClassiqValueError(
-            f"Operand argument {callable_.func_decl.name!r} to {op_name!r} should "
-            f"receive 0 parameters, not "
-            f"{len(callable_.func_decl.positional_arg_declarations)}"
+            f"Callable argument {callable_.func_decl.name!r} to {op_name!r} should "
+            f"not accept arguments."
         )
-    to_operand = prepare_arg(QuantumOperandDeclaration(name=""), callable_, op_name)
+    to_operand = prepare_arg(
+        QuantumOperandDeclaration(name=""), callable_, op_name, param_name
+    )
     if isinstance(to_operand, str):
         return [QuantumFunctionCall(function=to_operand)]
     elif isinstance(to_operand, QuantumLambdaFunction):