classiq 0.32.1__py3-none-any.whl → 0.34.0__py3-none-any.whl

classiq/interface/model/quantum_function_call.py

@@ -1,62 +1,29 @@
-import functools
 import itertools
 import re
-from collections import defaultdict
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Collection,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Match,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Union,
-)
+from typing import Any, Dict, List, Mapping, Optional, Sequence, Set, Union
 
 import pydantic
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel
 
-from classiq.interface.generator import function_param_list, function_params as f_params
 from classiq.interface.generator.arith.arithmetic import Arithmetic
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.function_params import (
-    NAME_REGEX,
-    FunctionParams,
-    IOName,
-    PortDirection,
-)
+from classiq.interface.generator.function_params import NAME_REGEX
 from classiq.interface.generator.functions import FunctionDeclaration
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.quantum_function_call import (
     BAD_CALL_NAME_ERROR_MSG,
-    BAD_INPUT_ERROR_MSG,
-    BAD_INPUT_EXPRESSION_MSG,
-    BAD_INPUT_SLICING_MSG,
-    BAD_OUTPUT_ERROR_MSG,
-    BAD_OUTPUT_EXPRESSION_MSG,
-    BAD_OUTPUT_SLICING_MSG,
-    CUSTOM_FUNCTION_SINGLE_IO_ERROR,
-    LEGAL_SLICING,
     SUFFIX_MARKER,
     randomize_suffix,
 )
-from classiq.interface.generator.slice_parsing_utils import (
-    IO_REGEX,
-    NAME,
-    SLICING,
-    parse_io_slicing,
-)
-from classiq.interface.generator.user_defined_function_params import CustomFunction
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
-from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
@@ -64,7 +31,7 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.validation_handle import get_unique_handle_names
 
-from classiq.exceptions import ClassiqControlError, ClassiqValueError
+from classiq.exceptions import ClassiqError, ClassiqValueError
 
 
 def _validate_no_duplicated_ports(
@@ -140,10 +107,6 @@ class QuantumFunctionCall(QuantumOperation):
         description="The function that is called"
     )
     params: Dict[str, Expression] = pydantic.Field(default_factory=dict)
-    function_params: f_params.FunctionParams = pydantic.Field(
-        description="The parameters necessary for defining the function",
-        default_factory=CustomFunction,
-    )
     strict_zero_ios: bool = pydantic.Field(
         default=True,
         description="Enables automated qubit allocation for pre-determined zero inputs "
@@ -163,15 +126,17 @@ class QuantumFunctionCall(QuantumOperation):
         default=True,
         description="False value indicates this call shouldn't be controlled even if the flow is controlled.",
     )
-    inputs: Dict[IOName, HandleBinding] = pydantic.Field(
+    inputs: Dict[str, HandleBinding] = pydantic.Field(
         default_factory=dict,
         description="A mapping from the input name to the wire it connects to",
     )
-    inouts: Dict[IOName, Union[SlicedHandleBinding, HandleBinding]] = pydantic.Field(
+    inouts: Dict[
+        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
+    ] = pydantic.Field(
         default_factory=dict,
         description="A mapping from in/out name to the wires that connect to it",
     )
-    outputs: Dict[IOName, HandleBinding] = pydantic.Field(
+    outputs: Dict[str, HandleBinding] = pydantic.Field(
         default_factory=dict,
         description="A mapping from the output name to the wire it connects to",
     )
@@ -191,7 +156,10 @@ class QuantumFunctionCall(QuantumOperation):
     )
 
     @property
-    def func_decl(self) -> Optional[QuantumFunctionDeclaration]:
+    def func_decl(self) -> QuantumFunctionDeclaration:
+        if self._func_decl is None:
+            raise ClassiqError("Accessing an unresolved quantum function call")
+
         return self._func_decl
 
     def set_func_decl(self, fd: Optional[FunctionDeclaration]) -> None:
@@ -208,17 +176,19 @@ class QuantumFunctionCall(QuantumOperation):
         return self.function
 
     @property
-    def wiring_inputs(self) -> Mapping[IOName, HandleBinding]:
+    def wiring_inputs(self) -> Mapping[str, HandleBinding]:
         return self.inputs
 
     @property
     def wiring_inouts(
         self,
-    ) -> Mapping[IOName, Union[SlicedHandleBinding, HandleBinding]]:
+    ) -> Mapping[
+        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
+    ]:
         return self.inouts
 
     @property
-    def wiring_outputs(self) -> Mapping[IOName, HandleBinding]:
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return self.outputs
 
     def get_positional_args(self) -> List[ArgValue]:
@@ -253,41 +223,13 @@ class QuantumFunctionCall(QuantumOperation):
         if isinstance(function, OperandIdentifier):
             function = function.name
 
-        params = values.get("function_params")
-        if isinstance(params, CustomFunction):
-            if function == CustomFunction.discriminator() and params.name != "":
-                function = params.name
-
         suffix = f"{SUFFIX_MARKER}_{randomize_suffix()}"
-        if not function or params is None:
+        if not function:
             return name if name else suffix
         return f"{function}_{suffix}"
 
-    @pydantic.root_validator(pre=True)
-    def validate_composite_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if isinstance(values.get("unitary_params"), CustomFunction) and not values.get(
-            "unitary"
-        ):
-            raise ClassiqValueError(
-                "`PhaseEstimation` of a user define function (`CustomFunction`) must receive the function name from the `unitary` field"
-            )
-        return values
-
-    @pydantic.root_validator(pre=True)
-    def _parse_function_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        f_params.parse_function_params_values(
-            values=values,
-            params_key="function_params",
-            discriminator_key="function",
-            param_classes=function_param_list.function_param_library.param_list,
-            default_parser_class=CustomFunction,
-        )
-        return values
-
     @property
     def pos_param_args(self) -> Dict[str, Expression]:
-        if TYPE_CHECKING:
-            assert self.func_decl is not None
         return dict(
             zip(
                 self.func_decl.param_decls.keys(),
@@ -301,8 +243,6 @@ class QuantumFunctionCall(QuantumOperation):
 
     @property
     def pos_operand_args(self) -> Dict[str, "QuantumOperand"]:
-        if TYPE_CHECKING:
-            assert self.func_decl is not None
         return dict(
             zip(
                 self.func_decl.operand_declarations.keys(),
@@ -316,8 +256,6 @@ class QuantumFunctionCall(QuantumOperation):
 
     @property
     def pos_port_args(self) -> Dict[str, HandleBinding]:
-        if TYPE_CHECKING:
-            assert self.func_decl is not None
         return dict(
             zip(
                 self.func_decl.port_declarations.keys(),
@@ -330,8 +268,6 @@ class QuantumFunctionCall(QuantumOperation):
         )
 
     def _update_pos_port_params(self) -> None:
-        if TYPE_CHECKING:
-            assert self.func_decl is not None
         for name, port_decl in self.func_decl.port_declarations.items():
             if port_decl.direction == PortDeclarationDirection.Input:
                 self.inputs[name] = self.pos_port_args[name]
@@ -345,45 +281,10 @@ class QuantumFunctionCall(QuantumOperation):
         self.operands.update(self.pos_operand_args)
         self._update_pos_port_params()
 
-    # TODO: note that this checks QuantumFunctionCall input register names
-    # are PARTIAL to FunctionParams input register names, not EQUAL.
-    # We might want to change that.
-    @staticmethod
-    def _validate_input_names(
-        *,
-        params: f_params.FunctionParams,
-        input_names: Collection[IOName],
-        control_states: List[ControlState],
-        strict_zero_ios: bool,
-    ) -> None:
-        (
-            invalid_expressions,
-            invalid_slicings,
-            invalid_names,
-        ) = QuantumFunctionCall._get_invalid_ios(
-            expressions=input_names,
-            params=params,
-            io=PortDirection.Input,
-            control_states=control_states,
-            strict_zero_ios=strict_zero_ios,
-        )
-        error_msg = []
-        if invalid_expressions:
-            error_msg.append(f"{BAD_INPUT_EXPRESSION_MSG}: {invalid_expressions}")
-        if invalid_names:
-            error_msg.append(f"{BAD_INPUT_ERROR_MSG}: {invalid_names}")
-        if invalid_slicings:
-            error_msg.append(f"{BAD_INPUT_SLICING_MSG}: {invalid_slicings}")
-        if error_msg:
-            raise ValueError("\n".join(error_msg))
-
     def resolve_function_decl(
         self,
         function_dict: Mapping[str, FunctionDeclaration],
     ) -> None:
-        if not isinstance(self.function_params, CustomFunction):
-            return
-
         if self._func_decl is None:
             func_decl = function_dict.get(self.func_name)
             if func_decl is None:
@@ -392,9 +293,6 @@ class QuantumFunctionCall(QuantumOperation):
                 )
             self.set_func_decl(func_decl)
 
-        if TYPE_CHECKING:
-            assert self.func_decl is not None
-
         if self.positional_args:
             self._reduce_positional_args_to_keywords()
 
@@ -425,228 +323,10 @@ class QuantumFunctionCall(QuantumOperation):
         ), "when using the Arithmetic function, assign to the expression result register via the target parameter instead of the strict_zero_ios flag"
         return strict_zero_ios
 
-    @pydantic.validator("control_states")
-    def _validate_control_states(
-        cls, control_states: List[ControlState], values: Dict[str, Any]
-    ) -> List[ControlState]:
-        control_names = [ctrl_state.name for ctrl_state in control_states]
-        function_params = values.get("function_params")
-        strict_zero_ios = values.get("strict_zero_ios")
-        if not (
-            isinstance(function_params, FunctionParams)
-            and isinstance(strict_zero_ios, bool)
-        ):
-            return control_states
-        all_input_names = [
-            *function_params.inputs_full(strict_zero_ios=strict_zero_ios),
-            *control_names,
-        ]
-        all_output_names = [*function_params.outputs, *control_names]
-        if any(
-            cls._has_repetitions(name_list)
-            for name_list in (control_names, all_input_names, all_output_names)
-        ):
-            raise ClassiqControlError()
-        return control_states
-
     @staticmethod
     def _has_repetitions(name_list: Sequence[str]) -> bool:
         return len(set(name_list)) < len(name_list)
 
-    @staticmethod
-    def _validate_slices(
-        io: PortDirection,
-        input_names: Collection[IOName],
-        fp: FunctionParams,
-        strict_zero_ios: bool,
-        control_states: List[ControlState],
-    ) -> None:
-        name_slice_pairs = [parse_io_slicing(input) for input in input_names]
-        slices_dict: Dict[str, List[slice]] = defaultdict(list)
-        for name, slice_obj in name_slice_pairs:
-            slices_dict[name].append(slice_obj)
-
-        fp_inputs = (
-            fp.inputs_full(strict_zero_ios)
-            if (io == PortDirection.Input)
-            else fp.outputs
-        )
-        widths = {name: reg.size for name, reg in fp_inputs.items()}
-        control_names = {state.name for state in control_states}
-
-        for name in slices_dict:
-            if name in control_names:
-                continue
-            assert name in widths, "Name not in widths"
-            if not QuantumFunctionCall._register_validate_slices(
-                slices_dict[name], widths[name]
-            ):
-                raise ValueError(BAD_INPUT_SLICING_MSG)
-
-    @staticmethod
-    def _register_validate_slices(slices: List[slice], reg_width: int) -> bool:
-        widths_separated = [len(range(reg_width)[reg_slice]) for reg_slice in slices]
-        # examples: slice(0), slice(5,None) when width <= 5, slice(5,3)
-        empty_slices = 0 in widths_separated
-
-        max_stop = max(reg_slice.stop or 0 for reg_slice in slices)
-        out_of_range = max_stop > reg_width
-
-        all_widths_separated = sum(widths_separated)
-        all_indices = set(
-            itertools.chain.from_iterable(
-                range(reg_width)[reg_slice] for reg_slice in slices
-            )
-        )
-        all_widths_combined = len(all_indices)
-        overlapping_slices = all_widths_combined != all_widths_separated
-
-        return not any((empty_slices, out_of_range, overlapping_slices))
-
-    @pydantic.validator("inputs")
-    def _validate_inputs(
-        cls, inputs: Mapping[IOName, HandleBinding], values: Dict[str, Any]
-    ) -> Mapping[IOName, HandleBinding]:
-        params: Optional[FunctionParams] = values.get("function_params")
-        strict_zero_ios: bool = values.get("strict_zero_ios", True)
-        control_states: List[ControlState] = values.get("control_states", list())
-        if params is None:
-            return dict()
-        if isinstance(params, CustomFunction):
-            if not isinstance(inputs, dict):
-                raise ValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
-            return inputs
-
-        cls._validate_input_names(
-            params=params,
-            input_names=inputs.keys(),
-            control_states=control_states,
-            strict_zero_ios=strict_zero_ios,
-        )
-
-        cls._validate_slices(
-            PortDirection.Input,
-            inputs.keys(),
-            params,
-            strict_zero_ios,
-            control_states,
-        )
-
-        return inputs
-
-    @staticmethod
-    def _validate_output_names(
-        *,
-        params: f_params.FunctionParams,
-        output_names: Collection[IOName],
-        control_states: List[ControlState],
-        strict_zero_ios: bool,
-    ) -> None:
-        (
-            invalid_expressions,
-            invalid_slicings,
-            invalid_names,
-        ) = QuantumFunctionCall._get_invalid_ios(
-            expressions=output_names,
-            params=params,
-            io=PortDirection.Output,
-            control_states=control_states,
-            strict_zero_ios=strict_zero_ios,
-        )
-        error_msg = []
-        if invalid_expressions:
-            error_msg.append(f"{BAD_OUTPUT_EXPRESSION_MSG}: {invalid_expressions}")
-        if invalid_names:
-            error_msg.append(f"{BAD_OUTPUT_ERROR_MSG}: {invalid_names}")
-        if invalid_slicings:
-            error_msg.append(f"{BAD_OUTPUT_SLICING_MSG}: {invalid_slicings}")
-        if error_msg:
-            raise ValueError("\n".join(error_msg))
-
-    @pydantic.validator("outputs")
-    def _validate_outputs(
-        cls, outputs: Mapping[IOName, HandleBinding], values: Dict[str, Any]
-    ) -> Mapping[IOName, HandleBinding]:
-        params = values.get("function_params")
-        strict_zero_ios: bool = values.get("strict_zero_ios", True)
-        control_states = values.get("control_states", list())
-        if params is None:
-            return outputs
-        if isinstance(params, CustomFunction):
-            if not isinstance(outputs, dict):
-                raise ValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
-            return outputs
-
-        cls._validate_output_names(
-            params=params,
-            output_names=outputs.keys(),
-            control_states=control_states,
-            strict_zero_ios=strict_zero_ios,
-        )
-
-        cls._validate_slices(
-            PortDirection.Output,
-            outputs.keys(),
-            params,
-            strict_zero_ios,
-            control_states,
-        )
-
-        return outputs
-
-    @staticmethod
-    def _get_invalid_ios(
-        *,
-        expressions: Iterable[str],
-        params: f_params.FunctionParams,
-        io: f_params.PortDirection,
-        control_states: List[ControlState],
-        strict_zero_ios: bool,
-    ) -> Tuple[List[str], List[str], List[str]]:
-        expression_matches: Iterable[Optional[Match]] = map(
-            functools.partial(re.fullmatch, IO_REGEX), expressions
-        )
-
-        valid_matches: List[Match] = []
-        invalid_expressions: List[str] = []
-        for expression, expression_match in zip(expressions, expression_matches):
-            invalid_expressions.append(
-                expression
-            ) if expression_match is None else valid_matches.append(expression_match)
-
-        invalid_slicings: List[str] = []
-        invalid_names: List[str] = []
-        valid_names = frozenset(
-            params.inputs_full(strict_zero_ios)
-            if io == PortDirection.Input
-            else params.outputs
-        )
-        for match in valid_matches:
-            name = match.groupdict().get(NAME)
-            if name is None:
-                raise AssertionError("Input/output name validation error")
-
-            slicing = match.groupdict().get(SLICING)
-            if slicing is not None and re.fullmatch(LEGAL_SLICING, slicing) is None:
-                invalid_slicings.append(match.string)
-
-            if name in valid_names:
-                continue
-            elif all(state.name != name for state in control_states):
-                invalid_names.append(name)
-
-        return invalid_expressions, invalid_slicings, invalid_names
-
-    def get_param_exprs(self) -> Dict[str, Expression]:
-        if isinstance(self.function_params, CustomFunction):
-            return self.params
-        else:
-            return {
-                name: Expression(expr=raw_expr)
-                for name, raw_expr in self.function_params
-                if self.function_params.is_field_gen_param(name)
-            }
-
     @pydantic.root_validator()
     def validate_handles(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         inputs = values.get("inputs", dict())
@@ -659,9 +339,6 @@ class QuantumFunctionCall(QuantumOperation):
 
         return values
 
-    class Config:
-        extra = Extra.forbid
-
 
 class QuantumLambdaFunction(BaseModel):
     """

classiq/interface/model/quantum_function_declaration.py

@@ -2,11 +2,7 @@ from typing import Any, ClassVar, Dict, List, Mapping, Sequence, Set, Type, Unio
 
 import pydantic
 
-from classiq.interface.generator.function_params import (
-    ArithmeticIODict,
-    IOName,
-    PortDirection,
-)
+from classiq.interface.generator.function_params import ArithmeticIODict, PortDirection
 from classiq.interface.generator.functions.function_declaration import (
     FunctionDeclaration,
 )
@@ -56,7 +52,7 @@ PositionalArg = Union[
 
 
 def _ports_to_registers(
-    port_declarations: Dict[IOName, PortDeclaration], direction: PortDirection
+    port_declarations: Dict[str, PortDeclaration], direction: PortDirection
 ) -> ArithmeticIODict:
     return {
         name: quantum_var_to_register(name, port_decl.quantum_type)
@@ -70,7 +66,7 @@ class QuantumFunctionDeclaration(FunctionDeclaration):
     Facilitates the creation of a common quantum function interface object.
     """
 
-    port_declarations: Dict[IOName, PortDeclaration] = pydantic.Field(
+    port_declarations: Dict[str, PortDeclaration] = pydantic.Field(
         description="The input and output ports of the function.",
         default_factory=dict,
     )
@@ -89,11 +85,11 @@ class QuantumFunctionDeclaration(FunctionDeclaration):
     ] = {}
 
     @property
-    def input_set(self) -> Set[IOName]:
+    def input_set(self) -> Set[str]:
         return set(self.inputs.keys())
 
     @property
-    def output_set(self) -> Set[IOName]:
+    def output_set(self) -> Set[str]:
         return set(self.outputs.keys())
 
     @property
@@ -138,8 +134,8 @@ class QuantumFunctionDeclaration(FunctionDeclaration):
 
     @pydantic.validator("port_declarations")
     def _validate_port_declarations_names(
-        cls, port_declarations: Dict[IOName, PortDeclaration]
-    ) -> Dict[IOName, PortDeclaration]:
+        cls, port_declarations: Dict[str, PortDeclaration]
+    ) -> Dict[str, PortDeclaration]:
         validate_nameables_mapping(port_declarations, "Port")
         return port_declarations
 

classiq/interface/model/quantum_statement.py

@@ -1,26 +1,32 @@
 from typing import Mapping, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Extra
 
-from classiq.interface.generator.function_params import IOName
-from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
 
 
 class QuantumStatement(BaseModel):
-    pass
+    class Config:
+        extra = Extra.forbid
 
 
 class QuantumOperation(QuantumStatement):
     @property
-    def wiring_inputs(self) -> Mapping[IOName, HandleBinding]:
+    def wiring_inputs(self) -> Mapping[str, HandleBinding]:
         return dict()
 
     @property
     def wiring_inouts(
         self,
-    ) -> Mapping[IOName, Union[SlicedHandleBinding, HandleBinding]]:
+    ) -> Mapping[
+        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
+    ]:
         return dict()
 
     @property
-    def wiring_outputs(self) -> Mapping[IOName, HandleBinding]:
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return dict()

classiq/interface/model/validations/handle_validation_base.py

@@ -1,7 +1,6 @@
 import abc
 from typing import Dict, Mapping, Type
 
-from classiq.interface.generator.function_params import IOName
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -17,7 +16,7 @@ EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
 class HandleValidationBase(abc.ABC):
     def __init__(
         self,
-        port_declarations: Mapping[IOName, PortDeclaration],
+        port_declarations: Mapping[str, PortDeclaration],
     ) -> None:
         self._port_declarations = port_declarations.values()