classiq 0.33.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

classiq/interface/model/quantum_function_call.py

@@ -1,59 +1,23 @@
-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,
-    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,
@@ -67,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(
@@ -143,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 "
@@ -196,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:
@@ -260,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(),
@@ -308,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(),
@@ -323,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(),
@@ -337,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]
@@ -352,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[str],
-        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:
@@ -399,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()
 
@@ -432,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[str],
-        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[str, HandleBinding], values: Dict[str, Any]
-    ) -> Mapping[str, 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[str],
-        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[str, HandleBinding], values: Dict[str, Any]
-    ) -> Mapping[str, 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())
@@ -666,9 +339,6 @@ class QuantumFunctionCall(QuantumOperation):
 
         return values
 
-    class Config:
-        extra = Extra.forbid
-
 
 class QuantumLambdaFunction(BaseModel):
     """

classiq/interface/model/quantum_statement.py

@@ -1,6 +1,6 @@
 from typing import Mapping, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Extra
 
 from classiq.interface.model.handle_binding import (
     HandleBinding,
@@ -10,7 +10,8 @@ from classiq.interface.model.handle_binding import (
 
 
 class QuantumStatement(BaseModel):
-    pass
+    class Config:
+        extra = Extra.forbid
 
 
 class QuantumOperation(QuantumStatement):

classiq/interface/server/routes.py

@@ -3,6 +3,10 @@ CHEMISTRY_PREFIX = "/chemistry"
 LEGACY_EXECUTE_PREFIX = "/execute"
 EXECUTION_PREFIX = "/execution"
 
+SYNTHESIS_SERVICE_PREFIX = "/synthesis/v1"
+
+EXECUTION_SERVICE_PREFIX = "/execution/v1"
+
 ANALYZER_CIRCUIT_PAGE = "circuit"
 DEFAULT_IDE_FE_APP = "https://platform.classiq.io/"
 
@@ -34,9 +38,7 @@ DATA_DOG_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{DATA_DOG_EVENT_TASK}"
 
 IDE_QASM_TASK = f"{TASKS_SUFFIX}/generated_circuit_from_qasm"
 IDE_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_QASM_TASK}"
-IDE_EXECUTION_RESULTS_PATH = f"/results{LEGACY_EXECUTE_PREFIX}"
 TASKS_GENERATE_SUFFIX = TASKS_SUFFIX + "/generate"
-SEMANTICS_CHECK_SUFFIX = TASKS_SUFFIX + "/semantic_checks"
 TASKS_VISUALIZE_SUFFIX = TASKS_SUFFIX + "/visualize"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
 MODEL_GENERATE_PREFIX = "/generate_model"
@@ -50,10 +52,10 @@ TASKS_GENERATE_FULL_PATH = TASKS_GENERATE_SUFFIX
 TASKS_SOLVE_EXACT_SUFFIX = "/tasks/solve_exact"
 TASKS_UCC_OPERATORS_SUFFIX = "/tasks/ucc_operators"
 
-TASKS_GET_MAX_CUT_MODEL = "/tasks/get_max_cut_model"
 
 EXECUTION_JOBS_SUFFIX = "/jobs"
 EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
+EXECUTION_SERVICE_JOBS_FULL_PATH = EXECUTION_SERVICE_PREFIX + EXECUTION_JOBS_SUFFIX
 EXECUTE_QUANTUM_PROGRAM_FULL_PATH = LEGACY_EXECUTE_PREFIX + QUANTUM_PROGRAM_SUFFIX
 EXECUTE_ESTIMATE_FULL_PATH = LEGACY_EXECUTE_PREFIX + ESTIMATE_SUFFIX
 
@@ -61,12 +63,12 @@ ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX
 GENERATE_RESOURCE_ESTIMATOR_REPORT = "/resource_estimator_report"
 
-CHEMISTRY_GENERATE_HAMILTONIAN_FULL_PATH = CHEMISTRY_PREFIX + TASKS_SUFFIX
+GENERATE_HAMILTONIAN_SUFFIX = "/generate_hamiltonian"
+GENERATE_HAMILTONIAN_FULL_PATH = SYNTHESIS_SERVICE_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
+
 CHEMISTRY_GENERATE_UCC_OPERATORS_FULL_PATH = (
     CHEMISTRY_PREFIX + TASKS_UCC_OPERATORS_SUFFIX
 )
-CHEMISTRY_SOLVE_EXACT_FULL_PATH = CHEMISTRY_PREFIX + TASKS_SOLVE_EXACT_SUFFIX
-CHEMISTRY_SOLVE_FULL_PATH = CHEMISTRY_PREFIX + TASKS_SOLVE_SUFFIX
 
 FINANCE_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/finance"