classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/hardware.py

@@ -1,12 +1,27 @@
 import datetime
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, Annotated, Optional
 
 import pydantic
 
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
+
+QueueTime = Annotated[
+    Optional[datetime.timedelta],
+    pydantic.PlainSerializer(
+        lambda _timedelta: (
+            _timedelta.total_seconds() if _timedelta is not None else None
+        ),
+        return_type=Optional[float],
+    ),
+]
 
 
 class Provider(StrEnum):
+    """
+    This class defines all Providers that Classiq supports.
+    This is mainly used in backend_preferences when specifying where do we want to execute the defined model.
+    """
+
     IBM_QUANTUM = "IBM Quantum"
     AZURE_QUANTUM = "Azure Quantum"
     AMAZON_BRAKET = "Amazon Braket"
@@ -15,10 +30,13 @@ class Provider(StrEnum):
     GOOGLE = "Google"
     ALICE_AND_BOB = "Alice & Bob"
     OQC = "OQC"
+    INTEL = "Intel"
+    AQT = "AQT"
+    IQCC = "IQCC"
 
     @property
-    def id(self):
-        return self.value.replace(" ", "-").lower()
+    def id(self) -> "ProviderIDEnum":
+        return self.value.replace(" ", "-").lower()  # type: ignore[return-value]
 
 
 ProviderIDEnum = StrEnum("ProviderIDEnum", {p.id: p.id for p in Provider})  # type: ignore[misc]
@@ -48,14 +66,17 @@ class HardwareStatus(pydantic.BaseModel):
         default_factory=lambda: datetime.datetime.now(tz=datetime.UTC)
     )
     availability: AvailabilityStatus
-    queue_time: Optional[datetime.timedelta]
-    pending_jobs: Optional[int]
+    queue_time: QueueTime = pydantic.Field(
+        default=None,
+        description="The estimated queue time for the hardware in seconds.",
+    )
+    pending_jobs: Optional[int] = None
 
 
 if TYPE_CHECKING:
-    ConnectivityMapEntry = Tuple[int, int]
+    ConnectivityMapEntry = tuple[int, int]
 else:
-    ConnectivityMapEntry = List[int]
+    ConnectivityMapEntry = list[int]
 
 
 class HardwareInformation(pydantic.BaseModel):
@@ -65,8 +86,8 @@ class HardwareInformation(pydantic.BaseModel):
     display_name: str
     device_type: DeviceType
     number_of_qubits: int
-    connectivity_map: Optional[List[ConnectivityMapEntry]]
-    basis_gates: List[str]
+    connectivity_map: Optional[list[ConnectivityMapEntry]] = None
+    basis_gates: list[str]
     status: HardwareStatus
 
     def is_simulator(self) -> bool:

classiq/interface/helpers/classproperty.py

@@ -0,0 +1,8 @@
+from typing import TYPE_CHECKING, Any, Optional
+
+
+class classproperty(property):  # noqa: N801
+    def __get__(self, owner_self: Any, owner_cls: Optional[type] = None) -> Any:
+        if TYPE_CHECKING:
+            assert self.fget is not None
+        return self.fget(owner_cls)

classiq/interface/helpers/custom_encoders.py

@@ -0,0 +1,3 @@
+from typing import Any, Callable
+
+CUSTOM_ENCODERS: dict[type, Callable[[Any], Any]] = {complex: str}

classiq/interface/helpers/custom_pydantic_types.py

@@ -1,6 +1,7 @@
-from typing import TYPE_CHECKING, Any, List, Tuple
+from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic
+from pydantic import Field, StrictStr, StringConstraints
 
 from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
 from classiq.interface.generator.parameters import ParameterComplexType
@@ -13,13 +14,9 @@ if TYPE_CHECKING:
     PydanticLargerThanOneInteger = int
     PydanticMachinePrecision = int
 else:
+    PydanticLargerThanOneInteger = Annotated[int, Field(gt=1)]
 
-    class PydanticLargerThanOneInteger(pydantic.ConstrainedInt):
-        gt = 1
-
-    class PydanticMachinePrecision(pydantic.ConstrainedInt):
-        gt = 0
-        le = MAXIMAL_MACHINE_PRECISION
+    PydanticMachinePrecision = Annotated[int, Field(gt=0, le=MAXIMAL_MACHINE_PRECISION)]
 
 
 # Probability float types
@@ -28,93 +25,86 @@ if TYPE_CHECKING:
     PydanticNonOneProbabilityFloat = float
     PydanticNonZeroProbabilityFloat = float
 else:
+    PydanticProbabilityFloat = Annotated[float, Field(ge=0.0, le=1.0)]
 
-    class PydanticProbabilityFloat(pydantic.ConstrainedFloat):
-        ge = 0.0
-        le = 1.0
-
-    class PydanticNonOneProbabilityFloat(pydantic.ConstrainedFloat):
-        ge = 0.0
-        lt = 1.0
+    PydanticNonOneProbabilityFloat = Annotated[float, Field(ge=0.0, lt=1.0)]
 
-    class PydanticNonZeroProbabilityFloat(pydantic.ConstrainedFloat):
-        gt = 0.0
-        le = 1.0
+    PydanticNonZeroProbabilityFloat = Annotated[float, Field(gt=0.0, le=1.0)]
 
 
 # CVAR parameter types
 if TYPE_CHECKING:
     PydanticAlphaParamCVAR = float
 else:
-
-    class PydanticAlphaParamCVAR(pydantic.ConstrainedFloat):
-        gt = 0.0
-        le = 1.0
+    PydanticAlphaParamCVAR = Annotated[float, Field(gt=0.0, le=1.0)]
 
 
 # General string types
 if TYPE_CHECKING:
     PydanticNonEmptyString = str
 else:
-    PydanticNonEmptyString = pydantic.constr(min_length=1)
+    PydanticNonEmptyString = Annotated[str, Field(min_length=1)]
 
 # Name string types
 if TYPE_CHECKING:
     PydanticFunctionNameStr = str
 else:
-    PydanticFunctionNameStr = pydantic.constr(
-        strict=True, regex="^([A-Za-z][A-Za-z0-9_]*)$"
-    )
+    PydanticFunctionNameStr = Annotated[
+        str, Field(strict=True, pattern="^([A-Za-z][A-Za-z0-9_]*)$")
+    ]
 
 if TYPE_CHECKING:
     PydanticPauliMonomial = tuple
 else:
-    PydanticPauliMonomial = pydantic.conlist(item_type=Any, min_items=2, max_items=2)
+    PydanticPauliMonomial = Annotated[list[Any], Field(min_length=2, max_length=2)]
 
 if TYPE_CHECKING:
     PydanticPauliMonomialStr = str
 else:
-    PydanticPauliMonomialStr = pydantic.constr(
-        strict=True, strip_whitespace=True, min_length=1, regex="^[IXYZ]+$"
-    )
+    PydanticPauliMonomialStr = Annotated[
+        StrictStr,
+        StringConstraints(strip_whitespace=True, min_length=1, pattern="^[IXYZ]+$"),
+    ]
 
-if TYPE_CHECKING:
-    PydanticPauliList = List[Tuple[PydanticPauliMonomialStr, ParameterComplexType]]
-else:
-    PydanticPauliList = pydantic.conlist(item_type=tuple, min_items=1)
+PydanticPauliList = Annotated[
+    list[tuple[PydanticPauliMonomialStr, ParameterComplexType]], Field(min_length=1)
+]
 
 if TYPE_CHECKING:
-    PydanticFloatTuple = Tuple[float, float]
+    PydanticFloatTuple = tuple[float, float]
 else:
-    PydanticFloatTuple = pydantic.conlist(item_type=float, min_items=2, max_items=2)
+    PydanticFloatTuple = Annotated[list[float], Field(min_length=2, max_length=2)]
 
-if TYPE_CHECKING:
-    PydanticNonNegIntTuple = Tuple[pydantic.NonNegativeInt, pydantic.NonNegativeInt]
-else:
-    PydanticNonNegIntTuple = pydantic.conlist(
-        item_type=pydantic.NonNegativeInt, min_items=2, max_items=2
-    )
+PydanticNonNegIntTuple = Annotated[
+    list[pydantic.NonNegativeInt], Field(min_length=2, max_length=2)
+]
 
 if TYPE_CHECKING:
     PydanticExpressionStr = str
 else:
-    PydanticExpressionStr = pydantic.constr(
-        strip_whitespace=True, min_length=1, max_length=MAX_EXPRESSION_SIZE
-    )
+    PydanticExpressionStr = Annotated[
+        str,
+        StringConstraints(
+            strip_whitespace=True, min_length=1, max_length=MAX_EXPRESSION_SIZE
+        ),
+    ]
 if TYPE_CHECKING:
-    AtomType = Tuple[str, List[float]]
+    AtomType = tuple[str, list[float]]
 else:
-    AtomType = pydantic.conlist(item_type=Any, min_items=2, max_items=2)
+    AtomType = Annotated[list[Any], Field(min_length=2, max_length=2)]
 
 
 if TYPE_CHECKING:
     PydanticDataDogUuid = str
 else:
-    PydanticDataDogUuid = pydantic.constr(
-        regex=r"^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$"
-    )
+    PydanticDataDogUuid = Annotated[
+        str,
+        Field(
+            pattern=r"^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$"
+        ),
+    ]
 
 if TYPE_CHECKING:
     PydanticDataDogGo = int
 else:
-    PydanticDataDogGo = pydantic.conint(ge=0)
+    PydanticDataDogGo = Annotated[int, Field(ge=0)]

classiq/interface/helpers/datastructures.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+
+class DotDict(dict):
+    def __getattr__(self, key: str) -> Any:
+        return super().get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        super().__setitem__(key, value)
+
+    def __delattr__(self, key: str) -> None:
+        super().__delitem__(key)
+
+
+class LenList(list):
+    @property
+    def len(self) -> int:
+        return len(self)
+
+
+def get_sdk_compatible_python_object(obj: Any) -> Any:
+    if isinstance(obj, list):
+        return LenList([get_sdk_compatible_python_object(item) for item in obj])
+    if isinstance(obj, dict):
+        return DotDict({k: get_sdk_compatible_python_object(v) for k, v in obj.items()})
+    return obj

classiq/interface/helpers/hashable_mixin.py

@@ -1,7 +1,8 @@
 import itertools
 import numbers
+from collections.abc import Iterator
 from enum import EnumMeta
-from typing import Any, Iterator, Tuple
+from typing import Any
 
 
 def immutable_version(value: Any) -> Any:
@@ -29,5 +30,5 @@ class HashableMixin:
         for val in self._values_to_hash():
             yield immutable_version(val)
 
-    def _value_tuple(self) -> Tuple[Any, ...]:
+    def _value_tuple(self) -> tuple[Any, ...]:
         return tuple(itertools.chain((str(type(self))), self._immutable_fields()))

classiq/interface/helpers/hashable_pydantic_base_model.py

@@ -1,4 +1,5 @@
-from typing import Any, Collection, Iterator
+from collections.abc import Collection, Iterator
+from typing import Any
 
 import pydantic
 

classiq/interface/helpers/pydantic_model_helpers.py

@@ -1,16 +1,12 @@
-from typing import Any, Dict, Protocol, Sequence, TypeVar
-
-import pydantic
-
-
-def get_discriminator_field(default: str, **kwargs: Any) -> Any:
-    return pydantic.Field(default_factory=lambda: default, **kwargs)
+from collections.abc import Sequence
+from typing import Any, Protocol, TypeVar
 
 
 def values_with_discriminator(
-    values: Dict[str, Any], discriminator: str, discriminator_value: Any
-) -> Dict[str, Any]:
-    values.setdefault(discriminator, discriminator_value)
+    values: Any, discriminator: str, discriminator_value: Any
+) -> dict[str, Any]:
+    if isinstance(values, dict):
+        values.setdefault(discriminator, discriminator_value)
     return values
 
 
@@ -21,5 +17,5 @@ class Nameable(Protocol):
 NameableType = TypeVar("NameableType", bound=Nameable)
 
 
-def nameables_to_dict(nameables: Sequence[NameableType]) -> Dict[str, NameableType]:
+def nameables_to_dict(nameables: Sequence[NameableType]) -> dict[str, NameableType]:
     return {value.name: value for value in nameables}

classiq/interface/helpers/validation_helpers.py

@@ -1,34 +1,17 @@
-from typing import Hashable, List, Mapping, Optional
+from collections.abc import Hashable, Mapping
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.pydantic_model_helpers import Nameable
 
-from classiq.exceptions import ClassiqValueError
 
-
-def is_list_unique(lst: List[Hashable]) -> bool:
+def is_list_unique(lst: list[Hashable]) -> bool:
     return len(set(lst)) == len(lst)
 
 
 def validate_nameables_mapping(
     nameables_dict: Mapping[str, Nameable], declaration_type: str
 ) -> None:
-    if not all([name == nameable.name for (name, nameable) in nameables_dict.items()]):
+    if not all(name == nameable.name for (name, nameable) in nameables_dict.items()):
         raise ClassiqValueError(
             f"{declaration_type} declaration names should match the keys of their names."
         )
-
-
-def validate_nameables_no_overlap(
-    left_nameables_dict: Optional[Mapping[str, Nameable]],
-    right_nameables_dict: Optional[Mapping[str, Nameable]],
-    left_declaration_type: str,
-    right_declaration_type: str,
-) -> Optional[str]:
-    if left_nameables_dict is None or right_nameables_dict is None:
-        return None
-
-    matched_names = left_nameables_dict.keys() & right_nameables_dict.keys()
-    if matched_names:
-        return f"{left_declaration_type} declaration names overlap with {right_declaration_type} declaration names: {matched_names}"
-
-    return None

classiq/interface/helpers/versioned_model.py

@@ -3,5 +3,5 @@ import pydantic
 from classiq.interface._version import VERSION
 
 
-class VersionedModel(pydantic.BaseModel, extra=pydantic.Extra.forbid):
+class VersionedModel(pydantic.BaseModel):
     version: str = pydantic.Field(default=VERSION)

classiq/interface/ide/ide_data.py

@@ -1,20 +1,21 @@
 from enum import IntEnum
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 import pydantic
 
 from classiq.interface.generator.generated_circuit_data import GeneratedFunction
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.ide.visual_model import CircuitMetrics
 
-GateCount = Dict[str, int]
+GateCount = dict[str, int]
 Depth = int
 
 
 class IDEDataQubit(pydantic.BaseModel):
     id: int
-    numChildren: Optional[int]
-    name: Optional[str]
+    numChildren: Optional[int] = None
+    name: Optional[str] = None
 
 
 class IDEQubitDef(pydantic.BaseModel):
@@ -51,17 +52,17 @@ class ConditionalRender(IntEnum):
 class IDEDataOperation(pydantic.BaseModel):
     gate: str
     displayName: str
-    children: List["IDEDataOperation"]
+    children: list["IDEDataOperation"]
     depth: Depth
     width: int
     gate_count: GateCount
     _qubits: list = pydantic.PrivateAttr()  # list[Qubit]
 
     displayArgs: str = ""
-    targets: Union[List[IDEQubitDef], List[IDEClassicalBitDef]] = pydantic.Field(
+    targets: Union[list[IDEQubitDef], list[IDEClassicalBitDef]] = pydantic.Field(
         default_factory=list
     )
-    controls: List[IDEQubitDef] = list()
+    controls: list[IDEQubitDef] = list()
     dataAttributes: DataAttributes = pydantic.Field(default_factory=DataAttributes)
     isControlled: bool = False
     isMeasurement: bool = False
@@ -75,13 +76,13 @@ class IDEDataOperation(pydantic.BaseModel):
 
 
 class IDEDataProperties(pydantic.BaseModel):
-    color: Optional[str]
-    rightLabel: Optional[str]
-    leftLabel: Optional[str]
+    color: Optional[str] = None
+    rightLabel: Optional[str] = None
+    leftLabel: Optional[str] = None
 
 
 class RegisterData(pydantic.BaseModel):
-    segmentIds: List[str]
+    segmentIds: list[str]
     properties: IDEDataProperties
     registerId: str
 
@@ -91,16 +92,11 @@ class InterfaceSegmentData(pydantic.BaseModel):
     properties: IDEDataProperties
 
 
-class CircuitMetrics(pydantic.BaseModel):
-    depth: int
-    count_ops: Dict[str, int]
-
-
 class IDEData(VersionedModel):
-    qubits: List[IDEDataQubit]
-    operations: List[IDEDataOperation]
-    register_data: List[RegisterData]
-    segment_data: List[InterfaceSegmentData]
+    qubits: list[IDEDataQubit]
+    operations: list[IDEDataOperation]
+    register_data: list[RegisterData]
+    segment_data: list[InterfaceSegmentData]
     circuit_metrics: Optional[CircuitMetrics]
     hardware_data: SynthesisHardwareData
     creation_time: str

classiq/interface/ide/visual_model.py

@@ -0,0 +1,130 @@
+from collections import Counter
+from typing import Any, Optional
+
+import pydantic
+from pydantic import ConfigDict
+
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.generator.generated_circuit_data import (
+    OperationLevel,
+    OperationParameter,
+)
+from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+
+class OperationType(StrEnum):
+    REGULAR = "REGULAR"
+    ALLOCATE = "ALLOCATE"
+    FREE = "FREE"
+    BIND = "BIND"
+    ATOMIC = "ATOMIC"
+
+
+class OperationData(pydantic.BaseModel):
+    approximated_depth: Optional[int] = None
+    width: int
+    gate_count: Counter[str] = pydantic.Field(default_factory=dict)
+
+
+class CircuitMetrics(pydantic.BaseModel):
+    depth: int
+    count_ops: dict[str, int]
+
+
+class ProgramData(pydantic.BaseModel):
+    hardware_data: SynthesisHardwareData
+    circuit_metrics: CircuitMetrics
+
+
+class OperationLink(pydantic.BaseModel):
+    label: str
+    inner_label: Optional[str] = None
+    qubits: tuple[int, ...]
+    type: str
+    is_captured: bool = False
+
+    model_config = ConfigDict(frozen=True)
+
+    def __hash__(self) -> int:
+        return hash((type(self), self.label, self.qubits, self.type))
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, OperationLink):
+            return False
+        return hash(self) == hash(other)
+
+
+class OperationLinks(pydantic.BaseModel):
+    inputs: list[OperationLink]
+    outputs: list[OperationLink]
+
+    @property
+    def input_width(self) -> int:
+        return sum(len(link.qubits) for link in self.inputs)
+
+    @property
+    def output_width(self) -> int:
+        return sum(len(link.qubits) for link in self.outputs)
+
+
+class AtomicGate(StrEnum):
+    UNKNOWN = ""
+    H = "H"
+    X = "X"
+    Y = "Y"
+    Z = "Z"
+    I = "I"  # noqa: E741
+    S = "S"
+    T = "T"
+    SDG = "SDG"
+    TDG = "TDG"
+    PHASE = "PHASE"
+    RX = "RX"
+    RY = "RY"
+    RZ = "RZ"
+    R = "R"
+    RXX = "RXX"
+    RYY = "RYY"
+    RZZ = "RZZ"
+    CH = "CH"
+    CX = "CX"
+    CY = "CY"
+    CZ = "CZ"
+    CRX = "CRX"
+    CRY = "CRY"
+    CRZ = "CRZ"
+    CPHASE = "CPHASE"
+    SWAP = "SWAP"
+    IDENTITY = "IDENTITY"
+    U = "U"
+
+    @property
+    def is_control_gate(self) -> bool:
+        return self.startswith("C")
+
+
+class Operation(pydantic.BaseModel):
+    name: str
+    qasm_name: str = pydantic.Field(default="")
+    details: str = pydantic.Field(default="")
+    children: list["Operation"]
+    operation_data: Optional[OperationData] = None
+    operation_links: OperationLinks
+    control_qubits: tuple[int, ...] = pydantic.Field(default_factory=tuple)
+    auxiliary_qubits: tuple[int, ...]
+    target_qubits: tuple[int, ...]
+    parameters: list[OperationParameter] = pydantic.Field(default_factory=list)
+    operation_level: OperationLevel
+    operation_type: OperationType = pydantic.Field(
+        description="Identifies unique operations that are visualized differently"
+    )
+    gate: AtomicGate = pydantic.Field(
+        default=AtomicGate.UNKNOWN, description="Gate type"
+    )
+    is_daggered: bool = pydantic.Field(default=False)
+
+
+class ProgramVisualModel(VersionedModel):
+    main_operation: Operation
+    program_data: ProgramData

classiq/interface/interface_version.py

@@ -0,0 +1 @@
+INTERFACE_VERSION = "7"

classiq/interface/jobs.py

@@ -1,14 +1,17 @@
-from typing import Any, Dict, Generic, TypeVar, Union
+from typing import Any, Generic, Optional, TypeVar, Union
 
 import pydantic
 from pydantic import BaseModel
-from pydantic.generics import GenericModel
+from typing_extensions import Self
 
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqAPIError
+from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 
-JSONObject = Dict[str, Any]
+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):
@@ -29,6 +32,32 @@ class JobStatus(StrEnum):
         return self in (self.COMPLETED, self.FAILED, self.CANCELLED)
 
 
-class JobDescription(GenericModel, Generic[T]):
+"""
+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
+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
+"""
+
+
+class JobDescription(BaseModel, Generic[T], json_encoders=CUSTOM_ENCODERS):
     status: JobStatus
-    description: T
+    failure_details: Optional[str] = pydantic.Field(default=None)
+    result: Optional[T] = pydantic.Field(default=None)
+
+    @pydantic.model_validator(mode="after")
+    def validate_status_and_fields(self) -> Self:
+        if self.status is JobStatus.COMPLETED:
+            # Completed job must return result and not have an error
+            if self.result is None or self.failure_details is not None:
+                raise ClassiqAPIError(INVALID_RESPONSE_ERROR_MSG)
+        elif self.status in (JobStatus.FAILED, JobStatus.CANCELLED):
+            # Failed job must return error and not have result
+            if self.result is not None or self.failure_details is None:
+                raise ClassiqAPIError(INVALID_RESPONSE_ERROR_MSG)
+        elif self.result is not None or self.failure_details is not None:
+            # Pending job must have no result and no error
+            raise ClassiqAPIError(INVALID_RESPONSE_ERROR_MSG)
+
+        return self

classiq/interface/model/allocate.py

@@ -0,0 +1,16 @@
+from collections.abc import Mapping
+from typing import Literal, Optional
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+
+class Allocate(QuantumOperation):
+    kind: Literal["Allocate"]
+    size: Optional[Expression] = None
+    target: ConcreteHandleBinding
+
+    @property
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
+        return {"out": self.target}