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

classiq/interface/model/quantum_function_declaration.py

@@ -1,7 +1,18 @@
-from typing import Any, ClassVar, Dict, List, Mapping, Sequence, Set, Type, Union
+from collections.abc import Sequence
+from typing import (
+    Annotated,
+    Any,
+    Literal,
+    Union,
+)
 
 import pydantic
+from pydantic import SerializeAsAny
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self
 
+from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import ArithmeticIODict, PortDirection
 from classiq.interface.generator.functions.function_declaration import (
     FunctionDeclaration,
@@ -9,219 +20,241 @@ from classiq.interface.generator.functions.function_declaration import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.helpers.pydantic_model_helpers import Nameable
-from classiq.interface.helpers.validation_helpers import (
-    validate_nameables_mapping,
-    validate_nameables_no_overlap,
+from classiq.interface.helpers.pydantic_model_helpers import (
+    values_with_discriminator,
 )
 from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
     ClassicalParameterDeclaration,
 )
-from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.port_declaration import (
+    AnonPortDeclaration,
+    PortDeclaration,
+)
 from classiq.interface.model.quantum_type import quantum_var_to_register
 
-from classiq.exceptions import ClassiqValueError
-
-
-def _is_equiv_kw_and_pos_decl(kw_decl: Nameable, pos_decl: Nameable) -> bool:
-    if isinstance(pos_decl, ClassicalParameterDeclaration):
-        return pos_decl.classical_type == kw_decl
-    return pos_decl == kw_decl
-
-
-def _populate_declaration_dicts_with_positional_lists(
-    pos_decls: Sequence[Nameable],
-    kw_decls: Dict[str, Nameable],
-    param_type: Type[Nameable],
-) -> None:
-    for pos_decl in pos_decls:
-        if not isinstance(pos_decl, param_type):
-            continue
-        kw_decl = kw_decls.get(pos_decl.name)
-        if kw_decl is not None and not _is_equiv_kw_and_pos_decl(kw_decl, pos_decl):
-            raise ClassiqValueError(
-                f"{param_type.__name__} parameter with name {pos_decl.name} already declared"
-            )
-        kw_decls[pos_decl.name] = (
-            pos_decl.classical_type  # type:ignore[assignment]
-            if isinstance(pos_decl, ClassicalParameterDeclaration)
-            else pos_decl
-        )
-
-
-PositionalArg = Union[
-    ClassicalParameterDeclaration, "QuantumOperandDeclaration", PortDeclaration
+AnonPositionalArg = Annotated[
+    Union[
+        AnonClassicalParameterDeclaration,
+        "AnonQuantumOperandDeclaration",
+        AnonPortDeclaration,
+    ],
+    pydantic.Field(..., discriminator="kind"),
 ]
 
 
 def _ports_to_registers(
-    port_declarations: Dict[str, PortDeclaration], direction: PortDirection
-) -> ArithmeticIODict:
-    return {
-        name: quantum_var_to_register(name, port_decl.quantum_type)
-        for name, port_decl in port_declarations.items()
+    port_declarations: Sequence[AnonPortDeclaration], direction: PortDirection
+) -> Sequence[RegisterUserInput]:
+    return [
+        quantum_var_to_register(port_decl.get_name(), port_decl.quantum_type)
+        for port_decl in port_declarations
         if port_decl.direction.includes_port_direction(direction)
-    }
+    ]
 
 
-class QuantumFunctionDeclaration(FunctionDeclaration):
+class AnonQuantumFunctionDeclaration(FunctionDeclaration):
     """
     Facilitates the creation of a common quantum function interface object.
     """
 
-    port_declarations: Dict[str, PortDeclaration] = pydantic.Field(
-        description="The input and output ports of the function.",
-        default_factory=dict,
+    positional_arg_declarations: Sequence[AnonPositionalArg] = pydantic.Field(
+        default_factory=list
     )
 
-    operand_declarations: Mapping[str, "QuantumOperandDeclaration"] = pydantic.Field(
-        description="The expected interface of the quantum function operands",
-        default_factory=dict,
-    )
+    @property
+    def port_declarations(self) -> Sequence[AnonPortDeclaration]:
+        return [
+            arg
+            for arg in self.positional_arg_declarations
+            if isinstance(arg, AnonPortDeclaration)
+        ]
 
-    positional_arg_declarations: List[PositionalArg] = pydantic.Field(
-        default_factory=list
-    )
+    @property
+    def operand_declarations(self) -> Sequence["AnonQuantumOperandDeclaration"]:
+        return [
+            arg
+            for arg in self.positional_arg_declarations
+            if isinstance(arg, AnonQuantumOperandDeclaration)
+        ]
 
-    BUILTIN_FUNCTION_DECLARATIONS: ClassVar[Dict[str, "QuantumFunctionDeclaration"]] = (
-        {}
-    )
+    @property
+    def param_decls(self) -> Sequence[AnonClassicalParameterDeclaration]:
+        return [
+            arg
+            for arg in self.positional_arg_declarations
+            if isinstance(arg, AnonClassicalParameterDeclaration)
+        ]
+
+    @property
+    def param_names(self) -> Sequence[str]:
+        return [param.get_name() for param in self.param_decls]
 
     @property
-    def input_set(self) -> Set[str]:
-        return set(self.inputs.keys())
+    def input_set(self) -> set[str]:
+        return {inp.name for inp in self.inputs}
 
     @property
-    def output_set(self) -> Set[str]:
-        return set(self.outputs.keys())
+    def output_set(self) -> set[str]:
+        return {output.name for output in self.outputs}
 
     @property
-    def inputs(self) -> ArithmeticIODict:
+    def inputs(self) -> Sequence[RegisterUserInput]:
         return _ports_to_registers(self.port_declarations, PortDirection.Input)
 
     @property
-    def outputs(self) -> ArithmeticIODict:
+    def outputs(self) -> Sequence[RegisterUserInput]:
         return _ports_to_registers(self.port_declarations, PortDirection.Output)
 
-    def update_logic_flow(
-        self, function_dict: Mapping[str, "QuantumFunctionDeclaration"]
-    ) -> None:
-        pass
-
     @property
-    def port_names(self) -> List[str]:
-        return list(self.port_declarations.keys())
+    def port_names(self) -> Sequence[str]:
+        return [port.get_name() for port in self.port_declarations]
 
     @property
-    def operand_names(self) -> List[str]:
-        return list(self.operand_declarations.keys())
+    def operand_names(self) -> Sequence[str]:
+        return [operand.get_name() for operand in self.operand_declarations]
 
     def ports_by_direction(
         self, direction: PortDirection
-    ) -> Mapping[str, PortDeclaration]:
-        return {
-            name: port
-            for name, port in self.port_declarations.items()
+    ) -> Sequence[AnonPortDeclaration]:
+        return [
+            port
+            for port in self.port_declarations
             if port.direction.includes_port_direction(direction)
-        }
+        ]
 
     def ports_by_declaration_direction(
         self, direction: PortDeclarationDirection
-    ) -> Set[str]:
+    ) -> set[str]:
         return {
-            name
-            for name, port in self.port_declarations.items()
+            port.get_name()
+            for port in self.port_declarations
             if port.direction == direction
         }
 
-    def get_positional_arg_decls(self) -> List[PositionalArg]:
-        result: List[PositionalArg] = self.positional_arg_declarations
-        if not result:
-            result = [
-                ClassicalParameterDeclaration(name=name, classical_type=ctype)
-                for name, ctype in self.param_decls.items()
-            ]
-            result.extend(self.operand_declarations.values())
-            result.extend(self.port_declarations.values())
-        return result
-
-    @pydantic.validator("operand_declarations")
-    def _validate_operand_declarations_names(
-        cls, operand_declarations: Dict[str, "QuantumOperandDeclaration"]
-    ) -> Dict[str, "QuantumOperandDeclaration"]:
-        validate_nameables_mapping(operand_declarations, "Operand")
-        return operand_declarations
-
-    @pydantic.validator("port_declarations")
-    def _validate_port_declarations_names(
-        cls, port_declarations: Dict[str, PortDeclaration]
-    ) -> Dict[str, PortDeclaration]:
-        validate_nameables_mapping(port_declarations, "Port")
-        return port_declarations
-
-    @pydantic.root_validator()
-    def _validate_params_and_operands_uniqueness(
-        cls, values: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        operand_declarations = values.get("operand_declarations")
-        parameter_declarations = values.get("param_decls")
-        port_declarations = values.get("port_declarations")
-        operand_parameter = validate_nameables_no_overlap(
-            operand_declarations, parameter_declarations, "operand", "parameter"
-        )
-        operand_port = validate_nameables_no_overlap(
-            operand_declarations, port_declarations, "operand", "port"
-        )
-        parameter_port = validate_nameables_no_overlap(
-            parameter_declarations, port_declarations, "parameter", "port"
-        )
-        error_message = ",".join(
-            msg
-            for msg in [operand_parameter, operand_port, parameter_port]
-            if msg is not None
+    def rename(self, new_name: str) -> "QuantumFunctionDeclaration":
+        if type(self) not in (
+            AnonQuantumFunctionDeclaration,
+            QuantumFunctionDeclaration,
+            NamedParamsQuantumFunctionDeclaration,
+        ):
+            raise ClassiqInternalError
+        return QuantumFunctionDeclaration(
+            **{
+                **{
+                    field_name: field_value
+                    for field_name, field_value in self.__dict__.items()
+                    if field_name in AnonQuantumFunctionDeclaration.model_fields
+                },
+                "name": new_name,
+            }
         )
 
-        if error_message:
-            raise ClassiqValueError(error_message)
 
-        return values
+class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
+    kind: Literal["QuantumOperandDeclaration"]
+
+    is_list: bool = pydantic.Field(
+        description="Indicate whether the operand expects an unnamed list of lambdas",
+        default=False,
+    )
 
-    @pydantic.root_validator()
-    def _reduce_positional_declarations_to_keyword(
-        cls, values: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        operand_declarations = values.get("operand_declarations", dict())
-        parameter_declarations = values.get("param_decls", dict())
-        port_declarations = values.get("port_declarations", dict())
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
+        return values_with_discriminator(values, "kind", "QuantumOperandDeclaration")
 
-        positional_arg_declarations = values.get("positional_arg_declarations", list())
+    def rename(self, new_name: str) -> "QuantumOperandDeclaration":
+        if type(self) not in (AnonQuantumOperandDeclaration, QuantumOperandDeclaration):
+            raise ClassiqInternalError
+        new_instance_data = self.__dict__.copy()
+        new_instance_data["name"] = new_name
+        new_instance_data["kind"] = "QuantumOperandDeclaration"
+        return QuantumOperandDeclaration(**new_instance_data)
 
-        _populate_declaration_dicts_with_positional_lists(
-            positional_arg_declarations,
-            parameter_declarations,
-            ClassicalParameterDeclaration,
-        )
-        _populate_declaration_dicts_with_positional_lists(
-            positional_arg_declarations,
-            operand_declarations,
-            QuantumOperandDeclaration,
-        )
-        _populate_declaration_dicts_with_positional_lists(
-            positional_arg_declarations, port_declarations, PortDeclaration
-        )
+    @property
+    def element_declaration(self) -> Self:
+        if not self.is_list:
+            raise ClassiqInternalError
+        return self.model_copy(update={"is_list": False})
 
-        values["operand_declarations"] = operand_declarations
-        values["param_decls"] = parameter_declarations
-        values["port_declarations"] = port_declarations
 
+AnonQuantumFunctionDeclaration.model_rebuild()
+
+
+class QuantumFunctionDeclaration(AnonQuantumFunctionDeclaration):
+    name: str
+
+
+class QuantumOperandDeclaration(
+    AnonQuantumOperandDeclaration, QuantumFunctionDeclaration
+):
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_none(cls, values: Any, info: ValidationInfo) -> dict[str, Any]:
         return values
 
 
-class QuantumOperandDeclaration(QuantumFunctionDeclaration):
-    is_list: bool = pydantic.Field(
-        description="Indicate whether the operand expects an unnamed list of lambdas",
-        default=False,
+PositionalArg = Annotated[
+    SerializeAsAny[
+        Union[
+            ClassicalParameterDeclaration,
+            QuantumOperandDeclaration,
+            PortDeclaration,
+        ]
+    ],
+    pydantic.Field(..., discriminator="kind"),
+]
+
+
+class NamedParamsQuantumFunctionDeclaration(QuantumFunctionDeclaration):
+
+    positional_arg_declarations: Sequence[PositionalArg] = pydantic.Field(
+        default_factory=list
     )
 
+    @property
+    def port_declarations_dict(self) -> dict[str, PortDeclaration]:
+        return {port.name: port for port in self.port_declarations}
+
+    @property
+    def operand_declarations_dict(self) -> dict[str, QuantumOperandDeclaration]:
+        return {op.name: op for op in self.operand_declarations}
+
+    @property
+    def param_decls_dict(self) -> dict[str, ClassicalParameterDeclaration]:
+        return {param.name: param for param in self.param_decls}
+
+    @property
+    def inputs_dict(self) -> ArithmeticIODict:
+        return _ports_to_registers_dict(self.port_declarations, PortDirection.Input)
+
+    @property
+    def inouts_dict(self) -> ArithmeticIODict:
+        return _ports_to_registers_dict(self.port_declarations, PortDirection.Inout)
+
+    @property
+    def outputs_dict(self) -> ArithmeticIODict:
+        return _ports_to_registers_dict(self.port_declarations, PortDirection.Output)
+
+    @property
+    def port_declarations(self) -> Sequence[PortDeclaration]:
+        return super().port_declarations  # type:ignore[return-value]
 
-QuantumFunctionDeclaration.update_forward_refs()
+    @property
+    def operand_declarations(self) -> Sequence[QuantumOperandDeclaration]:
+        return super().operand_declarations  # type:ignore[return-value]
+
+    @property
+    def param_decls(self) -> Sequence[ClassicalParameterDeclaration]:
+        return super().param_decls  # type:ignore[return-value]
+
+
+def _ports_to_registers_dict(
+    port_declarations: Sequence[PortDeclaration], direction: PortDirection
+) -> ArithmeticIODict:
+    return {
+        port_decl.name: quantum_var_to_register(port_decl.name, port_decl.quantum_type)
+        for port_decl in port_declarations
+        if port_decl.direction.includes_port_direction(direction)
+    }

classiq/interface/model/quantum_lambda_function.py

@@ -1,64 +1,65 @@
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Callable, Optional, Union
 
 import pydantic
-from pydantic import BaseModel
 
+from classiq.interface.ast_node import ASTNode
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumOperandDeclaration,
+    AnonQuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIfOperation
 
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
-from classiq.interface.model.within_apply_operation import WithinApplyOperation
 
-
-class QuantumLambdaFunction(BaseModel):
+class QuantumLambdaFunction(ASTNode):
     """
     The definition of an anonymous function passed as operand to higher-level functions
     """
 
-    rename_params: Dict[str, str] = pydantic.Field(
-        default_factory=dict,
-        description="Mapping of the declared param to the actual variable name used ",
+    pos_rename_params: list[str] = pydantic.Field(
+        default_factory=list,
+        description="Mapping of the declared param to the actual variable name used",
     )
 
     body: "StatementBlock" = pydantic.Field(
         description="A list of function calls passed to the operator"
     )
 
-    _func_decl: Optional[QuantumOperandDeclaration] = pydantic.PrivateAttr(default=None)
+    _func_decl: Optional[AnonQuantumOperandDeclaration] = pydantic.PrivateAttr(
+        default=None
+    )
+
+    _py_callable: Callable = pydantic.PrivateAttr(default=None)
 
     @property
-    def func_decl(self) -> Optional[QuantumOperandDeclaration]:
-        return self._func_decl
+    def py_callable(self) -> Callable:
+        return self._py_callable
 
-    def set_op_decl(self, fd: QuantumOperandDeclaration) -> None:
-        self._func_decl = fd
+    def is_generative(self) -> bool:
+        return self.py_callable is not None
 
+    def set_py_callable(self, py_callable: Callable) -> None:
+        self._py_callable = py_callable
 
-class LambdaListComprehension(BaseModel):
-    """
-    Specification of a list of lambda functions iteratively
-    """
+    @property
+    def func_decl(self) -> AnonQuantumOperandDeclaration:
+        if self._func_decl is None:
+            raise ClassiqError("Could not resolve lambda signature.")
+        return self._func_decl
 
-    count: Expression = pydantic.Field(
-        description="The number of lambda functions in the list"
-    )
+    def set_op_decl(self, fd: AnonQuantumOperandDeclaration) -> None:
+        self._func_decl = fd
 
-    index_var: str = pydantic.Field(
-        description="The name of the integer variable holding the iteration index"
-    )
 
-    func: QuantumLambdaFunction = pydantic.Field(
-        description="A lambda function definition replicated for index values 0 to count-1"
-    )
+class OperandIdentifier(ASTNode):
+    name: str
+    index: Expression
 
+    def __str__(self) -> str:
+        return f"{self.name}[{self.index.expr}]"
 
-QuantumCallable = Union[str, QuantumLambdaFunction]
-QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]
 
-QuantumIfOperation.update_forward_refs(QuantumOperand=QuantumOperand)
-WithinApplyOperation.update_forward_refs(QuantumOperand=QuantumOperand)
+QuantumCallable = Union[str, OperandIdentifier, QuantumLambdaFunction]
+QuantumOperand = Union[QuantumCallable, list[QuantumCallable]]

classiq/interface/model/quantum_statement.py

@@ -1,32 +1,91 @@
-from typing import Mapping, Union
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+from uuid import UUID, uuid4
 
-from pydantic import BaseModel, Extra
+import pydantic
+from pydantic import ConfigDict
 
+from classiq.interface.ast_node import ASTNode
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
     HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
 )
 
 
-class QuantumStatement(BaseModel):
-    class Config:
-        extra = Extra.forbid
+class QuantumStatement(ASTNode):
+    kind: str
+    model_config = ConfigDict(extra="forbid")
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
+        return values_with_discriminator(values, "kind", cls.__name__)
+
+
+@dataclass
+class HandleMetadata:
+    handle: HandleBinding
+    readable_location: Optional[str] = None
 
 
 class QuantumOperation(QuantumStatement):
+    uuid: UUID = pydantic.Field(
+        description="A unique identifier for this operation", default_factory=uuid4
+    )
+    _generative_blocks: dict[str, Callable] = pydantic.PrivateAttr(default_factory=dict)
+
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
         return dict()
 
     @property
-    def wiring_inouts(
-        self,
-    ) -> Mapping[
-        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-    ]:
+    def inputs(self) -> Sequence[HandleBinding]:
+        return list(self.wiring_inputs.values())
+
+    @property
+    def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
         return dict()
 
+    @property
+    def inouts(self) -> Sequence[HandleBinding]:
+        return list(self.wiring_inouts.values())
+
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return dict()
+
+    @property
+    def outputs(self) -> Sequence[HandleBinding]:
+        return list(self.wiring_outputs.values())
+
+    @property
+    def readable_inputs(self) -> Sequence[HandleMetadata]:
+        return [HandleMetadata(handle=handle) for handle in self.inputs]
+
+    @property
+    def readable_inouts(self) -> Sequence[HandleMetadata]:
+        return [HandleMetadata(handle=handle) for handle in self.inouts]
+
+    @property
+    def readable_outputs(self) -> Sequence[HandleMetadata]:
+        return [HandleMetadata(handle=handle) for handle in self.outputs]
+
+    def set_generative_block(self, block_name: str, py_callable: Callable) -> None:
+        self._generative_blocks[block_name] = py_callable
+
+    def remove_generative_block(self, block_name: str) -> None:
+        self._generative_blocks.pop(block_name)
+
+    def get_generative_block(self, block_name: str) -> Callable:
+        return self._generative_blocks[block_name]
+
+    def has_generative_block(self, block_name: str) -> bool:
+        return block_name in self._generative_blocks
+
+    def is_generative(self) -> bool:
+        return len(self._generative_blocks) > 0
+
+    def clear_generative_blocks(self) -> None:
+        self._generative_blocks.clear()