classiq 0.43.3__py3-none-any.whl → 0.44.0__py3-none-any.whl

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -1,14 +1,13 @@
 import abc
-from typing import Dict, List, Mapping, Optional, Union
+from typing import Dict, List, Mapping, Optional
 
 import pydantic
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
     HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.quantum_type import QuantumType
@@ -43,16 +42,12 @@ class QuantumExpressionOperation(QuantumOperation):
         self._var_types = var_types
 
     @property
-    def wiring_inouts(
-        self,
-    ) -> Mapping[
-        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-    ]:
+    def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
         return nameables_to_dict(self.var_handles)
 
 
 class QuantumAssignmentOperation(QuantumExpressionOperation):
-    result_var: HandleBinding = pydantic.Field(
+    result_var: ConcreteHandleBinding = pydantic.Field(
         description="The variable storing the expression result"
     )
     _result_type: Optional[QuantumType] = pydantic.PrivateAttr(

classiq/interface/model/quantum_function_call.py

@@ -1,104 +1,40 @@
-import itertools
-from typing import Any, Dict, List, Literal, Mapping, Optional, Type, Union
+from typing import (
+    Dict,
+    Iterable,
+    List,
+    Literal,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
+from uuid import UUID, uuid4
 
 import pydantic
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.function_declaration import (
-    FunctionDeclaration,
-)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
     HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
 )
+from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import (
-    QuantumOperand,
-)
-from classiq.interface.model.quantum_statement import QuantumOperation
-from classiq.interface.model.validation_handle import get_unique_handle_names
+from classiq.interface.model.quantum_lambda_function import QuantumOperand
+from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
 from classiq.exceptions import ClassiqError, ClassiqValueError
 
-
-def _validate_no_duplicated_ports(
-    inputs: Mapping[str, HandleBinding],
-    outputs: Mapping[str, HandleBinding],
-    inouts: Mapping[str, HandleBinding],
-) -> None:
-    inputs_and_inouts = inputs.keys() & inouts.keys()
-    if inputs_and_inouts:
-        raise ClassiqValueError(
-            f"{inputs_and_inouts} are used as ports in both inputs and inouts"
-        )
-
-    outputs_and_inouts = outputs.keys() & inouts.keys()
-    if outputs_and_inouts:
-        raise ClassiqValueError(
-            f"{outputs_and_inouts} are used as ports in both outputs and inouts"
-        )
-
-
-def _validate_no_duplicated_handles(
-    inputs: Mapping[str, HandleBinding],
-    outputs: Mapping[str, HandleBinding],
-    inouts: Mapping[str, HandleBinding],
-) -> None:
-    inputs_and_inouts = get_unique_handle_names(inputs) & get_unique_handle_names(
-        inouts
-    )
-    if inputs_and_inouts:
-        raise ClassiqValueError(
-            f"{inputs_and_inouts} are used as handles in both inputs and inouts"
-        )
-
-    outputs_and_inouts = get_unique_handle_names(outputs) & get_unique_handle_names(
-        inouts
-    )
-    if outputs_and_inouts:
-        raise ClassiqValueError(
-            f"{outputs_and_inouts} are used as handles in both outputs and inouts"
-        )
-
-
-def _validate_no_mixing_sliced_and_whole_handles(
-    inouts: Mapping[str, HandleBinding],
-) -> None:
-    def _treat_subscript_as_slice(type_: Type[HandleBinding]) -> Type[HandleBinding]:
-        if type_ == SubscriptHandleBinding:
-            return SlicedHandleBinding
-        return type_
-
-    inout_handle_names_to_types = {
-        handle_name: {_treat_subscript_as_slice(type(handle)) for handle in handles}
-        for handle_name, handles in itertools.groupby(
-            inouts.values(), lambda handle: handle.name
-        )
-    }
-    invalid_handles = [
-        handle
-        for handle, types in inout_handle_names_to_types.items()
-        if len(types) > 1
-    ]
-    if invalid_handles:
-        raise ClassiqValueError(
-            f"Inout handles {', '.join(invalid_handles)} mix sliced and whole handles"
-        )
-
-
 ArgValue = Union[
     Expression,
     QuantumOperand,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
-    HandleBinding,
+    ConcreteHandleBinding,
 ]
 
 
@@ -113,26 +49,10 @@ class QuantumFunctionCall(QuantumOperation):
     function: Union[str, OperandIdentifier] = pydantic.Field(
         description="The function that is called"
     )
-    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",
-    )
-    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",
-    )
-    designated_outputs: Dict[str, HandleBinding] = pydantic.Field(
-        default_factory=dict,
-        description="A mapping from the output name to the wire it connects to",
-    )
-    designated_operands: Dict[str, QuantumOperand] = pydantic.Field(
-        description="Function calls passed to the operator",
-        default_factory=dict,
-    )
     positional_args: List[ArgValue] = pydantic.Field(default_factory=list)
+    uuid: UUID = pydantic.Field(
+        description="A unique identifier for this call", default_factory=uuid4
+    )
 
     _func_decl: Optional[QuantumFunctionDeclaration] = pydantic.PrivateAttr(
         default=None
@@ -145,7 +65,7 @@ class QuantumFunctionCall(QuantumOperation):
 
         return self._func_decl
 
-    def set_func_decl(self, fd: Optional[FunctionDeclaration]) -> None:
+    def set_func_decl(self, fd: Optional[QuantumFunctionDeclaration]) -> None:
         if fd is not None and not isinstance(fd, QuantumFunctionDeclaration):
             raise ClassiqValueError(
                 "the declaration of a quantum function call cannot be set to a non-quantum function declaration."
@@ -160,76 +80,113 @@ class QuantumFunctionCall(QuantumOperation):
 
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
-        return self.inputs
+        return self._get_pos_port_args_by_direction(PortDeclarationDirection.Input)
+
+    @property
+    def inputs(self) -> Sequence[HandleBinding]:
+        return [
+            handle
+            for _, _, handle in self._get_handles_by_direction(
+                PortDeclarationDirection.Input
+            )
+        ]
+
+    @property
+    def readable_inputs(self) -> Sequence[HandleMetadata]:
+        return [
+            HandleMetadata(
+                handle=handle,
+                readable_location=self._get_readable_location(param_idx, param),
+            )
+            for param_idx, param, handle in self._get_handles_by_direction(
+                PortDeclarationDirection.Input
+            )
+        ]
 
     @property
     def wiring_inouts(
         self,
-    ) -> Mapping[
-        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-    ]:
-        return self.inouts
+    ) -> Mapping[str, ConcreteHandleBinding]:
+        return self._get_pos_port_args_by_direction(PortDeclarationDirection.Inout)
+
+    @property
+    def inouts(self) -> Sequence[HandleBinding]:
+        return [
+            handle
+            for _, _, handle in self._get_handles_by_direction(
+                PortDeclarationDirection.Inout
+            )
+        ]
+
+    @property
+    def readable_inouts(self) -> Sequence[HandleMetadata]:
+        return [
+            HandleMetadata(
+                handle=handle,
+                readable_location=self._get_readable_location(param_idx, param),
+            )
+            for param_idx, param, handle in self._get_handles_by_direction(
+                PortDeclarationDirection.Inout
+            )
+        ]
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        return self.outputs
+        return self._get_pos_port_args_by_direction(PortDeclarationDirection.Output)
 
-    def get_positional_args(self) -> List[ArgValue]:
-        result: List[ArgValue] = self.positional_args
-        if not result:
-            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 outputs(self) -> Sequence[HandleBinding]:
+        return [
+            handle
+            for _, _, handle in self._get_handles_by_direction(
+                PortDeclarationDirection.Output
+            )
+        ]
 
     @property
-    def positional_params(self) -> Dict[str, Expression]:
-        return dict(
-            zip(
-                self.func_decl.param_decls.keys(),
-                (
-                    param
-                    for param in self.positional_args
-                    if isinstance(param, Expression)
-                ),
+    def readable_outputs(self) -> Sequence[HandleMetadata]:
+        return [
+            HandleMetadata(
+                handle=handle,
+                readable_location=self._get_readable_location(param_idx, param),
             )
-        )
+            for param_idx, param, handle in self._get_handles_by_direction(
+                PortDeclarationDirection.Output
+            )
+        ]
 
     @property
-    def params(self) -> Dict[str, Expression]:
-        return self.positional_params or self.designated_params
+    def params(self) -> List[Expression]:
+        return [
+            param for param in self.positional_args if isinstance(param, Expression)
+        ]
 
     @property
-    def positional_operands(self) -> Dict[str, "QuantumOperand"]:
-        return dict(
-            zip(
-                self.func_decl.operand_declarations.keys(),
-                (
-                    param
-                    for param in self.positional_args
-                    if not isinstance(param, (Expression, HandleBinding))
-                ),
-            )
-        )
+    def params_dict(self) -> Dict[str, Expression]:
+        return dict(zip(self.func_decl.param_names, self.params))
 
     @property
-    def operands(self) -> Dict[str, "QuantumOperand"]:
-        return self.positional_operands or self.designated_operands
+    def operands(self) -> List["QuantumOperand"]:
+        return [
+            param
+            for param in self.positional_args
+            if not isinstance(param, (Expression, HandleBinding))
+        ]
 
     @property
-    def pos_port_args(self) -> Dict[str, HandleBinding]:
-        return dict(
-            zip(
-                self.func_decl.port_declarations.keys(),
-                (
-                    param
-                    for param in self.positional_args
-                    if isinstance(param, HandleBinding)
-                ),
-            )
-        )
+    def ports(self) -> List[HandleBinding]:
+        return [
+            param for param in self.positional_args if isinstance(param, HandleBinding)
+        ]
+
+    def _get_handles_by_direction(
+        self, direction: PortDeclarationDirection
+    ) -> List[Tuple[int, AnonPortDeclaration, HandleBinding]]:
+        return [
+            (idx, port_decl, handle)
+            for idx, port_decl, handle in self._get_handles_with_declarations()
+            if direction == port_decl.direction
+        ]
 
     def _get_pos_port_args_by_direction(
         self, direction: PortDeclarationDirection
@@ -240,49 +197,35 @@ class QuantumFunctionCall(QuantumOperation):
         if self._func_decl is None:
             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)
-                ),
-            )
+            port_decl.get_name(): handle
+            for _, port_decl, handle in self._get_handles_with_declarations()
             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
-        )
-
-    @property
-    def inouts(
+    def _get_handles_with_declarations(
         self,
-    ) -> Dict[str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]]:
-        return (
-            self._get_pos_port_args_by_direction(PortDeclarationDirection.Inout)
-            or self.designated_inouts
-        )
+    ) -> Iterable[Tuple[int, AnonPortDeclaration, HandleBinding]]:
+        return [
+            (idx, port, handle)
+            for idx, (port, handle) in enumerate(
+                zip(
+                    (port_decl for port_decl in self.func_decl.port_declarations),
+                    (
+                        param
+                        for param in self.positional_args
+                        if isinstance(param, HandleBinding)
+                    ),
+                )
+            )
+        ]
 
-    @property
-    def outputs(self) -> Dict[str, HandleBinding]:
-        return (
-            self._get_pos_port_args_by_direction(PortDeclarationDirection.Output)
-            or self.designated_outputs
+    def _get_readable_location(
+        self, param_index: int, param_decl: AnonPortDeclaration
+    ) -> str:
+        param_name = (
+            repr(param_decl.name) if param_decl.name is not None else f"#{param_index}"
         )
-
-    @pydantic.root_validator()
-    def validate_handles(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        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
+        param_text = (
+            f" for parameter {param_name}" if len(self.positional_args) > 1 else ""
+        )
+        return f"as an argument{param_text} of function {self.func_name!r}"