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

classiq/qmod/pretty_print/pretty_printer.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Mapping, Optional, Tuple, Union, cast
 
 import black
 
@@ -6,21 +6,26 @@ from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
+)
+from classiq.interface.generator.functions.concrete_types import (
     ConcreteClassicalType,
-    TypeName,
+    ConcreteQuantumType,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.visitor import NodeType, Visitor
 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,
+    AnonClassicalParameterDeclaration,
 )
 from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
@@ -29,7 +34,7 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 from classiq.interface.model.invert import Invert
 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.port_declaration import AnonPortDeclaration
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
@@ -45,7 +50,8 @@ from classiq.interface.model.quantum_function_call import (
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
-    PositionalArg,
+    AnonPositionalArg,
+    AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
@@ -66,7 +72,13 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.interface.model.within_apply_operation import WithinApply
 
 import classiq
-from classiq import Bool, ClassicalList, Integer, Real, StructDeclaration
+from classiq import (
+    Bool,
+    ClassicalList,
+    Integer,
+    Real,
+    StructDeclaration,
+)
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
@@ -82,18 +94,25 @@ class VariableDeclarationAssignment(Visitor):
         return res  # type: ignore[return-value]
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> Tuple[str, Optional[List[str]]]:
+        self.pretty_printer._imports["QBit"] = 1
+
         return "QBit", None
 
     def visit_QuantumBitvector(
         self, qtype: QuantumBitvector
     ) -> Tuple[str, Optional[List[str]]]:
+        self.pretty_printer._imports["QArray"] = 1
+
+        element_type = self.pretty_printer.visit(qtype.element_type)
         if qtype.length is not None:
-            return "QArray", ["QBit", self.pretty_printer.visit(qtype.length)]
-        return "QArray", ["QBit"]
+            return "QArray", [element_type, self.pretty_printer.visit(qtype.length)]
+        return "QArray", [element_type]
 
     def visit_QuantumNumeric(
         self, qtype: QuantumNumeric
     ) -> Tuple[str, Optional[List[str]]]:
+        self.pretty_printer._imports["QNum"] = 1
+
         params = []
         if qtype.size is not None:
             assert qtype.is_signed is not None
@@ -106,6 +125,9 @@ class VariableDeclarationAssignment(Visitor):
 
         return "QNum", params
 
+    def visit_TypeName(self, qtype: TypeName) -> Tuple[str, None]:
+        return qtype.name, None
+
 
 class PythonPrettyPrinter(Visitor):
     def __init__(self, decimal_precision: int = DEFAULT_DECIMAL_PRECISION) -> None:
@@ -114,8 +136,9 @@ class PythonPrettyPrinter(Visitor):
         self._imports = {"qfunc": 1}
         self._import_enum = False
         self._import_dataclass = False
+        self._import_annotated = False
         self._symbolic_imports: Dict[str, int] = dict()
-        self._functions: Optional[Dict[str, QuantumFunctionDeclaration]] = None
+        self._functions: Optional[Mapping[str, QuantumFunctionDeclaration]] = None
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -130,11 +153,12 @@ class PythonPrettyPrinter(Visitor):
         }
         enum_decls = [self.visit(decl) for decl in model.enums]
         struct_decls = [self.visit(decl) for decl in model.types]
+        qstruct_decls = [self.visit(qstruct_decl) for qstruct_decl in model.qstructs]
         func_defs = [self.visit(func) for func in model.functions]
         constants = [self.visit(const) for const in model.constants]
         classical_code = self.format_classical_code(model.classical_execution_code)
 
-        code = f"{self.format_imports()}\n\n{self.join_code_parts(*constants, *enum_decls, *struct_decls, *func_defs, classical_code)}"
+        code = f"{self.format_imports()}\n\n{self.join_code_parts(*constants, *enum_decls, *struct_decls, *qstruct_decls, *func_defs, classical_code)}"
         return black.format_str(code, mode=black.FileMode())
 
     def format_classical_code(self, code: str) -> str:
@@ -162,6 +186,8 @@ class PythonPrettyPrinter(Visitor):
     @property
     def special_imports(self) -> str:
         imports = ""
+        if self._import_annotated:
+            imports += "from typing_extensions import Annotated\n"
         if self._import_dataclass:
             imports += "from dataclasses import dataclass\n"
         if self._import_enum:
@@ -178,7 +204,7 @@ class PythonPrettyPrinter(Visitor):
 
     def _visit_arg_decls(self, func_def: QuantumFunctionDeclaration) -> str:
         return ", ".join(
-            self.visit(arg_decl) for arg_decl in func_def.get_positional_arg_decls()
+            self.visit(arg_decl) for arg_decl in func_def.positional_arg_declarations
         )
 
     def visit_QuantumFunctionDeclaration(
@@ -205,7 +231,13 @@ class PythonPrettyPrinter(Visitor):
         self._import_dataclass = True
         return f"@dataclass\nclass {struct_decl.name}:\n{self._visit_variables(struct_decl.variables)}\n"
 
-    def _visit_variables(self, variables: Dict[str, ConcreteClassicalType]) -> str:
+    def visit_QStructDeclaration(self, qstruct_decl: QStructDeclaration) -> str:
+        self._imports["QStruct"] = 1
+        return f"class {qstruct_decl.name}(QStruct):\n{self._visit_variables(qstruct_decl.fields)}\n"
+
+    def _visit_variables(
+        self, variables: Mapping[str, Union[ConcreteClassicalType, ConcreteQuantumType]]
+    ) -> str:
         self._level += 1
         variables_str = "".join(
             f"{self._indent}{self.visit(field_name)}: {self.visit(var_decl)};\n"
@@ -219,8 +251,8 @@ class PythonPrettyPrinter(Visitor):
     ) -> str:
         return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
-    def visit_PortDeclaration(self, port_decl: PortDeclaration) -> str:
-        var = self.visit_QuantumVariableDeclaration(port_decl)
+    def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
+        var = f"{port_decl.name}: {self.visit(port_decl.quantum_type)}"
         var_name, var_type = var.split(": ")
         for direction in PortDeclarationDirection:
             if port_decl.direction == PortDeclarationDirection.Inout:
@@ -258,8 +290,8 @@ class PythonPrettyPrinter(Visitor):
 
         return f"QNum{params}"
 
-    def visit_ClassicalParameterDeclaration(
-        self, cparam: ClassicalParameterDeclaration
+    def visit_AnonClassicalParameterDeclaration(
+        self, cparam: AnonClassicalParameterDeclaration
     ) -> str:
         return f"{cparam.name}: {self.visit(cparam.classical_type)}"
 
@@ -284,11 +316,14 @@ class PythonPrettyPrinter(Visitor):
         return f"CArray[{self.visit(ctarray.element_type)}, {ctarray.size}]"
 
     def visit_TypeName(self, type_: TypeName) -> str:
+        self._import_type_name(type_)
+        return type_.name
+
+    def _import_type_name(self, type_: TypeName) -> None:
         if type_.name in dir(classiq.qmod.builtins.enums) + dir(
             classiq.qmod.builtins.structs
         ):
             self._imports[type_.name] = 1
-        return type_.name
 
     def visit_VariableDeclarationStatement(
         self, local_decl: VariableDeclarationStatement
@@ -296,32 +331,38 @@ class PythonPrettyPrinter(Visitor):
         type_name, params = VariableDeclarationAssignment(self).visit(
             local_decl.quantum_type
         )
-        self._imports[type_name] = 1
         params = [f'"{local_decl.name}"'] + (params or [])
         param_args = ", ".join(params)
         return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)} = {type_name}({param_args})\n"
 
-    def _visit_operand_arg_decl(self, arg_decl: PositionalArg) -> str:
-        if isinstance(arg_decl, QuantumVariableDeclaration):
-            return self.visit(arg_decl.quantum_type)
-        if isinstance(arg_decl, ClassicalParameterDeclaration):
-            return self.visit(arg_decl.classical_type)
-        if isinstance(arg_decl, QuantumOperandDeclaration):
-            return self.visit_QuantumOperandDeclaration(arg_decl)
-
-    def visit_QuantumOperandDeclaration(
-        self, op_decl: QuantumOperandDeclaration
+    def _visit_operand_arg_decl(self, arg_decl: AnonPositionalArg) -> str:
+        if isinstance(arg_decl, AnonPortDeclaration):
+            type_str = self.visit(arg_decl.quantum_type)
+        elif isinstance(arg_decl, AnonClassicalParameterDeclaration):
+            type_str = self.visit(arg_decl.classical_type)
+        else:
+            type_str = self.visit_AnonQuantumOperandDeclaration(arg_decl, no_param=True)
+        if arg_decl.name is None:
+            return type_str
+        self._import_annotated = True
+        return f'Annotated[{type_str}, "{arg_decl.name}"]'
+
+    def visit_AnonQuantumOperandDeclaration(
+        self, op_decl: AnonQuantumOperandDeclaration, no_param: bool = False
     ) -> str:
-        qcallable_identifier = "QCallable"
-        if op_decl.is_list:
-            qcallable_identifier = "QCallableList"
+        qcallable_identifier = "QCallableList" if op_decl.is_list else "QCallable"
         self._imports[qcallable_identifier] = 1
         args = ", ".join(
             self._visit_operand_arg_decl(arg_decl)
-            for arg_decl in op_decl.get_positional_arg_decls()
+            for arg_decl in op_decl.positional_arg_declarations
         )
+        param_name = "" if no_param else f"{op_decl.name}: "
+        return f"{param_name}{qcallable_identifier}" + (f"[{args}]" if args else "")
 
-        return f"{op_decl.name}: {qcallable_identifier}" + (f"[{args}]" if args else "")
+    def visit_QuantumOperandDeclaration(
+        self, op_decl: QuantumOperandDeclaration
+    ) -> str:
+        return self.visit_AnonQuantumOperandDeclaration(op_decl)
 
     def visit_NativeFunctionDefinition(self, func_def: NativeFunctionDefinition) -> str:
         self._level += 1
@@ -330,21 +371,27 @@ class PythonPrettyPrinter(Visitor):
         return f"{self.visit_QuantumFunctionDeclaration(func_def)} \n{body}\n"
 
     def visit_QuantumFunctionCall(self, func_call: QuantumFunctionCall) -> str:
-        if len(func_call.get_positional_args()) <= 2 or self._functions is None:
-            args = ", ".join(self.visit(arg) for arg in func_call.get_positional_args())
-        else:
-            func_decl = self._functions[func_call.func_name]
-            args = ", ".join(
-                f"{self.visit(arg_decl.name)}={self.visit(arg)}"
-                for arg_decl, arg in zip(
-                    func_decl.get_positional_arg_decls(),
-                    func_call.get_positional_args(),
-                )
-            )
+        args = self._get_args(func_call)
         if func_call.func_name in dir(classiq.qmod.builtins.functions):
             self._imports[func_call.func_name] = 1
         return f"{self._indent}{func_call.func_name}{f'[{self.visit(func_call.function.index)}]' if isinstance(func_call.function, OperandIdentifier) else ''}({args})\n"
 
+    def _get_args(self, func_call: QuantumFunctionCall) -> str:
+        if len(func_call.positional_args) > 2 and self._functions is not None:
+            func_decl = self._functions[func_call.func_name]
+            if all(
+                param.name is not None
+                for param in func_decl.positional_arg_declarations
+            ):
+                return ", ".join(
+                    f"{self.visit(cast(str, arg_decl.name))}={self.visit(arg)}"
+                    for arg_decl, arg in zip(
+                        func_decl.positional_arg_declarations,
+                        func_call.positional_args,
+                    )
+                )
+        return ", ".join(self.visit(arg) for arg in func_call.positional_args)
+
     def visit_Control(self, op: Control) -> str:
         self._imports["control"] = 1
         return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)})\n"
@@ -373,7 +420,7 @@ class PythonPrettyPrinter(Visitor):
         self, body: StatementBlock, operand_arguments: Optional[List[str]] = None
     ) -> str:
         if len(body) == 0:
-            return "None"
+            return "lambda: []"
         argument_string = (
             (" " + ", ".join(operand_arguments)) if operand_arguments else ""
         )
@@ -406,20 +453,19 @@ class PythonPrettyPrinter(Visitor):
         )
 
     def visit_QuantumLambdaFunction(self, qlambda: QuantumLambdaFunction) -> str:
-        assert qlambda.func_decl is not None
-        return self._visit_body(
-            qlambda.body,
-            list(qlambda.rename_params.values()),
-        )
+        return self._visit_body(qlambda.body, qlambda.get_rename_params())
 
     def visit_HandleBinding(self, var_ref: HandleBinding) -> str:
         return var_ref.name
 
     def visit_SlicedHandleBinding(self, var_ref: SlicedHandleBinding) -> str:
-        return f"{var_ref.name}[{self.visit(var_ref.start)}:{self.visit(var_ref.end)}]"
+        return f"{self.visit(var_ref.base_handle)}[{self.visit(var_ref.start)}:{self.visit(var_ref.end)}]"
 
     def visit_SubscriptHandleBinding(self, var_ref: SubscriptHandleBinding) -> str:
-        return f"{var_ref.name}[{self.visit(var_ref.index)}]"
+        return f"{self.visit(var_ref.base_handle)}[{self.visit(var_ref.index)}]"
+
+    def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
+        return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
     def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
         op = "^=" if arith_op.inplace_result else "|="

classiq/qmod/qfunc.py

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

classiq/qmod/qmod_parameter.py

@@ -14,10 +14,9 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
     ClassicalType,
-    Struct,
 )
 
-from classiq import StructDeclaration
+from classiq import Struct, StructDeclaration
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr