classiq 0.88.0__py3-none-any.whl → 0.90.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/model_expansions/transformers/ast_renamer.py

@@ -1,26 +0,0 @@
-import ast
-
-_POSSIBLE_HANDLE_AST_TYPES = (ast.Subscript, ast.Attribute, ast.Name)
-
-
-class _ASTRenamer(ast.NodeTransformer):
-    def __init__(self, sub: dict[str, str]) -> None:
-        self._sub = sub
-
-    def visit(self, node: ast.AST) -> ast.AST:
-        if isinstance(node, _POSSIBLE_HANDLE_AST_TYPES):
-            node_expr = ast.unparse(node)
-            if node_expr in self._sub:
-                return ast.Name(id=self._sub[node_expr])
-        return super().visit(node)
-
-    def visit_Call(self, node: ast.Call) -> ast.Call:
-        return ast.Call(
-            func=node.func,
-            args=[self.visit(arg) for arg in node.args],
-            keywords=[],
-        )
-
-
-def rename_variables(expr: str, sub: dict[str, str]) -> str:
-    return ast.unparse(_ASTRenamer(sub).visit(ast.parse(expr)))