classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/interface/generator/inequality_mixer.py

@@ -1,51 +0,0 @@
-import pydantic
-
-from classiq.interface.generator import function_params
-from classiq.interface.generator.arith.argument_utils import RegisterOrConst
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.parameters import ParameterFloatType
-
-DATA_REG_INPUT_NAME: str = "data_reg_input"
-BOUND_REG_INPUT_NAME: str = "bound_reg_input"
-
-DATA_REG_OUTPUT_NAME: str = "data_reg_output"
-BOUND_REG_OUTPUT_NAME: str = "bound_reg_output"
-
-
-class InequalityMixer(function_params.FunctionParams):
-    """
-    Mixing a fixed point number variable below a given upper bound or above a given
-    lower bound. i.e. after applying this function the variable will hold a
-    superposition position of all the valid values.
-    """
-
-    data_reg_input: RegisterArithmeticInfo = pydantic.Field(
-        description="The input variable to mix."
-    )
-
-    bound_reg_input: RegisterOrConst = pydantic.Field(
-        description="Fixed number or variable that define the upper or lower bound for"
-        " the mixing operation. In case of a fixed number bound, the value"
-        " must be positive."
-    )
-
-    mixer_parameter: ParameterFloatType = pydantic.Field(
-        description="The parameter used for rotation gates in the mixer.",
-        is_exec_param=True,
-    )
-
-    is_less_inequality: bool = pydantic.Field(
-        default=True,
-        description="Whether to mix below or above a certain bound."
-        "Less inequality mixes between 0 and the given bound."
-        "Greater inequality mixes between the bound and the maximal number allowed by"
-        " the number of qubits (i.e 2^n - 1).",
-    )
-
-    def _create_ios(self) -> None:
-        self._inputs = {DATA_REG_INPUT_NAME: self.data_reg_input}
-        self._outputs = {DATA_REG_OUTPUT_NAME: self.data_reg_input}
-
-        if isinstance(self.bound_reg_input, RegisterArithmeticInfo):
-            self._inputs[BOUND_REG_INPUT_NAME] = self.bound_reg_input
-            self._outputs[BOUND_REG_OUTPUT_NAME] = self.bound_reg_input

classiq/interface/generator/model/classical_main_validator.py

@@ -1,106 +0,0 @@
-import ast
-from typing import Dict, List
-
-from classiq.model.model import DEFAULT_RESULT_NAME
-
-STANDARD_CMAIN_BODY_LENGTH = 2  # assignment of sample call, save statement
-
-
-class NonStandardClassicalCodeError(Exception):
-    pass
-
-
-# `is_standard_cmain` and `extract_sample_params` could easily be merged to one function, as they
-# are doing similar tasks, but we decided to separate them for the sake of a better interface
-def is_standard_cmain(model_classical_execution_code: str) -> bool:
-    try:
-        classical_body = _get_classical_body(model_classical_execution_code)
-        if len(classical_body) != STANDARD_CMAIN_BODY_LENGTH:
-            return False
-
-        _assert_sample_call(classical_body)
-        _assert_save_statement(classical_body)
-
-        return True
-    except NonStandardClassicalCodeError:
-        return False
-
-
-def extract_sample_params(model_classical_execution_code: str) -> Dict[str, float]:
-    classical_main = _get_classical_body(model_classical_execution_code)
-
-    qmain_params: Dict[str, float] = {}
-    sample_call = _get_sample_call(classical_main)
-    if len(sample_call.args) == 1 and isinstance(sample_call.args[0], ast.Dict):
-        ast_dict = sample_call.args[0]
-        qmain_params = dict(
-            zip(
-                [k.value for k in ast_dict.keys if isinstance(k, ast.Constant)],
-                [v.value for v in ast_dict.values if isinstance(v, ast.Constant)],
-            )
-        )
-
-    return qmain_params
-
-
-def has_classical_exec(model_classical_execution_code: str) -> bool:
-    return model_classical_execution_code != ""
-
-
-def _get_classical_body(model_classical_execution_code: str) -> List[ast.stmt]:
-    if not has_classical_exec(model_classical_execution_code):
-        raise NonStandardClassicalCodeError
-    return ast.parse(model_classical_execution_code).body
-
-
-def _assert_sample_call(classical_body: List[ast.stmt]) -> None:
-    _get_sample_call(classical_body)
-
-
-def _get_sample_call(
-    classical_body: List[ast.stmt],
-) -> ast.Call:
-    classical_call = classical_body[0]
-    if not isinstance(classical_call, ast.Assign):
-        raise NonStandardClassicalCodeError
-
-    if len(classical_call.targets) != 1:
-        raise NonStandardClassicalCodeError
-    target = classical_call.targets[0]
-    if not isinstance(target, ast.Name) or target.id != DEFAULT_RESULT_NAME:
-        raise NonStandardClassicalCodeError
-
-    invoked_expression = classical_call.value
-    if not isinstance(invoked_expression, ast.Call):
-        raise NonStandardClassicalCodeError
-    if (
-        not isinstance(invoked_expression.func, ast.Name)
-        or invoked_expression.func.id != "sample"
-    ):
-        raise NonStandardClassicalCodeError
-
-    return invoked_expression
-
-
-def _assert_save_statement(classical_body: List[ast.stmt]) -> None:
-    save_statement = classical_body[1]
-    if not isinstance(save_statement, ast.Expr) or not isinstance(
-        save_statement.value, ast.Call
-    ):
-        raise NonStandardClassicalCodeError
-
-    call = save_statement.value
-    if not isinstance(call.func, ast.Name) or call.func.id != "save":
-        raise NonStandardClassicalCodeError
-
-    if not len(call.args) == 1:
-        raise NonStandardClassicalCodeError
-
-    if (
-        not isinstance(call.args[0], ast.Dict)
-        or not isinstance(call.args[0].keys[0], ast.Constant)
-        or call.args[0].keys[0].value != DEFAULT_RESULT_NAME
-        or not isinstance(call.args[0].values[0], ast.Name)
-        or call.args[0].values[0].id != DEFAULT_RESULT_NAME
-    ):
-        raise NonStandardClassicalCodeError

classiq/interface/generator/range_mixer.py

@@ -1,56 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.arith.argument_utils import RegisterOrConst
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.function_params import FunctionParams
-from classiq.interface.generator.parameters import ParameterFloatType
-
-DATA_REG_INPUT_NAME: str = "data_reg_input"
-LOWER_BOUND_REG_INPUT_NAME: str = "lower_bound_reg_input"
-UPPER_BOUND_REG_INPUT_NAME: str = "upper_bound_reg_input"
-
-
-DATA_REG_OUTPUT_NAME: str = "data_reg_output"
-LOWER_BOUND_REG_OUTPUT_NAME: str = "lower_bound_reg_output"
-UPPER_BOUND_REG_OUTPUT_NAME: str = "upper_bound_reg_output"
-
-
-class RangeMixer(FunctionParams):
-    """
-    Mixing a fixed point number variable between a given lower and upper bounds.
-    I.e. after applying this function the variable will hold a
-    superposition of all the valid values.
-    """
-
-    data_reg_input: RegisterArithmeticInfo = pydantic.Field(
-        description="The input variable to mix."
-    )
-
-    lower_bound_reg_input: RegisterOrConst = pydantic.Field(
-        description="Fixed number or variable that define the lower bound for"
-        " the mixing operation. In case of a fixed number bound, the value"
-        " must be positive."
-    )
-
-    upper_bound_reg_input: RegisterOrConst = pydantic.Field(
-        description="Fixed number or variable that define the upper bound for"
-        " the mixing operation. In case of a fixed number bound, the value"
-        " must be positive."
-    )
-
-    mixer_parameter: ParameterFloatType = pydantic.Field(
-        description="The parameter used for rotation gates in the mixer.",
-        is_exec_param=True,
-    )
-
-    def _create_ios(self) -> None:
-        self._inputs = {DATA_REG_INPUT_NAME: self.data_reg_input}
-        self._outputs = {DATA_REG_OUTPUT_NAME: self.data_reg_input}
-
-        if isinstance(self.lower_bound_reg_input, RegisterArithmeticInfo):
-            self._inputs[LOWER_BOUND_REG_INPUT_NAME] = self.lower_bound_reg_input
-            self._outputs[LOWER_BOUND_REG_OUTPUT_NAME] = self.lower_bound_reg_input
-
-        if isinstance(self.upper_bound_reg_input, RegisterArithmeticInfo):
-            self._inputs[UPPER_BOUND_REG_INPUT_NAME] = self.upper_bound_reg_input
-            self._outputs[UPPER_BOUND_REG_OUTPUT_NAME] = self.upper_bound_reg_input

classiq/interface/generator/state_propagator.py

@@ -1,74 +0,0 @@
-from typing import Any, Dict, List
-
-import numpy as np
-import pydantic
-
-from classiq.interface.generator import function_params
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.complex_type import Complex
-from classiq.interface.generator.function_params import (
-    DEFAULT_INPUT_NAME,
-    DEFAULT_OUTPUT_NAME,
-)
-
-from classiq.exceptions import ClassiqValueError
-
-
-class StatePropagator(function_params.FunctionParams):
-    """
-    Creates a quantum circuit that propagates the start state vector to the end state vector,
-    both are assumed to be pure states.
-    The default start state vector is |000...0>.
-    """
-
-    end_state_vector: List[Complex] = pydantic.Field(
-        description="The desired state vector at the end of the operator."
-        " Must be of size 2**num_qubits. Does not have to be "
-        "normalized"
-    )
-
-    start_state_vector: List[Complex] = pydantic.Field(
-        default_factory=list,
-        description="The  state vector at the input of the operator."
-        " Must be of size 2**num_qubits. Does not have to be"
-        " normalized",
-    )
-
-    @pydantic.validator("start_state_vector", always=True)
-    def validate_start_state(
-        cls, start_state_vector: List[Complex], values: Dict[str, Any]
-    ) -> List[Complex]:
-        end_state_vector = values.get("end_state_vector")
-        if end_state_vector is None:
-            raise ClassiqValueError(
-                "Cannot validate start_start_vector without end_state_vector"
-            )
-
-        num_qubits = cls._num_qubits(end_state_vector)
-        if len(start_state_vector) == 0:
-            default_start_state_vector = [Complex(0.0) for _ in range(2**num_qubits)]
-            default_start_state_vector[0] = Complex(1.0)
-            start_state_vector = default_start_state_vector
-
-        if len(start_state_vector) != len(end_state_vector):
-            raise ClassiqValueError(
-                "Start and end state vectors are of non-equal length"
-            )
-
-        return start_state_vector
-
-    @staticmethod
-    def _num_qubits(vector: List[Complex]) -> int:
-        return int(np.log2(len(vector)))
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            DEFAULT_INPUT_NAME: RegisterArithmeticInfo(
-                size=self._num_qubits(self.start_state_vector)
-            )
-        }
-        self._outputs = {
-            DEFAULT_OUTPUT_NAME: RegisterArithmeticInfo(
-                size=self._num_qubits(self.end_state_vector)
-            )
-        }

classiq/interface/generator/types/builtin_struct_declarations/__init__.py

@@ -1 +0,0 @@
-from .pauli_struct_declarations import *  # noqa: F403

classiq/interface/generator/types/builtin_struct_declarations/pauli_struct_declarations.py

@@ -1,22 +0,0 @@
-import functools
-
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalList,
-    Pauli,
-    Real,
-    Struct,
-)
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-
-PAULI_TERM = StructDeclaration(
-    name="PauliTerm",
-    variables={
-        "pauli": ClassicalList(element_type=Pauli()),
-        "coefficient": Real(),
-    },
-)
-
-Hamiltonian = functools.partial(ClassicalList, element_type=Struct(name="PauliTerm"))
-
-StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.update(nameables_to_dict([PAULI_TERM]))

classiq/interface/ide/show.py

@@ -1,34 +0,0 @@
-import re
-
-import pydantic
-
-from classiq.interface.analyzer.result import QasmCode
-
-from classiq import QuantumProgram
-from classiq._internals.api_wrapper import ApiWrapper
-from classiq._internals.async_utils import syncify_function
-from classiq.exceptions import ClassiqValueError
-from classiq.synthesis import SerializedQuantumProgram
-
-QASM_VERSION_REGEX = re.compile("OPENQASM (\\d*.\\d*);")
-
-
-async def qasm_show_interactive_async(qasm_code: str) -> None:
-    circuit = await ApiWrapper.get_generated_circuit_from_qasm(QasmCode(code=qasm_code))
-    circuit.show()  # type: ignore[attr-defined]
-
-
-qasm_show_interactive = syncify_function(qasm_show_interactive_async)
-
-
-CANT_PARSE_QUANTUM_PROGRAM_MSG = (
-    "Can not parse quantum_program into GeneratedCircuit, \n"
-)
-
-
-def show(quantum_program: SerializedQuantumProgram) -> None:
-    try:
-        circuit = QuantumProgram.parse_raw(quantum_program)
-    except pydantic.error_wrappers.ValidationError as exc:
-        raise ClassiqValueError(CANT_PARSE_QUANTUM_PROGRAM_MSG) from exc
-    circuit.show()  # type: ignore[attr-defined]

classiq/interface/model/call_synthesis_data.py

@@ -1,68 +0,0 @@
-import dataclasses
-from typing import Any, List, Mapping
-
-from sympy import sympify
-
-from classiq.interface.generator.control_state import ControlState
-from classiq.interface.generator.synthesis_execution_parameter import PydanticPowerType
-
-from classiq.exceptions import ClassiqValueError
-
-ILLEGAL_NESTED_POWER_ERROR = "Nested power calls with a parametric power and an integer power are unsupported: {a}, {b}"
-
-
-def _merge_power(a: PydanticPowerType, b: PydanticPowerType) -> PydanticPowerType:
-    symbolic_res = sympify(a) * sympify(b)
-    if symbolic_res.is_Integer:
-        return int(symbolic_res)
-    elif symbolic_res.is_symbol:
-        return str(symbolic_res)
-    else:
-        raise ClassiqValueError(ILLEGAL_NESTED_POWER_ERROR.format(a=a, b=b))
-
-
-@dataclasses.dataclass
-class CallSynthesisData(Mapping):
-    power: PydanticPowerType = 1
-    is_inverse: bool = False
-    control_states: List[ControlState] = dataclasses.field(default_factory=list)
-    should_control: bool = True
-
-    def merge(self, other: "CallSynthesisData") -> "CallSynthesisData":
-        return CallSynthesisData(
-            power=_merge_power(self.power, other.power),
-            is_inverse=self.is_inverse != other.is_inverse,
-            control_states=self.control_states + other.control_states,
-            should_control=self.should_control and other.should_control,
-        )
-
-    def set_control(self, ctrl_name: str, ctrl_size: int) -> None:
-        self.control_states = [
-            ControlState(
-                name=ctrl_name,
-                num_ctrl_qubits=ctrl_size,
-            )
-        ]
-
-    def update_control_state(self, ctrl_size: int, ctrl_state: str) -> None:
-        prev_ctrl_state = self.control_states.pop()
-        self.control_states.append(
-            ControlState(
-                name=prev_ctrl_state.name,
-                num_ctrl_qubits=ctrl_size,
-                ctrl_state=ctrl_state,
-            )
-        )
-
-    @property
-    def has_control(self) -> bool:
-        return bool(self.control_states)
-
-    def __getitem__(self, key: str) -> Any:
-        return dataclasses.asdict(self)[key]
-
-    def __iter__(self):
-        return iter(dataclasses.asdict(self))
-
-    def __len__(self):
-        return len(dataclasses.asdict(self))

classiq/interface/model/common_model_types.py

@@ -1,23 +0,0 @@
-from typing import TypeVar, Union
-
-from pydantic import BaseModel
-
-from classiq.interface.generator.model.model import (
-    SerializedModel as SerializedSynthesisModel,
-    SynthesisModel,
-)
-from classiq.interface.model.model import (
-    Model as UserModel,
-    SerializedModel as SerializedUserModel,
-)
-
-ModelInput = Union[UserModel, SynthesisModel]
-
-
-class ModelRoot(BaseModel):
-    __root__: ModelInput
-
-
-SerializedModelInput = TypeVar(
-    "SerializedModelInput", SerializedSynthesisModel, SerializedUserModel
-)

classiq/interface/model/quantum_expressions/control_state.py

@@ -1,38 +0,0 @@
-from classiq.exceptions import ClassiqValueError
-
-
-def min_unsigned_bit_length(number: int) -> int:
-    if number < 0:
-        raise ClassiqValueError(
-            f"Quantum register is not signed but control value "
-            f"'{number}' is negative"
-        )
-    return 1 if number == 0 else number.bit_length()
-
-
-def min_signed_bit_length(number: int) -> int:
-    pos_val = abs(number)
-    is_whole = pos_val & (pos_val - 1) == 0
-    if number <= 0 and is_whole:
-        return min_unsigned_bit_length(pos_val)
-    return min_unsigned_bit_length(pos_val) + 1
-
-
-def min_bit_length(number: int, is_signed: bool) -> int:
-    return (
-        min_signed_bit_length(number) if is_signed else min_unsigned_bit_length(number)
-    )
-
-
-def to_twos_complement(value: int, bits: int, is_signed: bool) -> str:
-    required_bits = min_bit_length(value, is_signed)
-    if bits < required_bits:
-        raise ClassiqValueError(
-            f"Cannot express '{value}' using {bits} bits: "
-            f"at least {required_bits} bits are required"
-        )
-    if value >= 0:
-        return bin(value)[2:].zfill(bits)[::-1]
-    mask = (1 << bits) - 1
-    value = (abs(value) ^ mask) + 1
-    return bin(value)[:1:-1].rjust(bits, "1")

classiq/interface/model/quantum_if_operation.py

@@ -1,94 +0,0 @@
-from typing import TYPE_CHECKING, Optional
-
-import pydantic
-from sympy import Equality
-from sympy.core.numbers import Integer
-
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
-from classiq.interface.model.quantum_expressions.control_state import (
-    min_bit_length,
-    to_twos_complement,
-)
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumExpressionOperation,
-)
-
-from classiq.exceptions import ClassiqValueError
-
-if TYPE_CHECKING:
-    from classiq.interface.model.quantum_lambda_function import QuantumOperand
-
-QUANTUM_IF_INOUT_NAME = "ctrl"
-QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT = (
-    "quantum_if condition must be of the form '<quantum-variable> == "
-    "<classical-integer-expression>', but condition's {}-hand side was {!r}"
-)
-
-
-class QuantumIfOperation(QuantumExpressionOperation):
-    then: "QuantumOperand"
-    _ctrl: Optional[QmodQNumProxy] = pydantic.PrivateAttr(
-        default=None,
-    )
-    _ctrl_val: Optional[int] = pydantic.PrivateAttr(
-        default=None,
-    )
-
-    @property
-    def condition(self) -> Expression:
-        return self.expression
-
-    @property
-    def ctrl(self) -> QmodQNumProxy:
-        assert self._ctrl is not None
-        return self._ctrl
-
-    @property
-    def ctrl_val(self) -> int:
-        assert self._ctrl_val is not None
-        return self._ctrl_val
-
-    def resolve_condition(self) -> None:
-        condition = self.condition.value.value
-        if not isinstance(condition, Equality):
-            raise ClassiqValueError(
-                f"quantum_if condition must be an equality, was {str(condition)!r}"
-            )
-        ctrl, ctrl_val = condition.args
-        if isinstance(ctrl, Integer) and isinstance(ctrl_val, QmodQNumProxy):
-            ctrl, ctrl_val = ctrl_val, ctrl
-        if not isinstance(ctrl, QmodQNumProxy):
-            raise ClassiqValueError(
-                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format("left", str(ctrl))
-            )
-        if not isinstance(ctrl_val, Integer):
-            raise ClassiqValueError(
-                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format(
-                    "right", str(ctrl_val)
-                )
-            )
-        self._ctrl, self._ctrl_val = ctrl, int(ctrl_val)
-
-    @property
-    def ctrl_state(self) -> str:
-        is_signed = self.ctrl.is_signed
-        fraction_places = self.ctrl.fraction_digits
-        ctrl_size = len(self.ctrl)
-        if not is_signed and self.ctrl_val < 0:
-            raise ClassiqValueError(
-                f"Variable {str(self.ctrl)!r} is not signed but control value "
-                f"{self.ctrl_val} is negative"
-            )
-        required_qubits = min_bit_length(self.ctrl_val, is_signed)
-        if ctrl_size < required_qubits:
-            raise ClassiqValueError(
-                f"Variable {str(self.ctrl)!r} has {ctrl_size} qubits but control value "
-                f"{str(self.ctrl_val)!r} requires at least {required_qubits} qubits"
-            )
-        if fraction_places != 0:
-            raise ClassiqValueError(
-                f"quantum-if on a non-integer quantum variable {str(self.ctrl)!r} is "
-                f"not supported at the moment"
-            )
-        return to_twos_complement(self.ctrl_val, ctrl_size, is_signed)

classiq/interface/model/resolvers/function_call_resolver.py

@@ -1,43 +0,0 @@
-from typing import Any, Mapping
-
-from classiq.interface.generator.visitor import Visitor
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
-
-
-class FunctionCallResolver(Visitor):
-    def __init__(
-        self,
-        quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
-    ) -> None:
-        self._quantum_function_dict = quantum_function_dict
-
-    def visit_QuantumFunctionCall(self, fc: QuantumFunctionCall) -> None:
-        fc.resolve_function_decl(self._quantum_function_dict, check_operands=True)
-        self.visit_BaseModel(fc)
-
-    def visit_NativeFunctionDefinition(
-        self, func_def: NativeFunctionDefinition
-    ) -> None:
-        curr_dict = self._quantum_function_dict
-        self._quantum_function_dict = {
-            **self._quantum_function_dict,
-            **func_def.operand_declarations,
-        }
-        self.visit_BaseModel(func_def)
-        self._quantum_function_dict = curr_dict
-
-
-def resolve_function_calls(
-    root: Any,
-    quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
-) -> None:
-    FunctionCallResolver(
-        {
-            **QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS,
-            **quantum_function_dict,
-        },
-    ).visit(root)

classiq/interface/model/validations/handle_validation_base.py

@@ -1,55 +0,0 @@
-import abc
-from typing import Dict, Mapping, Type
-
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.validation_handle import HandleState, ValidationHandle
-
-EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
-    PortDeclarationDirection.Output: HandleState.INITIALIZED,
-    PortDeclarationDirection.Inout: HandleState.INITIALIZED,
-}
-
-
-class HandleValidationBase(abc.ABC):
-    def __init__(
-        self,
-        port_declarations: Mapping[str, PortDeclaration],
-    ) -> None:
-        self._port_declarations = port_declarations.values()
-
-    def report_errored_handles(self, exception_type: Type[Exception]) -> None:
-        self._validate_terminal_handle_state()
-
-        errored_handles = {
-            name: state.errors
-            for name, state in self._validation_handles_state.items()
-            if state.state is HandleState.ERRORED
-        }
-        if errored_handles:
-            raise exception_type(
-                "\n".join(
-                    f"Handle {handle_name!r} was errored with {'. '.join(errors)!r}"
-                    for handle_name, errors in errored_handles.items()
-                )
-            )
-
-    def _validate_terminal_handle_state(self) -> None:
-        for port_decl in self._port_declarations:
-            handle_state = self._validation_handles_state[port_decl.name]
-            expected_terminal_state = EXPECTED_TERMINAL_STATES.get(port_decl.direction)
-            if (
-                expected_terminal_state is not None
-                and handle_state.state is not expected_terminal_state
-                and handle_state.state is not HandleState.ERRORED
-            ):
-                handle_state.append_error(
-                    f"At the end of the function, in port {port_decl.name} is expected to be {expected_terminal_state} but it isn't"
-                )
-
-    @property
-    @abc.abstractmethod
-    def _validation_handles_state(self) -> Mapping[str, ValidationHandle]:
-        raise NotImplementedError