classiq 0.42.2__py3-none-any.whl → 0.43.1__py3-none-any.whl

classiq/interface/jobs.py

@@ -1,16 +1,18 @@
-from typing import Any, Dict, Generic, Literal, TypeVar, Union
+from typing import Any, Dict, Generic, Optional, TypeVar, Union
 
 import pydantic
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from pydantic.generics import GenericModel
 
 from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqAPIError
 
 JSONObject = Dict[str, Any]
 T = TypeVar("T", bound=Union[pydantic.BaseModel, JSONObject])
 AUTH_HEADER = "Classiq-BE-Auth"
+INVALID_RESPONSE_ERROR_MSG = "Invalid response from Classiq API"
 
 
 class JobID(BaseModel):
@@ -34,70 +36,39 @@ class JobStatus(StrEnum):
 """
 A job can be in either of 3 states: ongoing, completed successfully or completed
 unsuccessfully. Each job status belongs to one of the 3 states
-The class JobDescriptionBase represents a job description, regardless of its state
-JobDescriptionSuccess represents a job that was completed successfully. It contains the
-job result in the description field. The type of the result depends on the route, and
-so it's defined as a generic class
-JobDescriptionFailure represents a job that was completed unsuccessfully. It contains
-the failure details (i.e., error message) in the description field
-JobDescriptionNonFinal represents a job that has not terminated yet. It does not contain
-any additional information
-JobDescriptionUnion is used to define a discriminator field between the 3 states. Since
-JobDescriptionSuccess is generic, so is the union. This means it cannot be defined
-as an annotated type alias (that is, we cannot define
-JobDescriptionUnion = Annotated[Union[...], Field(discriminator="kind")])
+For ongoing jobs, we expect both the failure_details and result to be None
+For successful jobs, we expect failure_details to be None and result to be an instance of T
+For unsuccessful jobs, we expect failure_details to be a string and result to be None
 """
 
-SuccessStatus = Literal[JobStatus.COMPLETED]
-FailureStatus = Union[
-    Literal[JobStatus.FAILED],
-    Literal[JobStatus.CANCELLED],
-]
-NonFinalStatus = Union[
-    Literal[JobStatus.QUEUED],
-    Literal[JobStatus.RUNNING],
-    Literal[JobStatus.READY],
-    Literal[JobStatus.CANCELLING],
-    Literal[JobStatus.UNKNOWN],
-]
 
-
-class FailureDetails(BaseModel):
-    details: str
-
-
-class JobDescriptionBase(GenericModel, Generic[T], json_encoders=CUSTOM_ENCODERS):
-    kind: str
+class JobDescription(GenericModel, Generic[T], json_encoders=CUSTOM_ENCODERS):
     status: JobStatus
-    description: Union[T, FailureDetails, Dict]
-
-
-class JobDescriptionSuccess(JobDescriptionBase[T], Generic[T]):
-    kind: Literal["success"] = pydantic.Field(default="success")
-    status: SuccessStatus = Field(default=JobStatus.COMPLETED)
-    description: T
-
-
-class JobDescriptionFailure(JobDescriptionBase[Any]):
-    kind: Literal["failure"] = pydantic.Field(default="failure")
-    status: FailureStatus
-    description: FailureDetails
-
-
-class JobDescriptionNonFinal(JobDescriptionBase[Any]):
-    kind: Literal["non_final"] = pydantic.Field(default="non_final")
-    status: NonFinalStatus
-    description: Dict = Field(default_factory=dict)
-
-    @pydantic.validator("description")
-    def validate_empty_description(cls, description: Dict) -> Dict:
-        if description:
-            raise ValueError("Non-final job description must be empty")
-
-        return description
-
-
-class JobDescriptionUnion(GenericModel, Generic[T], json_encoders=CUSTOM_ENCODERS):
-    __root__: Union[
-        JobDescriptionSuccess[T], JobDescriptionFailure, JobDescriptionNonFinal
-    ] = Field(discriminator="kind")
+    failure_details: Optional[str]
+    result: Optional[T]
+
+    @pydantic.root_validator
+    def validate_status_and_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        status: Optional[JobStatus] = values.get("status")
+        if status is None or "result" not in values or "failure_details" not in values:
+            # If any of the fields doesn't exist, then previous validations failed
+            # result and failure_details are Optional, so we explicitly check if they
+            # exist in the values dictionary
+            return values
+
+        result = values["result"]
+        failure_details = values["failure_details"]
+
+        if status is JobStatus.COMPLETED:
+            # Completed job must return result and not have an error
+            if result is None or failure_details is not None:
+                raise ClassiqAPIError(INVALID_RESPONSE_ERROR_MSG)
+        elif status in (JobStatus.FAILED, JobStatus.CANCELLED):
+            # Failed job must return error and not have result
+            if result is not None or failure_details is None:
+                raise ClassiqAPIError(INVALID_RESPONSE_ERROR_MSG)
+        elif result is not None or failure_details is not None:
+            # Pending job must have no result and no error
+            raise ClassiqAPIError(INVALID_RESPONSE_ERROR_MSG)
+
+        return values

classiq/interface/model/bind_operation.py

@@ -37,3 +37,6 @@ class BindOperation(QuantumOperation):
                 raise ClassiqValueError(f"Cannot bind '{handle}'")
 
         return handles
+
+    def reversed(self) -> "BindOperation":
+        return BindOperation(in_handles=self.out_handles, out_handles=self.in_handles)

classiq/interface/model/classical_parameter_declaration.py

@@ -18,3 +18,6 @@ class ClassicalParameterDeclaration(ASTNode):
         return values_with_discriminator(
             values, "kind", "ClassicalParameterDeclaration"
         )
+
+    def rename(self, new_name: str) -> "ClassicalParameterDeclaration":
+        return self.copy(update=dict(name=new_name))

classiq/interface/model/handle_binding.py

@@ -1,3 +1,5 @@
+from typing import Union
+
 from pydantic import Extra
 
 from classiq.interface.ast_node import ASTNode
@@ -45,3 +47,8 @@ class SlicedHandleBinding(HandleBinding):
 
     def is_bindable(self) -> bool:
         return False
+
+
+ConcreteHandleBinding = Union[
+    HandleBinding, SubscriptHandleBinding, SlicedHandleBinding
+]

classiq/interface/model/inplace_binary_operation.py

@@ -1,13 +1,17 @@
 from typing import Literal, Mapping
 
-import pydantic
-
+from classiq.interface.generator.functions.builtins.core_library import (
+    INTEGER_XOR_FUNCTION,
+    MODULAR_ADD_FUNCTION,
+)
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+)
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
 
 
 class BinaryOperation(StrEnum):
@@ -15,26 +19,20 @@ class BinaryOperation(StrEnum):
     Xor = "inplace_xor"
 
     @property
-    def internal_function(self) -> str:
+    def internal_function_declaration(self) -> QuantumFunctionDeclaration:
         return {
-            BinaryOperation.Addition: "modular_add",
-            BinaryOperation.Xor: "integer_xor",
+            BinaryOperation.Addition: MODULAR_ADD_FUNCTION,
+            BinaryOperation.Xor: INTEGER_XOR_FUNCTION,
         }[self]
 
 
 class InplaceBinaryOperation(QuantumOperation):
     kind: Literal["InplaceBinaryOperation"]
 
-    target: HandleBinding
-    value: HandleBinding
+    target: ConcreteHandleBinding
+    value: ConcreteHandleBinding
     operation: BinaryOperation
 
     @property
     def wiring_inouts(self) -> Mapping[str, HandleBinding]:
         return nameables_to_dict([self.target, self.value])
-
-    @pydantic.validator("target", "value")
-    def validate_handle(cls, handle: HandleBinding) -> HandleBinding:
-        if not handle.is_bindable():
-            raise ClassiqValueError(f"Cannot bind '{handle!r}'")
-        return handle

classiq/interface/model/model.py

@@ -1,5 +1,5 @@
 from collections import Counter
-from typing import Any, Dict, List, Literal, NewType, Optional, Set
+from typing import Dict, List, Literal, NewType, Set
 
 import pydantic
 
@@ -12,6 +12,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.quantum_function_call import SUFFIX_RANDOMIZER
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.helpers.versioned_model import VersionedModel
@@ -19,9 +20,6 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
-from classiq.interface.model.resolvers.function_call_resolver import (
-    resolve_function_calls,
-)
 from classiq.interface.model.statement_block import StatementBlock
 
 from classiq.exceptions import ClassiqValueError
@@ -65,9 +63,14 @@ class Model(VersionedModel, ASTNode):
         description="The user-defined custom type library.",
     )
 
+    enums: List[EnumDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined enums",
+    )
+
     types: List[StructDeclaration] = pydantic.Field(
         default_factory=list,
-        description="The user-defined custom function library.",
+        description="user-defined structs",
     )
 
     classical_execution_code: str = pydantic.Field(
@@ -118,21 +121,6 @@ class Model(VersionedModel, ASTNode):
             functions.append(_create_empty_main_function())
         return functions
 
-    @pydantic.root_validator()
-    def validate_static_correctness(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        functions: Optional[List[QuantumFunctionDeclaration]] = values.get("functions")
-        if functions is None:
-            return values
-
-        resolve_function_calls(
-            values,
-            nameables_to_dict(functions),
-        )
-        for func_def in functions:
-            if isinstance(func_def, NativeFunctionDefinition):
-                func_def.validate_body()
-        return values
-
     @pydantic.validator("types")
     def types_validator(cls, types: List[StructDeclaration]) -> List[StructDeclaration]:
         user_defined_types: Set[str] = set()

classiq/interface/model/native_function_definition.py

@@ -4,12 +4,6 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
 from classiq.interface.model.statement_block import StatementBlock
-from classiq.interface.model.validations.handles_validator import HandleValidator
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
-
-from classiq.exceptions import ClassiqValueError
 
 
 class NativeFunctionDefinition(QuantumFunctionDeclaration):
@@ -23,14 +17,3 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
     body: StatementBlock = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )
-
-    def validate_body(self) -> None:
-        handle_validator = HandleValidator(self.port_declarations)
-
-        for statement in self.body:
-            if isinstance(statement, VariableDeclarationStatement):
-                handle_validator.handle_variable_declaration(statement)
-            else:
-                handle_validator.handle_operation(statement)
-
-        handle_validator.report_errored_handles(ClassiqValueError)

classiq/interface/model/quantum_function_call.py

@@ -1,6 +1,5 @@
 import itertools
-import re
-from typing import Any, Dict, List, Literal, Mapping, Optional, Set, Type, Union
+from typing import Any, Dict, List, Literal, Mapping, Optional, Type, Union
 
 import pydantic
 
@@ -19,11 +18,8 @@ from classiq.interface.model.handle_binding import (
 )
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
-    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
-    QuantumCallable,
-    QuantumLambdaFunction,
     QuantumOperand,
 )
 from classiq.interface.model.quantum_statement import QuantumOperation
@@ -117,22 +113,22 @@ class QuantumFunctionCall(QuantumOperation):
     function: Union[str, OperandIdentifier] = pydantic.Field(
         description="The function that is called"
     )
-    params: Dict[str, Expression] = pydantic.Field(default_factory=dict)
-    inputs: Dict[str, HandleBinding] = pydantic.Field(
+    designated_params: Dict[str, Expression] = pydantic.Field(default_factory=dict)
+    designated_inputs: Dict[str, HandleBinding] = pydantic.Field(
         default_factory=dict,
         description="A mapping from the input name to the wire it connects to",
     )
-    inouts: Dict[
+    designated_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[str, HandleBinding] = pydantic.Field(
+    designated_outputs: Dict[str, HandleBinding] = pydantic.Field(
         default_factory=dict,
         description="A mapping from the output name to the wire it connects to",
     )
-    operands: Dict[str, QuantumOperand] = pydantic.Field(
+    designated_operands: Dict[str, QuantumOperand] = pydantic.Field(
         description="Function calls passed to the operator",
         default_factory=dict,
     )
@@ -181,15 +177,15 @@ class QuantumFunctionCall(QuantumOperation):
     def get_positional_args(self) -> List[ArgValue]:
         result: List[ArgValue] = self.positional_args
         if not result:
-            result = list(self.params.values())
-            result.extend(self.operands.values())
-            result.extend(self.inputs.values())
-            result.extend(self.inouts.values())
-            result.extend(self.outputs.values())
+            result = list(self.designated_params.values())
+            result.extend(self.designated_operands.values())
+            result.extend(self.designated_inputs.values())
+            result.extend(self.designated_inouts.values())
+            result.extend(self.designated_outputs.values())
         return result
 
     @property
-    def pos_param_args(self) -> Dict[str, Expression]:
+    def positional_params(self) -> Dict[str, Expression]:
         return dict(
             zip(
                 self.func_decl.param_decls.keys(),
@@ -202,7 +198,11 @@ class QuantumFunctionCall(QuantumOperation):
         )
 
     @property
-    def pos_operand_args(self) -> Dict[str, "QuantumOperand"]:
+    def params(self) -> Dict[str, Expression]:
+        return self.positional_params or self.designated_params
+
+    @property
+    def positional_operands(self) -> Dict[str, "QuantumOperand"]:
         return dict(
             zip(
                 self.func_decl.operand_declarations.keys(),
@@ -214,6 +214,10 @@ class QuantumFunctionCall(QuantumOperation):
             )
         )
 
+    @property
+    def operands(self) -> Dict[str, "QuantumOperand"]:
+        return self.positional_operands or self.designated_operands
+
     @property
     def pos_port_args(self) -> Dict[str, HandleBinding]:
         return dict(
@@ -227,181 +231,58 @@ class QuantumFunctionCall(QuantumOperation):
             )
         )
 
-    def _update_pos_port_params(self) -> 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]
-            elif port_decl.direction == PortDeclarationDirection.Output:
-                self.outputs[name] = self.pos_port_args[name]
-            else:
-                self.inouts[name] = self.pos_port_args[name]
-
-    def _reduce_positional_args_to_keywords(self) -> None:
-        self.params.update(self.pos_param_args)
-        self.operands.update(self.pos_operand_args)
-        self._update_pos_port_params()
-
-    def resolve_function_decl(
-        self,
-        function_dict: Mapping[str, QuantumFunctionDeclaration],
-        check_operands: bool,
-    ) -> None:
+    def _get_pos_port_args_by_direction(
+        self, direction: PortDeclarationDirection
+    ) -> Dict[str, HandleBinding]:
+        # This is a hack for handles to wires reduction tests,
+        # that initialize function definitions or calls not in the scope of a model,
+        # so there is no function resolution annotation.
         if self._func_decl is None:
-            func_decl = function_dict.get(self.func_name)
-            if func_decl is None:
-                raise ClassiqValueError(
-                    f"Error resolving function {self.func_name}, the function is not found in included library."
-                )
-            self.set_func_decl(func_decl)
-
-        if self.positional_args:
-            self._reduce_positional_args_to_keywords()
-
-        _check_params_against_declaration(
-            set(self.params.keys()),
-            set(self.func_decl.param_decls.keys()),
-            self.func_decl.name,
+            return dict()
+        return {
+            port_decl.name: port
+            for port_decl, port in zip(
+                self.func_decl.port_declarations.values(),
+                (
+                    param
+                    for param in self.positional_args
+                    if isinstance(param, HandleBinding)
+                ),
+            )
+            if direction == port_decl.direction
+        }
+
+    @property
+    def inputs(self) -> Dict[str, HandleBinding]:
+        return (
+            self._get_pos_port_args_by_direction(PortDeclarationDirection.Input)
+            or self.designated_inputs
         )
-        _check_ports_against_declaration(self, self.func_decl)
-        _check_params_against_declaration(
-            set(self.operands.keys()),
-            set(self.func_decl.operand_declarations.keys()),
-            self.func_name,
+
+    @property
+    def inouts(
+        self,
+    ) -> Dict[str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]]:
+        return (
+            self._get_pos_port_args_by_direction(PortDeclarationDirection.Inout)
+            or self.designated_inouts
         )
-        if check_operands:
-            _check_operands_against_declaration(self, self.func_decl, function_dict)
 
-        for name, op in self.operands.items():
-            op_decl = self.func_decl.operand_declarations[name]
-            for qlambda in get_lambda_defs(op):
-                if isinstance(qlambda, QuantumLambdaFunction):
-                    qlambda.set_op_decl(op_decl)
+    @property
+    def outputs(self) -> Dict[str, HandleBinding]:
+        return (
+            self._get_pos_port_args_by_direction(PortDeclarationDirection.Output)
+            or self.designated_outputs
+        )
 
     @pydantic.root_validator()
     def validate_handles(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        inputs = values.get("inputs", dict())
-        outputs = values.get("outputs", dict())
-        inouts = values.get("inouts", dict())
+        inputs = values.get("designated_inputs", dict())
+        outputs = values.get("designated_outputs", dict())
+        inouts = values.get("designated_inouts", dict())
 
         _validate_no_duplicated_ports(inputs, outputs, inouts)
         _validate_no_duplicated_handles(inputs, outputs, inouts)
         _validate_no_mixing_sliced_and_whole_handles(inouts)
 
         return values
-
-
-def get_lambda_defs(operand: QuantumOperand) -> List[QuantumCallable]:
-    if isinstance(operand, list):
-        return operand
-    return [operand]
-
-
-def _check_ports_against_declaration(
-    call: QuantumFunctionCall, decl: QuantumFunctionDeclaration
-) -> None:
-    call_input_names = set(call.inputs.keys())
-
-    _check_params_against_declaration(
-        call_input_names,
-        decl.ports_by_declaration_direction(PortDeclarationDirection.Input),
-        call.func_name,
-    )
-
-    call_output_names = set(call.outputs.keys())
-
-    _check_params_against_declaration(
-        call_output_names,
-        decl.ports_by_declaration_direction(PortDeclarationDirection.Output),
-        call.func_name,
-    )
-
-    inout_params = set(call.inouts.keys())
-
-    _check_params_against_declaration(
-        inout_params,
-        decl.ports_by_declaration_direction(PortDeclarationDirection.Inout),
-        call.func_name,
-    )
-
-
-def _check_operand_against_declaration(
-    call: QuantumFunctionCall,
-    operand_decl: QuantumOperandDeclaration,
-    operand_argument: QuantumOperand,
-    function_dict: Mapping[str, QuantumFunctionDeclaration],
-    in_list: bool = False,
-) -> None:
-    if isinstance(operand_argument, list):
-        if in_list:
-            raise ClassiqValueError(
-                f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not "
-                f"a valid operand. Nested operand lists are not permitted"
-            )
-        for arg in operand_argument:
-            _check_operand_against_declaration(
-                call, operand_decl, arg, function_dict, in_list=True
-            )
-        return
-    operand_arg_decl: QuantumFunctionDeclaration
-    if isinstance(operand_argument, str):
-        if operand_argument not in function_dict:
-            raise ClassiqValueError(
-                f"{operand_argument!r} argument to {call.func_decl.name!r} is not a "
-                f"registered function"
-            )
-        operand_arg_decl = function_dict[operand_argument]
-    elif isinstance(operand_argument, QuantumLambdaFunction):
-        if operand_argument.func_decl is None:
-            return
-        operand_arg_decl = operand_argument.func_decl
-    else:
-        raise ClassiqValueError(
-            f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not a "
-            f"valid operand"
-        )
-    num_arg_parameters = len(operand_arg_decl.get_positional_arg_decls())
-    num_decl_parameters = len(operand_decl.get_positional_arg_decls())
-    if num_arg_parameters != num_decl_parameters:
-        raise ClassiqValueError(
-            f"Signature of argument {operand_argument!r} to {call.func_decl.name!r} "
-            f"does not match the signature of parameter {operand_decl.name!r}. "
-            f"{operand_decl.name!r} accepts {num_decl_parameters} parameters but "
-            f"{operand_argument!r} accepts {num_arg_parameters} parameters"
-        )
-
-
-def _check_operands_against_declaration(
-    call: QuantumFunctionCall,
-    decl: QuantumFunctionDeclaration,
-    function_dict: Mapping[str, QuantumFunctionDeclaration],
-) -> None:
-    for operand_parameter, operand_argument in call.operands.items():
-        _check_operand_against_declaration(
-            call,
-            decl.operand_declarations[operand_parameter],
-            operand_argument,
-            function_dict,
-        )
-
-
-def _check_params_against_declaration(
-    call_params: Set[str],
-    param_decls: Set[str],
-    callee_name: str,
-) -> None:
-    unknown_params = call_params - param_decls
-    if any(re.match(r"arg\d+", param) for param in unknown_params):
-        error_msg = (
-            f"Unsupported passing of named function {callee_name!r} as an operand."
-            "\nSuggestion: replace the named function with lambda function."
-        )
-    else:
-        error_msg = f"Unknown parameters {unknown_params} in call to {callee_name!r}."
-    if unknown_params:
-        raise ClassiqValueError(error_msg)
-
-    missing_params = param_decls - call_params
-    if missing_params:
-        raise ClassiqValueError(
-            f"Missing parameters {missing_params} in call to {callee_name!r}."
-        )