classiq 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

classiq/qmod/native/pretty_printer.py

@@ -0,0 +1,311 @@
+from typing import Dict, List
+
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ConcreteClassicalType,
+)
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.generator.visitor import NodeType, Visitor
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.model import Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
+    AmplitudeLoadingOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+)
+from classiq.interface.model.quantum_function_call import (
+    OperandIdentifier,
+    QuantumFunctionCall,
+)
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_if_operation import QuantumIfOperation
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+)
+from classiq.interface.model.quantum_variable_declaration import (
+    QuantumVariableDeclaration,
+)
+from classiq.interface.model.statement_block import StatementBlock
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApplyOperation
+
+from classiq import Bool, ClassicalList, Integer, Pauli, Real, Struct, StructDeclaration
+from classiq.qmod.native.expression_to_qmod import transform_expression
+from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
+
+
+class DSLPrettyPrinter(Visitor):
+    def __init__(self, decimal_precision: int = DEFAULT_DECIMAL_PRECISION) -> None:
+        self._level = 0
+        self._decimal_precision = decimal_precision
+
+    def visit(self, node: NodeType) -> str:
+        res = super().visit(node)
+        if not isinstance(res, str):
+            raise AssertionError(f"Pretty printing for {type(node)} is not supported ")
+        return res
+
+    def visit_Model(self, model: Model) -> str:
+        struct_decls = [self.visit(struct_decl) for struct_decl in model.types]
+        func_defs = [self.visit(func_def) for func_def in model.functions]
+        constants = [self.visit(constant) for constant in model.constants]
+        classical_code = (
+            f"cscope ```\n{model.classical_execution_code}\n```"
+            if model.classical_execution_code
+            else ""
+        )
+        return "\n".join([*constants, *struct_decls, *func_defs, classical_code])
+
+    def visit_Constant(self, constant: Constant) -> str:
+        return f"{self._indent}{self.visit(constant.name)}: {self.visit(constant.const_type)} = {self.visit(constant.value)};\n"
+
+    def _visit_arg_decls(self, func_def: QuantumFunctionDeclaration) -> str:
+        gen_time_args = ", ".join(
+            self.visit(arg_decl)
+            for arg_decl in func_def.get_positional_arg_decls()
+            if not isinstance(arg_decl, PortDeclaration)
+        )
+        quantum_args = ", ".join(
+            self.visit(arg_decl)
+            for arg_decl in func_def.get_positional_arg_decls()
+            if isinstance(arg_decl, PortDeclaration)
+        )
+        gen_time_arg_list = f"<{gen_time_args}>" if gen_time_args else ""
+        return f"{gen_time_arg_list}({quantum_args})"
+
+    def visit_QuantumFunctionDeclaration(
+        self, func_decl: QuantumFunctionDeclaration
+    ) -> str:
+        return f"qfunc {func_decl.name}{self._visit_arg_decls(func_decl)}"
+
+    def visit_StructDeclaration(self, struct_decl: StructDeclaration) -> str:
+        return f"struct {struct_decl.name} {{\n{self._visit_variables(struct_decl.variables)}}}\n"
+
+    def _visit_variables(self, variables: Dict[str, ConcreteClassicalType]) -> str:
+        self._level += 1
+        variables_str = "".join(
+            f"{self._indent}{self.visit(field_name)}: {self.visit(var_decl)};\n"
+            for field_name, var_decl in variables.items()
+        )
+        self._level -= 1
+        return variables_str
+
+    def visit_QuantumVariableDeclaration(
+        self, var_decl: QuantumVariableDeclaration
+    ) -> str:
+        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
+
+    def visit_PortDeclaration(self, port_decl: PortDeclaration) -> str:
+        dir_str = (
+            f"{port_decl.direction} "
+            if port_decl.direction != PortDeclarationDirection.Inout
+            else ""
+        )
+        return f"{dir_str}{self.visit_QuantumVariableDeclaration(port_decl)}"
+
+    def visit_QuantumBit(self, qtype: QuantumBit) -> str:
+        return "qbit"
+
+    def visit_QuantumBitvector(self, qtype: QuantumBitvector) -> str:
+        if qtype.length is not None:
+            if qtype.length.is_evaluated() and qtype.length.to_int_value() == 1:
+                return "qbit"
+            return f"qbit[{self.visit(qtype.length)}]"
+        return "qbit[]"
+
+    def visit_QuantumNumeric(self, qtype: QuantumNumeric) -> str:
+        params = ""
+        if qtype.size is not None:
+            assert qtype.is_signed is not None
+            assert qtype.fraction_digits is not None
+
+            params = "<{}>".format(
+                ", ".join(
+                    self.visit(param)
+                    for param in [qtype.size, qtype.is_signed, qtype.fraction_digits]
+                )
+            )
+
+        return f"qnum{params}"
+
+    def visit_ClassicalParameterDeclaration(
+        self, cparam: ClassicalParameterDeclaration
+    ) -> str:
+        return f"{cparam.name}: {self.visit(cparam.classical_type)}"
+
+    def visit_Integer(self, ctint: Integer) -> str:
+        return "int"
+
+    def visit_Real(self, ctint: Real) -> str:
+        return "real"
+
+    def visit_Bool(self, ctbool: Bool) -> str:
+        return "bool"
+
+    def visit_Pauli(self, ctbool: Pauli) -> str:
+        return "Pauli"
+
+    def visit_ClassicalList(self, ctlist: ClassicalList) -> str:
+        return f"{self.visit(ctlist.element_type)}[]"
+
+    def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
+        return f"{self.visit(ctarray.element_type)}[{ctarray.size}]"
+
+    def visit_Struct(self, struct: Struct) -> str:
+        return struct.name
+
+    def visit_VariableDeclarationStatement(
+        self, local_decl: VariableDeclarationStatement
+    ) -> str:
+        return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)};\n"
+
+    def visit_QuantumOperandDeclaration(
+        self, op_decl: QuantumOperandDeclaration
+    ) -> str:
+        return f"{op_decl.name}: qfunc{[] if op_decl.is_list else ''} {self._visit_arg_decls(op_decl)}"
+
+    def visit_NativeFunctionDefinition(self, func_def: NativeFunctionDefinition) -> str:
+        self._level += 1
+        body = "".join(self.visit(qvar_decl) for qvar_decl in func_def.body)
+        self._level -= 1
+        return f"{self.visit_QuantumFunctionDeclaration(func_def)} {{\n{body}}}\n"
+
+    def visit_QuantumFunctionCall(self, func_call: QuantumFunctionCall) -> str:
+        gen_time_args = ", ".join(
+            self.visit(arg_decl)
+            for arg_decl in func_call.get_positional_args()
+            if not isinstance(arg_decl, HandleBinding)
+        )
+        gen_time_arg_list = f"<{gen_time_args}>" if gen_time_args else ""
+        quantum_args = ", ".join(
+            self.visit(arg_decl)
+            for arg_decl in func_call.get_positional_args()
+            if isinstance(arg_decl, HandleBinding)
+        )
+        return f"{self._indent}{func_call.func_name}{f'[{self.visit(func_call.function.index)}]' if isinstance(func_call.function, OperandIdentifier) else ''}{gen_time_arg_list}({quantum_args});\n"
+
+    def visit_QuantumIfOperation(self, op: QuantumIfOperation) -> str:
+        quantum_if = f"{self._indent}quantum_if ({self.visit(op.expression)}) {{\n"
+        operand = op.then
+        if not isinstance(operand, QuantumLambdaFunction):
+            raise AssertionError(
+                "Expected quantum_if to be implemented using a lambda function"
+            )
+        quantum_if += self._visit_body(operand.body)
+        quantum_if += f"{self._indent}}}\n"
+        return quantum_if
+
+    def visit_WithinApplyOperation(self, op: WithinApplyOperation) -> str:
+        action = op.action
+        compute = op.compute
+        if not isinstance(action, QuantumLambdaFunction) or not isinstance(
+            compute, QuantumLambdaFunction
+        ):
+            raise AssertionError(
+                "Expected within-apply to be implemented using a lambda functions"
+            )
+        within_apply_code = f"{self._indent}within {{\n"
+        within_apply_code += self._visit_body(compute.body)
+        within_apply_code += f"{self._indent}}} apply {{\n"
+        within_apply_code += self._visit_body(action.body)
+        within_apply_code += f"{self._indent}}}\n"
+        return within_apply_code
+
+    def _visit_body(self, body: StatementBlock) -> str:
+        code = ""
+        self._level += 1
+        for statement in body:
+            code += self.visit(statement)
+        self._level -= 1
+        return code
+
+    def visit_InplaceBinaryOperation(self, op: InplaceBinaryOperation) -> str:
+        return (
+            f"{self._indent}{op.operation.value}({op.value.name}, {op.target.name});\n"
+        )
+
+    def _visit_pack_expr(self, vars: List[HandleBinding]) -> str:
+        if len(vars) == 1:
+            return self.visit(vars[0])
+
+        var_list_str = ", ".join(self.visit(var) for var in vars)
+        return f"{{{var_list_str}}}"
+
+    def visit_Expression(self, expr: Expression) -> str:
+        return transform_expression(
+            expr.expr, level=self._level, decimal_precision=self._decimal_precision
+        )
+
+    def visit_QuantumLambdaFunction(self, qlambda: QuantumLambdaFunction) -> str:
+        assert qlambda.func_decl is not None
+        gen_time_args = ", ".join(
+            qlambda.rename_params.get(arg_decl.name, arg_decl.name)
+            for arg_decl in qlambda.func_decl.get_positional_arg_decls()
+            if not isinstance(arg_decl, PortDeclaration)
+        )
+        quantum_args = ", ".join(
+            arg_decl.name
+            for arg_decl in qlambda.func_decl.get_positional_arg_decls()
+            if isinstance(arg_decl, PortDeclaration)
+        )
+        gen_time_arg_list = f"<{gen_time_args}>" if gen_time_args else ""
+        body = self._visit_body(qlambda.body)
+        return f"lambda{gen_time_arg_list}({quantum_args}) {{\n{body}{self._indent}}}"
+
+    def visit_HandleBinding(self, var_ref: HandleBinding) -> str:
+        return var_ref.name
+
+    def visit_SlicedHandleBinding(self, var_ref: SlicedHandleBinding) -> str:
+        return str(var_ref)
+
+    def visit_SubscriptHandleBinding(self, var_ref: SubscriptHandleBinding) -> str:
+        return str(var_ref)
+
+    def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
+        op = "^=" if arith_op.inplace_result else "="
+        return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)};\n"
+
+    def visit_AmplitudeLoadingOperation(
+        self, amplitude_loading_op: AmplitudeLoadingOperation
+    ) -> str:
+        return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)};\n"
+
+    def _print_bind_handles(self, handles: List[HandleBinding]) -> str:
+        if len(handles) == 1:
+            return self.visit(handles[0])
+
+        return "{" + ", ".join(self.visit(handle) for handle in handles) + "}"
+
+    def visit_BindOperation(self, bind_op: BindOperation) -> str:
+        return f"{self._indent}{self._print_bind_handles(bind_op.in_handles)} -> {self._print_bind_handles(bind_op.out_handles)};\n"
+
+    def visit_list(self, node: list) -> str:
+        return "[" + ", ".join(self.visit(elem) for elem in node) + "]"
+
+    @property
+    def _indent(self) -> str:
+        return "  " * self._level

classiq/qmod/qfunc.py

@@ -0,0 +1,27 @@
+from typing import Callable, Optional, Union, overload
+
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.quantum_function import ExternalQFunc, QFunc
+
+
+@overload
+def qfunc(func: Callable, *, external: bool = False) -> QFunc: ...
+
+
+@overload
+def qfunc(func: None = None, *, external: bool) -> Callable[[Callable], QCallable]: ...
+
+
+def qfunc(
+    func: Optional[Callable] = None, *, external: bool = False
+) -> Union[Callable[[Callable], QCallable], QCallable]:
+    def wrapper(func: Callable) -> QCallable:
+        if external:
+            return ExternalQFunc(func)
+
+        return QFunc(func)
+
+    if func is not None:
+        return wrapper(func)
+
+    return wrapper

classiq/qmod/qmod_constant.py

@@ -0,0 +1,76 @@
+import inspect
+from typing import Any, Optional
+
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import QStructBase
+
+from classiq.exceptions import ClassiqError
+from classiq.qmod.declaration_inferrer import python_type_to_qmod
+from classiq.qmod.model_state_container import ModelStateContainer
+from classiq.qmod.qmod_parameter import QParam, QParamStruct
+
+
+class QConstant:
+    CURRENT_QMODULE: Optional[ModelStateContainer] = None
+
+    def __init__(self, name: str, py_type: type, value: Any) -> None:
+        self.name = name
+        self._py_type = py_type
+        self._value = value
+
+    @staticmethod
+    def set_current_model(qmodule: ModelStateContainer) -> None:
+        QConstant.CURRENT_QMODULE = qmodule
+
+    def add_to_model(self) -> None:
+        if QConstant.CURRENT_QMODULE is None:
+            raise ClassiqError(
+                "Error trying to add a constant to a model without a current QModule."
+            )
+
+        expr = str(self._value)
+        if (
+            self.name in QConstant.CURRENT_QMODULE.constants
+            and expr != QConstant.CURRENT_QMODULE.constants[self.name].value.expr
+        ):
+            raise ClassiqError(f"Constant {self.name} is already defined in the model")
+
+        if isinstance(self._value, QConstant):
+            QConstant.CURRENT_QMODULE.constants[self.name] = Constant(
+                name=self.name,
+                const_type=QConstant.CURRENT_QMODULE.constants[
+                    self._value.name
+                ].const_type,
+                value=Expression(expr=self._value.name),
+            )
+        else:
+            qmod_type = python_type_to_qmod(
+                self._py_type, qmodule=QConstant.CURRENT_QMODULE
+            )
+            if qmod_type is None:
+                raise ClassiqError("Invalid QMOD type")
+
+            QConstant.CURRENT_QMODULE.constants[self.name] = Constant(
+                name=self.name,
+                const_type=qmod_type,
+                value=Expression(expr=expr),
+            )
+
+    def __getattr__(self, name: str) -> QParam:
+        self.add_to_model()
+
+        py_type = type(self._value)
+        if (
+            QConstant.CURRENT_QMODULE is None
+            or not inspect.isclass(py_type)
+            or not issubclass(py_type, QStructBase)
+        ):
+            return self.__getattribute__(name)
+
+        return QParamStruct.get_field(
+            QConstant.CURRENT_QMODULE, self.name, py_type.__name__, name
+        )
+
+    def __str__(self) -> str:
+        return self.name

classiq/qmod/qmod_parameter.py

@@ -1,6 +1,12 @@
 import sys
-from typing import _GenericAlias  # type: ignore[attr-defined]
-from typing import Any, Generic, TypeVar, Union
+from typing import (  # type: ignore[attr-defined]
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    TypeVar,
+    Union,
+    _GenericAlias,
+)
 
 from typing_extensions import ParamSpec
 
@@ -19,8 +25,15 @@ from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 _T = TypeVar("_T")
 
 
-class QParam(Symbolic, Generic[_T]):
-    pass
+if TYPE_CHECKING:
+
+    class QParam(SymbolicExpr, Generic[_T]):
+        pass
+
+else:
+
+    class QParam(Symbolic, Generic[_T]):
+        pass
 
 
 class QParamScalar(QParam, SymbolicExpr):
@@ -46,7 +59,7 @@ class QParamList(QParam):
         )
 
     def __len__(self) -> int:
-        raise ValueError(
+        raise ClassiqValueError(
             "len(<expr>) is not supported for QMod lists - use <expr>.len() instead"
         )
 
@@ -63,22 +76,31 @@ class QParamStruct(QParam):
         self._struct_type = struct_type
 
     def __getattr__(self, field_name: str) -> QParam:
+        return QParamStruct.get_field(
+            self._qmodule, str(self), self._struct_type.name, field_name
+        )
+
+    @staticmethod
+    def get_field(
+        qmodule: ModelStateContainer,
+        variable_name: str,
+        struct_name: str,
+        field_name: str,
+    ) -> QParam:
         struct_decl = StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.get(
-            self._struct_type.name
+            struct_name, qmodule.type_decls.get(struct_name)
         )
-        if struct_decl is None:
-            struct_decl = self._qmodule.type_decls.get(self._struct_type.name)
         assert struct_decl is not None
         field_type = struct_decl.variables.get(field_name)
         if field_type is None:
             raise ClassiqValueError(
-                f"Struct {self._struct_type.name!r} doesn't have field {field_name!r}"
+                f"Struct {struct_name!r} doesn't have field {field_name!r}"
             )
 
         return create_param(
-            f"get_field({self},{field_name!r})",
+            f"get_field({variable_name},{field_name!r})",
             field_type,
-            qmodule=self._qmodule,
+            qmodule=qmodule,
         )
 
 
@@ -100,7 +122,7 @@ class Array(ArrayBase[_P]):
 def create_param(
     expr_str: str, ctype: ClassicalType, qmodule: ModelStateContainer
 ) -> QParam:
-    if isinstance(ctype, ClassicalList) or isinstance(ctype, ClassicalArray):
+    if isinstance(ctype, (ClassicalList, ClassicalArray)):
         return QParamList(expr_str, ctype, qmodule=qmodule)
     elif isinstance(ctype, Struct):
         return QParamStruct(expr_str, ctype, qmodule=qmodule)

classiq/qmod/qmod_struct.py

@@ -1,5 +1,5 @@
 import dataclasses
-from typing import Any, List, Type
+from typing import Any, Type
 
 from typing_extensions import dataclass_transform
 
@@ -16,7 +16,7 @@ def _qmod_val_to_expr_str(val: Any) -> str:
         )
         return f"struct_literal({type(val).__name__}, {kwargs_str})"
 
-    if isinstance(val, List):
+    if isinstance(val, list):
         elements_str = ", ".join([_qmod_val_to_expr_str(elem) for elem in val])
         return f"[{elements_str}]"
 
@@ -24,7 +24,7 @@ def _qmod_val_to_expr_str(val: Any) -> str:
 
 
 @dataclass_transform()
-def QStruct(user_class: Type) -> Type:  # noqa: N802 - for consistency with 'QFunc'
+def struct(user_class: Type) -> Type:
     def _new_repr(self: Any) -> str:
         return _qmod_val_to_expr_str(self)