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

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -1,413 +0,0 @@
-from collections.abc import Mapping
-from enum import Enum
-from typing import Any, Callable, Union, get_args
-
-import sympy
-from sympy import Eq, Expr, Piecewise, Symbol
-
-from classiq.interface.exceptions import (
-    ClassiqExpansionError,
-    ClassiqInternalExpansionError,
-)
-from classiq.interface.generator.expressions.atomic_expression_functions import (
-    MEASUREMENT_FUNCTIONS,
-)
-from classiq.interface.generator.expressions.expression_types import (
-    ExpressionValue,
-    QmodStructInstance,
-)
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
-    ClassicalArrayProxy,
-    ClassicalSequenceProxy,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
-    ClassicalProxy,
-)
-from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
-    QmodQNumProxy,
-)
-from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
-    QmodQStructProxy,
-)
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.generator.expressions.type_proxy import TypeProxy
-from classiq.interface.generator.functions.classical_function_declaration import (
-    ClassicalFunctionDeclaration,
-)
-from classiq.interface.generator.functions.classical_type import (
-    Bool,
-    ClassicalArray,
-    ClassicalTuple,
-    ClassicalType,
-    OpaqueHandle,
-    QmodPyObject,
-    Real,
-    StructMetaType,
-)
-from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.helpers.backward_compatibility import zip_strict
-
-from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
-    BitwiseAnd,
-    BitwiseNot,
-    BitwiseOr,
-    BitwiseXor,
-    LogicalXor,
-    LShift,
-    RShift,
-)
-from classiq.model_expansions.model_tables import (
-    HandleIdentifier,
-    HandleTable,
-)
-from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
-    MISSING_SLICE_VALUE_PLACEHOLDER,
-)
-from classiq.model_expansions.sympy_conversion.sympy_to_python import (
-    sympy_to_python,
-)
-from classiq.model_expansions.utils.sympy_utils import is_constant_subscript
-from classiq.qmod.builtins.classical_functions import (
-    __all__ as qmod_classical_functions,
-)
-from classiq.qmod.model_state_container import QMODULE
-from classiq.qmod.utilities import qmod_val_to_expr_str
-
-
-def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
-    if isinstance(qmod_type, TypeName):
-        if (
-            isinstance(val, QmodStructInstance)
-            and val.struct_declaration == QMODULE.type_decls[qmod_type.name]
-        ):
-            return {
-                field_name: qmod_val_to_python(val.fields[field_name], field_type)
-                for field_name, field_type in val.struct_declaration.variables.items()
-            }
-
-        if isinstance(val, (Enum, int)):
-            return val
-
-    elif isinstance(qmod_type, ClassicalArray):
-        if isinstance(val, list):
-            return [qmod_val_to_python(elem, qmod_type.element_type) for elem in val]
-
-    elif isinstance(qmod_type, ClassicalTuple):
-        if isinstance(val, list):
-            return [
-                qmod_val_to_python(elem, elem_type)
-                for elem_type, elem in zip_strict(
-                    qmod_type.element_types, val, strict=True
-                )
-            ]
-
-    elif isinstance(qmod_type, OpaqueHandle):
-        if isinstance(val, HandleIdentifier):
-            return HandleTable.get_handle_object(val)
-
-    elif isinstance(val, Expr):
-        return sympy_to_python(val)
-
-    elif isinstance(qmod_type, Real):
-        if isinstance(val, (float, int)):
-            return val
-
-    elif isinstance(qmod_type, Bool):
-        if isinstance(val, bool):
-            return val
-
-    elif isinstance(qmod_type, StructMetaType):
-        if isinstance(val, TypeProxy):
-            return val.struct_declaration
-
-    elif isinstance(val, int):  # other scalars are represented as int
-        return val
-
-    raise ClassiqInternalExpansionError(
-        f"Bad value {val!r} of type {type(val)!r} for {qmod_type!r}"
-    )
-
-
-def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
-    if isinstance(qmod_type, TypeName):
-        if qmod_type.name in QMODULE.enum_decls:
-            return val
-
-        struct_decl = QMODULE.type_decls[qmod_type.name]
-        if not isinstance(val, Mapping):
-            raise ClassiqInternalExpansionError(
-                f"Bad value for struct {struct_decl.name}"
-            )
-        qmod_dict = {
-            field_name: python_val_to_qmod(val[field_name], field_type)
-            for field_name, field_type in struct_decl.variables.items()
-        }
-        return QmodStructInstance(struct_decl.model_copy(deep=True), qmod_dict)
-
-    if isinstance(qmod_type, ClassicalArray):
-        if not isinstance(val, list):
-            raise ClassiqInternalExpansionError("Bad value for list")
-        return [python_val_to_qmod(elem, qmod_type.element_type) for elem in val]
-
-    if isinstance(qmod_type, ClassicalTuple):
-        if not isinstance(val, list):
-            raise ClassiqInternalExpansionError("Bad value for list")
-        return [
-            python_val_to_qmod(elem, elem_type)
-            for elem, elem_type in zip_strict(val, qmod_type.element_types, strict=True)
-        ]
-
-    if isinstance(qmod_type, OpaqueHandle):
-        if not isinstance(val, QmodPyObject):
-            raise ClassiqInternalExpansionError("Bad value opaque handle")
-        return HandleTable.set_handle_object(val)
-
-    return val
-
-
-def python_call_wrapper(func: Callable, *args: ExpressionValue) -> Any:
-    func_decl = ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS[
-        func.__name__
-    ]
-    python_args = [
-        qmod_val_to_python(args[idx], param_type.classical_type)
-        for idx, param_type in enumerate(func_decl.param_decls)
-    ]
-    assert func_decl.return_type is not None
-    return python_val_to_qmod(func(*python_args), func_decl.return_type)
-
-
-def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInstance:
-    return QmodStructInstance(
-        QMODULE.type_decls[struct_type_symbol.name].model_copy(deep=True),
-        {field: sympy_to_python(field_value) for field, field_value in kwargs.items()},
-    )
-
-
-def get_field(
-    proxy: Union[
-        QmodSizedProxy, QmodStructInstance, list, ClassicalProxy, AnyClassicalValue
-    ],
-    field: str,
-) -> ExpressionValue:
-    if isinstance(proxy, AnyClassicalValue) or (
-        isinstance(proxy, Symbol)
-        and not isinstance(proxy, QmodSizedProxy)
-        and not isinstance(proxy, ClassicalProxy)
-    ):
-        return AnyClassicalValue(f"get_field({qmod_val_to_expr_str(proxy)}, '{field}')")
-    if isinstance(proxy, type) and issubclass(proxy, Enum):
-        return getattr(proxy, field)
-    if isinstance(proxy, list):
-        if field != "len":
-            raise ClassiqExpansionError(
-                f"List {str(proxy)!r} has no attribute {field!r}. "
-                f"Available attributes: len"
-            )
-        return len(proxy)
-    if not isinstance(
-        proxy, (QmodSizedProxy, QmodStructInstance, ClassicalProxy, AnyClassicalValue)
-    ):
-        raise ClassiqExpansionError(
-            f"Object {str(proxy)!r} has not attribute {field!r}"
-        )
-    if field not in proxy.fields:
-        if isinstance(proxy, (QmodStructInstance, QmodQStructProxy)):
-            property_name = "field"
-        else:
-            property_name = "attribute"
-        suffix = (
-            f". Available {property_name}s: {', '.join(proxy.fields.keys())}"
-            if len(proxy.fields) > 0
-            else ""
-        )
-        proxy_str = proxy.__name__ if isinstance(proxy, type) else f"{str(proxy)!r}"
-        raise ClassiqExpansionError(
-            f"{proxy.type_name} {proxy_str} has no {property_name} {field!r}{suffix}"
-        )
-    return proxy.fields[field]
-
-
-def get_type(struct_type: Symbol) -> TypeProxy:
-    return TypeProxy(QMODULE.type_decls[struct_type.name])
-
-
-def do_div(lhs: Any, rhs: Any) -> Any:
-    res = lhs / rhs
-    if isinstance(res, sympy.Expr):
-        res = res.evalf()
-    return res
-
-
-_EXPRESSION_TYPES = get_args(ExpressionValue)
-
-
-def _is_qmod_value(val: Any) -> bool:
-    if not isinstance(val, slice):
-        return isinstance(val, _EXPRESSION_TYPES)
-    if val.start is not None and not isinstance(val.start, _EXPRESSION_TYPES):
-        return False
-    if val.stop is not None and not isinstance(val.stop, _EXPRESSION_TYPES):
-        return False
-    return val.step is None or isinstance(val.step, _EXPRESSION_TYPES)
-
-
-def do_subscript(value: Any, index: Any) -> Any:
-    if not isinstance(value, (list, ClassicalSequenceProxy)) or not isinstance(
-        index, QmodQNumProxy
-    ):
-        if isinstance(index, (QmodSizedProxy, QmodStructInstance)):
-            raise ClassiqExpansionError(
-                f"Subscript {value}[{index}] is not supported. Supported subscripts "
-                f"include:\n"
-                f"\t1. `qbv[idx]`, where `qbv` is a quantum array and `idx` is a "
-                f"classical integer.\n"
-                f"\t2. `l[n]`, where `l` is a list of classical real numbers and `n` "
-                f"is a classical or quantum integer."
-            )
-        if (
-            isinstance(value, list)
-            and not is_constant_subscript(index)
-            and _is_qmod_value(index)
-        ):
-            return AnyClassicalValue(qmod_val_to_expr_str(value))[index]
-        return value[index]
-    if index.is_signed or index.fraction_digits > 0:
-        raise ClassiqExpansionError(
-            "Quantum numeric subscript must be an unsigned integer (is_signed=False, "
-            "fraction_digits=0)"
-        )
-    if isinstance(value, ClassicalSequenceProxy):
-        length = value.length
-    else:
-        length = len(value)
-    if not isinstance(length, sympy.Basic) and length != 2**index.size:
-        raise ClassiqExpansionError(
-            f"Quantum numeric subscript size mismatch: The quantum numeric has "
-            f"{index.size} qubits but the list size is {length} != 2**{index.size}"
-        )
-    if isinstance(value, ClassicalSequenceProxy):
-        return AnyClassicalValue(
-            f"do_subscript({qmod_val_to_expr_str(value)}, {qmod_val_to_expr_str(index)})"
-        )
-    else:
-        return Piecewise(
-            *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
-            (value[-1], True),
-        )
-
-
-def do_slice(value: Any, lower: Any, upper: Any) -> Any:
-    if isinstance(lower, Symbol) and str(lower) == MISSING_SLICE_VALUE_PLACEHOLDER:
-        lower = None
-    if isinstance(upper, Symbol) and str(upper) == MISSING_SLICE_VALUE_PLACEHOLDER:
-        upper = None
-    return do_subscript(value, slice(lower, upper))
-
-
-def do_sum(val: Any) -> Any:
-    if (isinstance(val, sympy.Basic) and len(val.free_symbols) > 0) or (
-        isinstance(val, ClassicalArrayProxy) and not isinstance(val.length, int)
-    ):
-        return AnyClassicalValue(f"sum({val})")
-    return sum(val)
-
-
-do_sum.__name__ = "sum"
-
-
-def mod_inverse(a: Any, b: Any) -> Any:
-    if (
-        isinstance(a, AnyClassicalValue)
-        or (isinstance(a, sympy.Basic) and len(a.free_symbols) > 0)
-        or isinstance(b, AnyClassicalValue)
-        or (isinstance(b, sympy.Basic) and len(b.free_symbols) > 0)
-    ):
-        return AnyClassicalValue(f"mod_inverse({a}, {b})")
-    return sympy.mod_inverse(a, b)
-
-
-def min_wrapper(*vals: Any) -> Any:
-    try:
-        return sympy.Min(*vals)
-    except ValueError:
-        return AnyClassicalValue(f"Min({', '.join(map(str, vals))})")
-
-
-min_wrapper.__name__ = "min"
-
-
-def Min_wrapper(*vals: Any) -> Any:  # noqa: N802
-    return min_wrapper(*vals)
-
-
-Min_wrapper.__name__ = "Min"
-
-
-def max_wrapper(*vals: Any) -> Any:
-    try:
-        return sympy.Max(*vals)
-    except ValueError:
-        return AnyClassicalValue(f"Max({', '.join(map(str, vals))})")
-
-
-max_wrapper.__name__ = "max"
-
-
-def Max_wrapper(*vals: Any) -> Any:  # noqa: N802
-    return max_wrapper(*vals)
-
-
-Max_wrapper.__name__ = "Max"
-
-
-CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
-    print,
-    do_sum,
-    struct_literal,
-    get_field,
-    get_type,
-    do_div,
-    do_slice,
-    do_subscript,
-    BitwiseAnd,
-    BitwiseXor,
-    BitwiseNot,
-    BitwiseOr,
-    LogicalXor,
-    RShift,
-    LShift,
-    mod_inverse,
-    min_wrapper,
-    Min_wrapper,
-    max_wrapper,
-    Max_wrapper,
-]
-
-
-def _symbolic_function(func: str) -> Callable:
-    def wrapper(*args: Any) -> AnyClassicalValue:
-        return AnyClassicalValue(
-            f"{func}({', '.join(map(qmod_val_to_expr_str, args))})"
-        )
-
-    wrapper.__name__ = func
-    return wrapper
-
-
-QMOD_CLASSICAL_FUNCTIONS = [
-    _symbolic_function(func)
-    for func in qmod_classical_functions + list(MEASUREMENT_FUNCTIONS)
-]
-
-ATOMIC_EXPRESSION_FUNCTIONS = {
-    **{
-        core_func.__name__: core_func
-        for core_func in CORE_LIB_FUNCTIONS_LIST + QMOD_CLASSICAL_FUNCTIONS
-    },
-}

classiq/model_expansions/model_tables.py

@@ -1,18 +0,0 @@
-from typing import Optional
-
-from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
-from classiq.interface.generator.functions.classical_type import QmodPyObject
-
-
-class HandleTable:
-    _handle_map: dict[HandleIdentifier, QmodPyObject] = {}
-
-    @classmethod
-    def get_handle_object(cls, hid: HandleIdentifier) -> Optional[QmodPyObject]:
-        return cls._handle_map.get(hid)
-
-    @classmethod
-    def set_handle_object(cls, qmod_object: QmodPyObject) -> HandleIdentifier:
-        hid = HandleIdentifier(id(qmod_object))
-        cls._handle_map[hid] = qmod_object
-        return hid

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -1,181 +0,0 @@
-import ast
-from typing import TYPE_CHECKING, cast
-
-from classiq.interface.exceptions import ClassiqExpansionError
-
-MISSING_SLICE_VALUE_PLACEHOLDER = "MISSING_SLICE_VALUE"
-
-
-def translate_to_sympy(expr: str) -> str:
-    node = ast.parse(expr)
-    node = ExpressionSympyTranslator().visit(node)
-    # node is a Module, we want an Expression
-    if TYPE_CHECKING:
-        assert isinstance(node.body[0], ast.Expr)
-    expression = ast.Expression(node.body[0].value)
-
-    return ast.unparse(ast.fix_missing_locations(expression))
-
-
-class ExpressionSympyTranslator(ast.NodeTransformer):
-    BINARY_OPERATORS: dict[type[ast.AST], str] = {
-        ast.BitOr: "BitwiseOr",
-        ast.BitAnd: "BitwiseAnd",
-        ast.BitXor: "BitwiseXor",
-        ast.Div: "do_div",
-        ast.RShift: "RShift",
-        ast.LShift: "LShift",
-    }
-
-    UNARY_OPERATORS: dict[type[ast.AST], str] = {
-        ast.Invert: "BitwiseNot",
-        ast.Not: "Not",
-    }
-
-    BOOLEAN_OPERATORS: dict[type[ast.AST], str] = {
-        ast.Or: "Or",
-        ast.And: "And",
-    }
-
-    COMPARE_OPERATORS: dict[type[ast.AST], str] = {
-        ast.Eq: "Eq",
-        ast.NotEq: "Ne",
-    }
-
-    SPECIAL_FUNCTIONS: dict[str, str] = {
-        "max": "Max",
-        "min": "Min",
-    }
-
-    def visit_BinOp(self, node: ast.BinOp) -> ast.AST:
-        sympy_class = self.BINARY_OPERATORS.get(node.op.__class__)
-        if sympy_class is not None:
-            left = self.visit(node.left)
-            right = self.visit(node.right)
-
-            new_node = ast.Call(
-                func=ast.Name(id=sympy_class, ctx=ast.Load()),
-                args=[left, right],
-                starargs=None,
-                keywords=[],
-                kwargs=None,
-            )
-
-            return new_node
-        return self.generic_visit(node)
-
-    def visit_Compare(self, node: ast.Compare) -> ast.AST:
-        if len(node.ops) > 1:
-            raise ClassiqExpansionError(
-                f"Qmod expressions do not support chained comparison, as done in {ast.unparse(node)}"
-            )
-        sympy_class = self.COMPARE_OPERATORS.get(node.ops[0].__class__)
-        if sympy_class is not None:
-            left = self.visit(node.left)
-            right = self.visit(node.comparators[0])
-
-            new_node = ast.Call(
-                func=ast.Name(id=sympy_class, ctx=ast.Load()),
-                args=[left, right],
-                starargs=None,
-                keywords=[],
-                kwargs=None,
-            )
-
-            return new_node
-        return self.generic_visit(node)
-
-    def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
-        sympy_class = self.BOOLEAN_OPERATORS.get(node.op.__class__)
-        if sympy_class is not None:
-            values = [self.visit(value) for value in node.values]
-
-            new_node = ast.Call(
-                func=ast.Name(id=sympy_class, ctx=ast.Load()),
-                args=values,
-                starargs=None,
-                keywords=[],
-                kwargs=None,
-            )
-
-            return new_node
-        return self.generic_visit(node)
-
-    def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.AST:
-        sympy_class = self.UNARY_OPERATORS.get(node.op.__class__)
-        if sympy_class is not None:
-            operand = self.visit(node.operand)
-
-            new_node = ast.Call(
-                func=ast.Name(id=sympy_class, ctx=ast.Load()),
-                args=[operand],
-                starargs=None,
-                keywords=[],
-                kwargs=None,
-            )
-
-            return new_node
-        return self.generic_visit(node)
-
-    def visit_Call(self, node: ast.Call) -> ast.AST:
-        if isinstance(node.func, ast.Name) and node.func.id == "Piecewise":
-            return self._visit_piecewise(node)
-
-        if (
-            not isinstance(node.func, ast.Name)
-            or node.func.id not in self.SPECIAL_FUNCTIONS
-        ):
-            return self.generic_visit(node)
-
-        return ast.Call(
-            func=ast.Name(self.SPECIAL_FUNCTIONS[node.func.id]),
-            args=[self.visit(arg) for arg in (node.args)],
-            keywords=[self.visit(arg) for arg in node.keywords],
-        )
-
-    def _visit_piecewise(self, node: ast.Call) -> ast.AST:
-        # sympy Piecewise expression may include bitwise operations:
-        # Piecewise((0, Eq(x, 0)), (0.5, Eq(x, 1) | Eq(x, 2)), (1, True))
-        #                                         ^
-        # We should avoid converting these to 'BitwiseOr' and such.
-        return ast.Call(
-            func=node.func,
-            args=[
-                ast.Tuple(
-                    elts=(
-                        self.generic_visit(cast(ast.Tuple, arg).elts[0]),
-                        cast(ast.Tuple, arg).elts[1],
-                    )
-                )
-                for arg in node.args
-            ],
-            keywords=node.keywords,
-        )
-
-    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
-        if isinstance(node.slice, ast.Slice):
-            if node.slice.lower is not None:
-                lower = self.visit(node.slice.lower)
-            else:
-                lower = ast.Name(MISSING_SLICE_VALUE_PLACEHOLDER)
-            if node.slice.upper is not None:
-                upper = self.visit(node.slice.upper)
-            else:
-                upper = ast.Name(MISSING_SLICE_VALUE_PLACEHOLDER)
-            return ast.Call(
-                func=ast.Name("do_slice"),
-                args=[self.visit(node.value), lower, upper],
-                keywords=[],
-            )
-        return ast.Call(
-            func=ast.Name("do_subscript"),
-            args=[self.visit(node.value), self.visit(node.slice)],
-            keywords=[],
-        )
-
-    def visit_Attribute(self, node: ast.Attribute) -> ast.Call:
-        return ast.Call(
-            func=ast.Name("get_field"),
-            args=[self.visit(node.value), ast.Constant(value=node.attr)],
-            keywords=[],
-        )