classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/qmod/declaration_inferrer.py

@@ -1,160 +1,193 @@
 import dataclasses
-import inspect
 import sys
-from typing import Any, Callable, Dict, List, Optional, Type, get_args, get_origin
+from collections.abc import Sequence
+from enum import EnumMeta
+from typing import (
+    Any,
+    Callable,
+    Literal,
+    Optional,
+    get_args,
+    get_origin,
+    overload,
+)
 
 from typing_extensions import _AnnotatedAlias
 
-from classiq.interface.generator.functions.classical_type import (
-    Bool,
-    ClassicalArray,
-    ClassicalList,
-    ConcreteClassicalType,
-    Integer,
-    QStructBase,
-    Real,
-    Struct,
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
 )
+from classiq.interface.generator.types.enum_declaration import declaration_from_enum
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
+    AnonClassicalParameterDeclaration,
 )
-from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumOperandDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
-    QuantumFunctionDeclaration,
-    QuantumOperandDeclaration,
 )
 
-from classiq import StructDeclaration
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import ModelStateContainer
-from classiq.qmod.qmod_parameter import Array, QParam
-from classiq.qmod.qmod_variable import QVar, get_type_hint_expr
-from classiq.qmod.quantum_callable import QCallable, QCallableList
-from classiq.qmod.utilities import unmangle_keyword
-
-OPERAND_ARG_NAME = "arg{i}"
-
-
-def _version_portable_get_args(py_type: type) -> tuple:
-    if get_origin(py_type) is None:
-        return tuple()
-    if sys.version_info[0:2] < (3, 10):
-        return get_args(py_type)  # The result of __class_getitem__
-    else:
-        return get_args(py_type)[0]
-
-
-def _python_type_to_qmod(
-    py_type: type, *, qmodule: ModelStateContainer
-) -> Optional[ConcreteClassicalType]:
-    if py_type == int:
-        return Integer()
-    elif py_type == float:
-        return Real()
-    elif py_type == bool:
-        return Bool()
-    elif get_origin(py_type) == list:
-        return ClassicalList(
-            element_type=_python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
-        )
-    elif get_origin(py_type) == Array:
-        array_args = _version_portable_get_args(py_type)
-        if len(array_args) != 2:
-            raise ValueError(
-                "Array accepts two generic parameters in the form 'Array[<element-type>, <size>]'"
-            )
-        return ClassicalArray(
-            element_type=_python_type_to_qmod(array_args[0], qmodule=qmodule),
-            size=get_type_hint_expr(array_args[1]),
+from classiq.qmod.python_classical_type import PythonClassicalType
+from classiq.qmod.qmod_variable import QVar
+from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
+
+if sys.version_info[0:2] >= (3, 9):
+    from typing import Annotated
+
+
+class _PythonClassicalType(PythonClassicalType):
+    def __init__(self, qmodule: Optional[ModelStateContainer]):
+        super().__init__()
+        self.qmodule = qmodule
+
+    def register_enum(self, py_type: EnumMeta) -> None:
+        if (
+            self.qmodule is None
+            or py_type.__name__ in BUILTIN_ENUM_DECLARATIONS
+            or py_type.__name__ in self.qmodule.enum_decls
+        ):
+            return
+
+        enum_decl = declaration_from_enum(py_type)
+        self.qmodule.enum_decls[py_type.__name__] = enum_decl
+
+    def register_struct(self, py_type: type) -> None:
+        if (
+            self.qmodule is None
+            or py_type.__name__ in BUILTIN_STRUCT_DECLARATIONS
+            or py_type.__name__ in self.qmodule.type_decls
+        ):
+            return
+
+        struct_decl = StructDeclaration(
+            name=py_type.__name__,
+            variables={
+                f.name: self.convert(f.type) for f in dataclasses.fields(py_type)
+            },
         )
-    elif inspect.isclass(py_type) and issubclass(py_type, QStructBase):
-        _add_qmod_struct(py_type, qmodule=qmodule)
-        return Struct(name=py_type.__name__)
-    return None
-
-
-def _add_qmod_struct(
-    py_type: Type[QStructBase], *, qmodule: ModelStateContainer
-) -> None:
-    if (
-        py_type.__name__ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS
-        or py_type.__name__ in qmodule.type_decls.keys()
-    ):
-        return
-
-    qmodule.type_decls[py_type.__name__] = StructDeclaration(
-        name=py_type.__name__,
-        variables={
-            f.name: _python_type_to_qmod(f.type, qmodule=qmodule)
-            for f in dataclasses.fields(py_type)
-        },
-    )
+        self.qmodule.type_decls[py_type.__name__] = struct_decl
 
 
-def _extract_param_decl(
-    name: str, py_type: Any, *, qmodule: ModelStateContainer
-) -> ClassicalParameterDeclaration:
-    if len(get_args(py_type)) != 1:
-        raise ValueError("QParam takes exactly one generic argument")
-    py_type = get_args(py_type)[0]
-    return ClassicalParameterDeclaration(
-        name=name, classical_type=_python_type_to_qmod(py_type, qmodule=qmodule)
-    )
+def python_type_to_qmod(
+    py_type: type, *, qmodule: Optional[ModelStateContainer]
+) -> Optional[ConcreteClassicalType]:
+    return _PythonClassicalType(qmodule).convert(py_type)
 
 
-def _extract_port_decl(name: str, py_type: Any) -> PortDeclaration:
+def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
     # FIXME: CAD-13409
-    qtype: Type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
+    qtype: type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
     direction = qtype.port_direction(py_type)
     if isinstance(py_type, _AnnotatedAlias):
         py_type = py_type.__args__[0]
-    return PortDeclaration(
-        name=name,
+    param = AnonPortDeclaration(
+        name=None,
         direction=direction,
         quantum_type=qtype.to_qmod_quantum_type(py_type),
     )
+    if name is not None:
+        param = param.rename(name)
+    return param
 
 
 def _extract_operand_decl(
-    name: str, py_type: Any, qmodule: ModelStateContainer
-) -> QuantumOperandDeclaration:
-    qc_args = _version_portable_get_args(py_type)
-    arg_dict = {
-        OPERAND_ARG_NAME.format(i=i): arg_type for i, arg_type in enumerate(qc_args)
-    }
-    return QuantumOperandDeclaration(
+    name: Optional[str], py_type: Any, qmodule: Optional[ModelStateContainer]
+) -> AnonQuantumOperandDeclaration:
+    is_list = (get_origin(py_type) or py_type) is QCallableList
+    if get_origin(py_type) is list:
+        is_list = True
+        py_type = version_portable_get_args(py_type)[0]
+    type_args = version_portable_get_args(py_type)
+    if len(type_args) > 0 and isinstance(type_args[0], list):  # Callable support
+        type_args = tuple(type_args[0])
+    param_decls = [_extract_operand_param(arg_type) for arg_type in type_args]
+    param = AnonQuantumOperandDeclaration(
         name=name,
-        positional_arg_declarations=_extract_positional_args(arg_dict, qmodule=qmodule),
-        is_list=(get_origin(py_type) or py_type) is QCallableList,
+        positional_arg_declarations=_extract_positional_args(
+            param_decls, qmodule=qmodule
+        ),
+        is_list=is_list,
+    )
+    if name is not None:
+        param = param.rename(name)
+    return param
+
+
+def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
+    if sys.version_info[0:2] < (3, 9) or get_origin(py_type) is not Annotated:
+        return None, py_type
+    args = get_args(py_type)
+    if len(args) == 2:
+        if isinstance(args[1], PortDeclarationDirection):
+            return None, py_type
+        elif isinstance(args[1], str):
+            return args[1], args[0]
+        elif get_origin(args[1]) is Literal:
+            return version_portable_get_args(args[1])[0], args[0]
+    elif len(args) == 3 and isinstance(args[1], PortDeclarationDirection):
+        if isinstance(args[2], str):
+            return args[2], Annotated[args[0], args[1]]
+        elif get_origin(args[2]) is Literal:
+            return version_portable_get_args(args[2])[0], Annotated[args[0], args[1]]
+    raise ClassiqValueError(
+        f"Operand parameter declaration must be of the form <param-type> or "
+        f"Annotated[<param-type>, <param-name>]. Got {py_type}"
     )
 
 
+@overload
 def _extract_positional_args(
-    args: Dict[str, Any], qmodule: ModelStateContainer
-) -> List[PositionalArg]:
-    result: List[PositionalArg] = []
-    for name, py_type in args.items():
+    args: Sequence[tuple[str, Any]], qmodule: Optional[ModelStateContainer]
+) -> Sequence[PositionalArg]:
+    pass
+
+
+@overload
+def _extract_positional_args(
+    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+) -> Sequence[AnonPositionalArg]:
+    pass
+
+
+def _extract_positional_args(
+    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+) -> Sequence[AnonPositionalArg]:
+    result: list[AnonPositionalArg] = []
+    for name, py_type in args:
         if name == "return":
             continue
         name = unmangle_keyword(name)
-        if get_origin(py_type) is QParam:
-            result.append(_extract_param_decl(name, py_type, qmodule=qmodule))
+        classical_type = python_type_to_qmod(py_type, qmodule=qmodule)
+        if classical_type is not None:
+            param = AnonClassicalParameterDeclaration(
+                name=None,
+                classical_type=classical_type,
+            )
+            if name is not None:
+                param = param.rename(name)
+            result.append(param)
         elif QVar.from_type_hint(py_type) is not None:
             result.append(_extract_port_decl(name, py_type))
         else:
-            assert (get_origin(py_type) or py_type) is QCallable or (
-                get_origin(py_type) or py_type
-            ) is QCallableList
             result.append(_extract_operand_decl(name, py_type, qmodule=qmodule))
     return result
 
 
 def infer_func_decl(
-    py_func: Callable, qmodule: ModelStateContainer
-) -> QuantumFunctionDeclaration:
-    return QuantumFunctionDeclaration(
+    py_func: Callable, qmodule: Optional[ModelStateContainer] = None
+) -> NamedParamsQuantumFunctionDeclaration:
+    return NamedParamsQuantumFunctionDeclaration(
         name=unmangle_keyword(py_func.__name__),
         positional_arg_declarations=_extract_positional_args(
-            py_func.__annotations__, qmodule=qmodule
+            list(py_func.__annotations__.items()), qmodule=qmodule
         ),
     )

classiq/qmod/expression_query.py

@@ -0,0 +1,39 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
+from classiq.interface.model.quantum_type import QuantumNumeric
+
+from classiq.qmod.qmod_variable import QNum
+from classiq.qmod.symbolic_type import SymbolicTypes
+
+
+def get_expression_numeric_attributes(
+    vars: list[QNum],
+    expr: SymbolicTypes,
+    machine_precision: int = MAXIMAL_MACHINE_PRECISION,
+) -> tuple[int, bool, int]:
+    """
+    Computes and returns the numeric attributes of a given symbolic expression.
+
+    Args:
+        vars: A list of `QNum` variables used in the symbolic expression.
+        expr: The symbolic expression for which numeric attributes are to be computed.
+        machine_precision: The precision level of the machine for the computation. Defaults to MAXIMAL_MACHINE_PRECISION = 20.
+
+    Returns:
+        Tuple[int, bool, int]:
+            A tuple containing the following numeric attributes:
+            - The size in bits (int) required to represent the result.
+            - A boolean indicating whether the result is signed (bool).
+            - The number of fraction digits (int) in the result.
+
+    """
+    res_type = compute_arithmetic_result_type(
+        expr_str=str(expr),
+        var_types={str(var.get_handle_binding()): var.get_qmod_type() for var in vars},
+        machine_precision=machine_precision,
+    )
+    if TYPE_CHECKING:
+        assert isinstance(res_type, QuantumNumeric)
+    return res_type.size_in_bits, res_type.sign_value, res_type.fraction_digits_value

classiq/qmod/generative.py

@@ -0,0 +1,42 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any, Optional
+
+from classiq.interface.exceptions import ClassiqError
+from classiq.interface.generator.expressions.expression import Expression
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+_GENERATIVE_MODE: bool = False
+_FRONTEND_INTERPRETER: Optional["BaseInterpreter"] = None
+
+
+def is_generative_mode() -> bool:
+    return _GENERATIVE_MODE
+
+
+@contextmanager
+def generative_mode_context(generative: bool) -> Iterator[None]:
+    global _GENERATIVE_MODE
+    previous = _GENERATIVE_MODE
+    _GENERATIVE_MODE = generative
+    try:
+        yield
+    finally:
+        _GENERATIVE_MODE = previous
+
+
+def set_frontend_interpreter(interpreter: "BaseInterpreter") -> None:
+    global _FRONTEND_INTERPRETER
+    _FRONTEND_INTERPRETER = interpreter
+
+
+def get_frontend_interpreter() -> "BaseInterpreter":
+    if _FRONTEND_INTERPRETER is None:
+        raise ClassiqError("Interpreter was not set")
+    return _FRONTEND_INTERPRETER
+
+
+def interpret_expression(expr: str) -> Any:
+    return get_frontend_interpreter().evaluate(Expression(expr=expr)).value

classiq/qmod/model_state_container.py

@@ -1,13 +1,27 @@
-from typing import Dict
+from typing import TYPE_CHECKING
 
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.native_function_definition import (
+    NativeFunctionDefinition,
+)
 
-from classiq import StructDeclaration
+if TYPE_CHECKING:
+    from classiq.qmod.quantum_function import GenerativeQFunc
 
 
 class ModelStateContainer:
-    type_decls: Dict[str, StructDeclaration]
-    native_defs: Dict[str, NativeFunctionDefinition]
+    enum_decls: dict[str, EnumDeclaration]
+    type_decls: dict[str, StructDeclaration]
+    qstruct_decls: dict[str, QStructDeclaration]
+    native_defs: dict[str, NativeFunctionDefinition]
+    constants: dict[str, Constant]
+    functions_compilation_metadata: dict[str, CompilationMetadata]
+    generative_functions: dict[str, "GenerativeQFunc"]
+    function_dependencies: dict[str, list[str]]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/__init__.py

@@ -0,0 +1,7 @@
+from .pretty_printer import DSLPrettyPrinter
+
+__all__ = ["DSLPrettyPrinter"]
+
+
+def __dir__() -> list[str]:
+    return __all__

classiq/qmod/native/expression_to_qmod.py

@@ -0,0 +1,194 @@
+import ast
+import re
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+import numpy as np
+
+from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
+
+IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
+BINARY_OPS: Mapping[type[ast.operator], str] = {
+    ast.Add: "+",
+    ast.Sub: "-",
+    ast.Mult: "*",
+    ast.Div: "/",
+    ast.Mod: "%",
+    ast.Pow: "**",
+    ast.BitAnd: "&",
+    ast.BitOr: "|",
+    ast.BitXor: "^",
+    ast.LShift: "<<",
+    ast.RShift: ">>",
+}
+BOOL_OPS: Mapping[type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[type[ast.unaryop], str] = {
+    ast.UAdd: "+",
+    ast.USub: "-",
+    ast.Invert: "~",
+    ast.Not: "not",
+}
+COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
+    ast.Eq: "==",
+    ast.NotEq: "!=",
+    ast.Lt: "<",
+    ast.LtE: "<=",
+    ast.Gt: ">",
+    ast.GtE: ">=",
+}
+LIST_FORMAT_CHAR_LIMIT = 20
+
+
+@dataclass
+class ASTToQMODCode:
+    level: int
+    decimal_precision: Optional[int]
+    indent_seq: str = "  "
+
+    @property
+    def indent(self) -> str:
+        return self.level * self.indent_seq
+
+    def visit(self, node: ast.AST) -> str:
+        return self.ast_to_code(node)
+
+    def ast_to_code(self, node: ast.AST) -> str:
+        if isinstance(node, ast.Module):
+            return self.indent.join(self.ast_to_code(child) for child in node.body)
+        elif isinstance(node, ast.Attribute):
+            # Enum attribute access
+            if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
+                raise AssertionError("Error parsing enum attribute access")
+            if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
+                raise AssertionError("Error parsing enum attribute access")
+            return f"{node.value.id!s}::{node.attr!s}"
+        elif isinstance(node, ast.Name):
+            return node.id
+        elif isinstance(node, ast.Num):
+            if self.decimal_precision is None:
+                return str(node.n)
+            return str(np.round(node.n, self.decimal_precision))
+        elif isinstance(node, ast.Str):
+            return repr(node.s)
+        elif isinstance(node, ast.Constant):
+            return repr(node.value)
+        elif isinstance(node, ast.BinOp):
+            return "({} {} {})".format(
+                self.ast_to_code(node.left),
+                BINARY_OPS[type(node.op)],
+                self.ast_to_code(node.right),
+            )
+        elif isinstance(node, ast.UnaryOp):
+            unary_op = UNARY_OPS[type(node.op)]
+            space = " " if unary_op == "not" else ""
+            return f"({unary_op}{space}{self.ast_to_code(node.operand)})"
+        elif isinstance(node, ast.BoolOp):
+            return "({})".format(
+                (" " + BOOL_OPS[type(node.op)] + " ").join(
+                    self.ast_to_code(value) for value in node.values
+                )
+            )
+        elif isinstance(node, ast.Compare):
+            if len(node.ops) != 1 or len(node.comparators) != 1:
+                raise AssertionError("Error parsing comparison expression.")
+            return "({} {} {})".format(
+                self.ast_to_code(node.left),
+                COMPARE_OPS[type(node.ops[0])],
+                self.ast_to_code(node.comparators[0]),
+            )
+        elif isinstance(node, ast.List):
+            elts = node.elts
+            elements = self.indent_items(
+                lambda: [self.ast_to_code(element) for element in elts]
+            )
+            return f"[{elements}]"
+        elif isinstance(node, ast.Subscript):
+            return f"{self.ast_to_code(node.value)}[{_remove_redundant_parentheses(self.ast_to_code(node.slice))}]"
+        elif isinstance(node, ast.Slice):
+            # A QMOD expression does not support slice step
+            if node.lower is None or node.upper is None or node.step is not None:
+                raise AssertionError("Error parsing slice expression.")
+            return f"{self.ast_to_code(node.lower)}:{self.ast_to_code(node.upper)}"
+        elif isinstance(node, ast.Call):
+            func = self.ast_to_code(node.func)
+            if func == "get_field":
+                if len(node.args) != 2:
+                    raise AssertionError("Error parsing struct field access.")
+                field = str(self.ast_to_code(node.args[1])).replace("'", "")
+                if not IDENTIFIER.match(field):
+                    raise AssertionError("Error parsing struct field access.")
+                return f"{self.ast_to_code(node.args[0])}.{field}"
+            elif func == "struct_literal":
+                if len(node.args) != 1 or not isinstance(node.args[0], ast.Name):
+                    raise AssertionError("Error parsing struct literal.")
+                keywords = node.keywords
+                initializer_list = self.indent_items(
+                    lambda: [
+                        f"{keyword.arg}={self._cleaned_ast_to_code(keyword.value)}"
+                        for keyword in keywords
+                        if keyword.arg is not None
+                    ]
+                )
+                return f"{self.ast_to_code(node.args[0])} {{{initializer_list}}}"
+            else:
+                return "{}({})".format(
+                    func, ", ".join(self._cleaned_ast_to_code(arg) for arg in node.args)
+                )
+        elif isinstance(node, ast.Expr):
+            return self._cleaned_ast_to_code(node.value)
+        else:
+            raise AssertionError("Error parsing expression: unsupported AST node.")
+
+    def indent_items(self, items: Callable[[], list[str]]) -> str:
+        should_indent = (
+            len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
+        )
+        if should_indent:
+            self.level += 1
+            left_ws = "\n" + self.indent
+            inner_ws = ",\n" + self.indent
+        else:
+            left_ws = ""
+            inner_ws = ", "
+        items_ = items()
+        if should_indent:
+            self.level -= 1
+            right_ws = "\n" + self.indent
+        else:
+            right_ws = ""
+        return f"{left_ws}{inner_ws.join(items_)}{right_ws}"
+
+    def _cleaned_ast_to_code(self, node: ast.AST) -> str:
+        return _remove_redundant_parentheses(self.ast_to_code(node))
+
+
+def _remove_redundant_parentheses(expr: str) -> str:
+    if not (expr.startswith("(") and expr.endswith(")")):
+        return expr
+    parentheses_map: dict[int, int] = dict()
+    stack: list[int] = []
+    for index, char in enumerate(expr):
+        if char == "(":
+            stack.append(index)
+        elif char == ")":
+            parentheses_map[stack.pop()] = index
+    index = 0
+    original_length = len(expr)
+    while (
+        index in parentheses_map
+        and parentheses_map[index] == original_length - index - 1
+    ):
+        expr = expr[1:-1]
+        index += 1
+    return expr
+
+
+def transform_expression(
+    expr: str,
+    level: int = 0,
+    decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,
+) -> str:
+    return ASTToQMODCode(level=level, decimal_precision=decimal_precision).visit(
+        ast.parse(expr)
+    )