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

classiq/evaluators/arg_type_match.py

@@ -1,168 +0,0 @@
-from collections.abc import Sequence
-from enum import Enum
-from typing import Any
-
-from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
-    QmodStructInstance,
-)
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.generator.functions.classical_type import (
-    StructMetaType,
-)
-from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
-from classiq.interface.generator.functions.type_name import (
-    TypeName,
-)
-from classiq.interface.model.classical_parameter_declaration import (
-    AnonClassicalParameterDeclaration,
-)
-from classiq.interface.model.port_declaration import AnonPortDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    AnonPositionalArg,
-    AnonQuantumOperandDeclaration,
-)
-
-from classiq.evaluators.type_type_match import check_signature_match
-from classiq.model_expansions.closure import FunctionClosure
-from classiq.model_expansions.scope import Evaluated, QuantumVariable
-from classiq.qmod.model_state_container import QMODULE
-from classiq.qmod.qmod_parameter import CInt, get_qmod_type
-
-
-def check_type_match(
-    parameters: Sequence[AnonPositionalArg],
-    arguments: list[Evaluated],
-    function_name: str,
-) -> None:
-    if len(parameters) != len(arguments):
-        raise ClassiqExpansionError(
-            f"Function {function_name!r} takes {len(parameters)} arguments but "
-            f"{len(arguments)} were given"
-        )
-    for parameter, evaluated_arg in zip(parameters, arguments):
-        check_arg_type_match(evaluated_arg.value, parameter, function_name)
-
-
-def check_arg_type_match(
-    argument: Any, parameter: AnonPositionalArg, function_name: str
-) -> None:
-    message_prefix = (
-        f"Argument {str(argument)!r} to parameter {parameter.name!r} of function "
-        f"{function_name!r} has incompatible type; "
-    )
-    if isinstance(parameter, AnonPortDeclaration):
-        error_message = message_prefix + "expected quantum variable"
-        _check_qvar_type_match(argument, error_message)
-    elif isinstance(parameter, AnonQuantumOperandDeclaration):
-        if parameter.is_list:
-            error_message = message_prefix + "expected list of operands"
-            _check_operand_list_type_match(
-                argument, parameter, function_name, error_message
-            )
-        else:
-            error_message = message_prefix + "expected operand"
-            _check_operand_type_match(argument, parameter, function_name, error_message)
-    elif isinstance(parameter, AnonClassicalParameterDeclaration):
-        error_message = (
-            message_prefix + f"expected {_resolve_type_name(parameter.classical_type)}"
-        )
-        _check_classical_type_match(argument, parameter, error_message, function_name)
-    else:
-        raise ClassiqExpansionError(
-            f"unexpected parameter declaration type: {type(parameter).__name__}"
-        )
-
-
-def _check_qvar_type_match(argument: Any, error_message: str) -> None:
-    if not isinstance(argument, QuantumVariable):
-        raise ClassiqExpansionError(error_message)
-
-
-def _check_operand_list_type_match(
-    argument: Any,
-    parameter: AnonQuantumOperandDeclaration,
-    function_name: str,
-    error_message: str,
-) -> None:
-    if not isinstance(argument, list) or any(
-        not isinstance(op, FunctionClosure) for op in argument
-    ):
-        raise ClassiqExpansionError(error_message)
-    for idx, operand in enumerate(argument):
-        if operand.positional_arg_declarations is not None:
-            check_signature_match(
-                parameter.positional_arg_declarations,
-                operand.positional_arg_declarations,
-                f"operand #{idx + 1} in parameter {parameter.name!r} "
-                f"in function {function_name!r}",
-            )
-
-
-def _check_operand_type_match(
-    argument: Any,
-    parameter: AnonQuantumOperandDeclaration,
-    function_name: str,
-    error_message: str,
-) -> None:
-    if not isinstance(argument, FunctionClosure):
-        raise ClassiqExpansionError(error_message)
-    if argument.positional_arg_declarations is not None:
-        check_signature_match(
-            parameter.positional_arg_declarations,
-            argument.positional_arg_declarations,
-            f"operand {parameter.name!r} in function {function_name!r}",
-        )
-
-
-def _check_classical_type_match(
-    argument: Any,
-    parameter: AnonClassicalParameterDeclaration,
-    error_message: str,
-    function_name: str,
-) -> None:
-    classical_type = parameter.classical_type
-    type_name = _resolve_type_name(classical_type)
-    type_is_struct = (
-        isinstance(classical_type, TypeName)
-        and classical_type.name in QMODULE.type_decls
-    )
-    type_is_enum = (
-        isinstance(classical_type, TypeName)
-        and classical_type.name in QMODULE.enum_decls
-    )
-    arg_is_qvar = isinstance(argument, QmodSizedProxy)
-    arg_is_builtin = argument.__class__.__module__ == "builtins"
-    arg_is_int = isinstance(argument, int)
-    arg_is_enum = isinstance(argument, Enum)
-    arg_is_struct = isinstance(argument, QmodStructInstance)
-    arg_struct_name = None if not arg_is_struct else argument.struct_declaration.name
-    # FIXME: Remove suzuki_trotter overloading (CLS-2912)
-    if function_name == "suzuki_trotter" and parameter.name == "pauli_operator":
-        return
-    if (
-        arg_is_qvar
-        or (arg_is_builtin and type_is_struct)
-        or (arg_is_builtin and not arg_is_int and type_is_enum)
-        or (arg_is_struct and (not type_is_struct or arg_struct_name != type_name))
-        or (
-            arg_is_enum
-            and get_qmod_type(classical_type) != CInt
-            and (not type_is_enum or type(argument).__name__ != type_name)
-        )
-    ):
-        raise ClassiqExpansionError(error_message)
-
-
-def _resolve_type_name(classical_type: ConcreteClassicalType) -> str:
-    if isinstance(classical_type, StructMetaType):
-        type_name = "Struct"
-    else:
-        type_name = get_qmod_type(classical_type).__name__
-    if not isinstance(classical_type, TypeName):
-        return type_name
-    if type_name not in QMODULE.type_decls and type_name not in QMODULE.enum_decls:
-        raise ClassiqExpansionError(f"Undefined type {type_name}")
-    return type_name

classiq/evaluators/classical_type_inference.py

@@ -1,121 +0,0 @@
-from typing import TYPE_CHECKING, Any, Union
-
-from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
-    ClassicalSequenceProxy,
-    _is_int,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
-    ClassicalStructProxy,
-)
-from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
-    QmodStructInstance,
-)
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalArray,
-    ClassicalTuple,
-    ClassicalType,
-)
-from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.helpers.backward_compatibility import zip_strict
-
-
-def infer_classical_type(val: Any, classical_type: ClassicalType) -> ClassicalType:
-    if isinstance(classical_type, TypeName):
-        return _infer_classical_struct_type(val, classical_type)
-    if isinstance(classical_type, (ClassicalArray, ClassicalTuple)):
-        return _infer_classical_array_type(val, classical_type)
-    return classical_type
-
-
-def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> ClassicalType:
-    if not isinstance(val, (QmodStructInstance, ClassicalStructProxy)):
-        return classical_type
-    if classical_type.is_enum:
-        raise ClassiqExpansionError(
-            f"{classical_type.type_name!r} expected, got {str(val)!r}"
-        )
-    decl = classical_type.classical_struct_decl
-    new_fields = {
-        field_name: infer_classical_type(field_val, field_type)
-        for (field_name, field_val), field_type in zip_strict(
-            val.fields.items(),
-            decl.variables.values(),
-            strict=True,
-        )
-    }
-    new_classical_type = TypeName(name=decl.name)
-    new_classical_type.set_classical_struct_decl(
-        StructDeclaration(name=decl.name, variables=new_fields)
-    )
-    return new_classical_type
-
-
-def _infer_classical_array_type(
-    val: Any, classical_type: Union[ClassicalArray, ClassicalTuple]
-) -> ClassicalType:
-    if isinstance(val, ClassicalSequenceProxy):
-        val_length = val.length
-    elif isinstance(val, list):
-        val_length = len(val)
-    elif isinstance(val, AnyClassicalValue):
-        return classical_type
-    else:
-        raise ClassiqExpansionError(f"Array expected, got {str(val)!r}")
-    if isinstance(val_length, int) and (
-        (
-            isinstance(classical_type, ClassicalArray)
-            and classical_type.length is not None
-            and classical_type.length.is_evaluated()
-            and _is_int(classical_type.length.value.value)
-            and val_length != (type_length := int(classical_type.length.value.value))
-        )
-        or (
-            isinstance(classical_type, ClassicalTuple)
-            and val_length != (type_length := classical_type.length)
-        )
-    ):
-        raise ClassiqExpansionError(
-            f"Type mismatch: Argument has {val_length} items but "
-            f"{type_length} expected"
-        )
-    new_classical_type = _infer_inner_array_types(classical_type, val, val_length)
-    if classical_type.is_generative:
-        new_classical_type.set_generative()
-    return new_classical_type
-
-
-def _infer_inner_array_types(
-    classical_type: ClassicalType, val: Any, val_length: Any
-) -> ClassicalType:
-    if isinstance(classical_type, ClassicalTuple):
-        return ClassicalTuple(
-            element_types=(
-                infer_classical_type(val[idx], element_type)
-                for idx, element_type in enumerate(classical_type.element_types)
-            ),
-        )
-    if TYPE_CHECKING:
-        assert isinstance(classical_type, ClassicalArray)
-    if _is_int(val_length) and val_length != 0:
-        return ClassicalTuple(
-            element_types=(
-                infer_classical_type(val[i], classical_type.element_type)
-                for i in range(int(val_length))
-            ),
-        )
-    element_type: ClassicalType
-    if val_length == 0:
-        element_type = classical_type.element_type
-    else:
-        element_type = infer_classical_type(val[0], classical_type.element_type)
-    if _is_int(val_length):
-        length = Expression(expr=str(int(val_length)))
-    else:
-        length = None
-    return ClassicalArray(element_type=element_type, length=length)

classiq/interface/combinatorial_optimization/optimization_problem.py

@@ -1,17 +0,0 @@
-from typing import Any
-
-import pydantic
-from pydantic import BaseModel
-
-from classiq.interface.executor.optimizer_preferences import CombinatorialOptimizer
-
-
-class MaxCutProblem(BaseModel):
-    qaoa_reps: pydantic.PositiveInt = pydantic.Field(
-        default=1, description="Number of layers in qaoa ansatz."
-    )
-    optimizer_preferences: CombinatorialOptimizer = pydantic.Field(
-        default_factory=CombinatorialOptimizer,
-        description="preferences for the VQE execution",
-    )
-    serialized_graph: dict[str, Any]

classiq/interface/combinatorial_optimization/result.py

@@ -1,9 +0,0 @@
-from classiq.interface.helpers.versioned_model import VersionedModel
-
-
-class AnglesResult(VersionedModel):
-    initial_point: list[float]
-
-
-class PyomoObjectResult(VersionedModel):
-    details: str

classiq/interface/generator/expressions/handle_identifier.py

@@ -1,6 +0,0 @@
-import dataclasses
-
-
-@dataclasses.dataclass(frozen=True)
-class HandleIdentifier:
-    id: int

classiq/interface/generator/expressions/proxies/classical/any_classical_value.py

@@ -1,41 +0,0 @@
-import inspect
-from typing import Any, NoReturn
-
-import sympy
-
-_SYMPY_MEMBERS = [name for name, _ in inspect.getmembers(sympy.Symbol)] + ["precedence"]
-
-
-def subscript_to_str(index: Any) -> str:
-    if not isinstance(index, slice):
-        return str(index)
-    expr = ""
-    if index.start is not None:
-        expr += str(index.start)
-    expr += ":"
-    if index.stop is not None:
-        expr += str(index.stop)
-    if index.step is not None:
-        expr += f":{index.step}"
-    return expr
-
-
-class AnyClassicalValue(sympy.Symbol):
-    def __getitem__(self, item: Any) -> "AnyClassicalValue":
-        if isinstance(item, slice):
-            return AnyClassicalValue(f"{self}[{subscript_to_str(item)}]")
-        return AnyClassicalValue(f"do_subscript({self}, {item})")
-
-    def __getattribute__(self, attr: str) -> Any:
-        if attr.startswith("_") or attr in _SYMPY_MEMBERS:
-            return super().__getattribute__(attr)
-        return AnyClassicalValue(f"get_field({self}, '{attr}')")
-
-    def __len__(self) -> NoReturn:
-        raise TypeError("object of type 'AnyClassicalValue' has no len()")
-
-    def __iter__(self) -> NoReturn:
-        raise TypeError("'AnyClassicalValue' object is not iterable")
-
-    def __bool__(self) -> bool:
-        return True

classiq/interface/generator/expressions/proxies/quantum/qmod_qarray_proxy.py

@@ -1,80 +0,0 @@
-from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, Union
-
-import sympy
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.model.handle_binding import (
-    HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
-)
-
-if TYPE_CHECKING:
-    from classiq.interface.model.quantum_type import QuantumType
-
-
-ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
-ILLEGAL_SLICE_MSG = "Quantum array slice must be of the form [<int-value>:<int-value>]."
-
-
-class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
-    def __init__(
-        self,
-        handle: HandleBinding,
-        element_type: "QuantumType",
-        element_size: Union[int, sympy.Basic],
-        length: Union[int, sympy.Basic],
-    ) -> None:
-        super().__init__(handle, element_size * length)
-        self._length = length
-        self._element_type = element_type
-        self._element_size = element_size
-
-    def __getitem__(self, key: Any) -> "QmodSizedProxy":
-        return (
-            self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
-        )
-
-    def _get_subscript(self, index: Any) -> "QmodSizedProxy":
-        return self._element_type.get_proxy(
-            SubscriptHandleBinding(
-                base_handle=self.handle,
-                index=Expression(expr=str(index)),
-            )
-        )
-
-    def _get_slice(self, slice_: slice) -> "QmodSizedProxy":
-        if slice_.step is not None:
-            raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
-        return QmodQArrayProxy(
-            SlicedHandleBinding(
-                base_handle=self.handle,
-                start=Expression(expr=str(slice_.start)),
-                end=Expression(expr=str(slice_.stop)),
-            ),
-            self._element_type,
-            self._element_size,
-            slice_.stop - slice_.start,
-        )
-
-    @property
-    def type_name(self) -> str:
-        return "Quantum array"
-
-    @property
-    def len(self) -> Union[int, sympy.Basic]:
-        return self._length
-
-    @property
-    def fields(self) -> Mapping[str, Any]:
-        return {**super().fields, "len": self.len}
-
-    @property
-    def size(self) -> int:
-        return self.len * self._element_size

classiq/interface/generator/expressions/proxies/quantum/qmod_qscalar_proxy.py

@@ -1,77 +0,0 @@
-from collections.abc import Mapping
-from typing import Any, Optional, Union
-
-import sympy
-from sympy import Symbol
-from typing_extensions import Self
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.model.handle_binding import HandleBinding
-
-
-class QmodQScalarProxy(Symbol, QmodSizedProxy):
-    def __new__(cls, handle: HandleBinding, **assumptions: bool) -> "QmodQScalarProxy":
-        return super().__new__(cls, handle.qmod_expr, **assumptions)
-
-    def __init__(self, handle: HandleBinding, size: int) -> None:
-        super().__init__(handle, size)
-
-    def __copy__(self) -> Self:
-        return self
-
-    def __deepcopy__(self, memo: Optional[dict]) -> Self:
-        return self
-
-
-class QmodQBitProxy(QmodQScalarProxy):
-    def __init__(self, handle: HandleBinding) -> None:
-        super().__init__(handle, 1)
-
-    @property
-    def type_name(self) -> str:
-        return "Quantum bit"
-
-
-class QmodQNumProxy(QmodQScalarProxy):
-    def __init__(
-        self,
-        handle: HandleBinding,
-        size: Union[int, sympy.Basic],
-        fraction_digits: Union[int, sympy.Basic],
-        is_signed: Union[bool, sympy.Basic],
-    ) -> None:
-        super().__init__(handle, size)
-        if (
-            isinstance(fraction_digits, int)
-            and isinstance(size, int)
-            and fraction_digits > size
-        ):
-            raise ClassiqValueError(
-                f"Quantum numeric of size {size} cannot have {fraction_digits} "
-                f"fraction digits"
-            )
-        self._fraction_digits = fraction_digits
-        self._is_signed = is_signed
-
-    @property
-    def type_name(self) -> str:
-        return "Quantum numeric"
-
-    @property
-    def fraction_digits(self) -> Union[int, sympy.Basic]:
-        return self._fraction_digits
-
-    @property
-    def is_signed(self) -> Union[bool, sympy.Basic]:
-        return self._is_signed
-
-    @property
-    def fields(self) -> Mapping[str, Any]:
-        return {
-            **super().fields,
-            "is_signed": self.is_signed,
-            "fraction_digits": self.fraction_digits,
-        }

classiq/interface/generator/expressions/proxies/quantum/qmod_qstruct_proxy.py

@@ -1,38 +0,0 @@
-from collections.abc import Mapping
-from typing import TYPE_CHECKING
-
-from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.model.handle_binding import (
-    FieldHandleBinding,
-    HandleBinding,
-)
-
-if TYPE_CHECKING:
-    from classiq.interface.model.quantum_type import QuantumType
-
-
-class QmodQStructProxy(NonSymbolicExpr, QmodSizedProxy):
-    def __init__(
-        self,
-        handle: HandleBinding,
-        struct_name: str,
-        fields: Mapping[str, "QuantumType"],
-    ) -> None:
-        self._fields = {
-            name: type_.get_proxy(FieldHandleBinding(base_handle=handle, field=name))
-            for name, type_ in fields.items()
-        }
-        size = sum(proxy.size for proxy in self._fields.values())
-        super().__init__(handle, size)
-        self._struct_name = struct_name
-
-    @property
-    def type_name(self) -> str:
-        return self._struct_name
-
-    @property
-    def fields(self) -> Mapping[str, QmodSizedProxy]:
-        return {**super().fields, **self._fields}

classiq/interface/generator/expressions/proxies/quantum/qmod_sized_proxy.py

@@ -1,39 +0,0 @@
-from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, Union
-
-import sympy
-
-if TYPE_CHECKING:
-    from classiq.interface.model.handle_binding import HandleBinding
-
-
-class QmodSizedProxy:
-    def __init__(self, handle: "HandleBinding", size: Union[int, sympy.Basic]) -> None:
-        self._handle = handle
-        self._size = size
-
-    @property
-    def size(self) -> Union[int, sympy.Basic]:
-        return self._size
-
-    def __str__(self) -> str:
-        return self.handle.qmod_expr
-
-    def __repr__(self) -> str:
-        return str(self)
-
-    @property
-    def type_name(self) -> str:
-        raise NotImplementedError
-
-    @property
-    def handle(self) -> "HandleBinding":
-        return self._handle
-
-    @property
-    def len(self) -> int:
-        return self._size
-
-    @property
-    def fields(self) -> Mapping[str, Any]:
-        return {"size": self._size}

classiq/interface/generator/expressions/type_proxy.py

@@ -1,10 +0,0 @@
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from classiq.interface.generator.types.struct_declaration import StructDeclaration
-
-
-class TypeProxy:
-    def __init__(self, struct_declaration: "StructDeclaration") -> None:
-        super().__init__()
-        self.struct_declaration = struct_declaration