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

classiq/interface/generator/model/__init__.py

@@ -1,20 +1,17 @@
-from typing import List
-
 from classiq.interface.generator.model.constraints import (
     Constraints,
     OptimizationParameter,
     TranspilerBasisGates,
 )
-from classiq.interface.generator.model.model import SynthesisModel
 from classiq.interface.generator.model.preferences import (
     CustomHardwareSettings,
     Preferences,
 )
 
-__all__: List[str] = [
+__all__: list[str] = [
     "Constraints",
-    "Preferences",
     "CustomHardwareSettings",
     "OptimizationParameter",
+    "Preferences",
     "TranspilerBasisGates",
 ]

classiq/interface/generator/model/constraints.py

@@ -1,14 +1,13 @@
 from collections import defaultdict
-from typing import Dict, Optional, Union
+from typing import Optional, Union
 
 import pydantic
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, ConfigDict
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.transpiler_basis_gates import TranspilerBasisGates
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 UNCONSTRAINED = -1
 
 
@@ -30,18 +29,37 @@ def optimization_parameter_type_from_string(param: str) -> OptimizationParameter
     raise ClassiqValueError(f"Invalid OptimizationParameterType {param}")
 
 
-class Constraints(BaseModel, extra=Extra.forbid):
+class Constraints(BaseModel):
     """
-    Input constraints for the generated quantum circuit.
+    Constraints for the quantum circuit synthesis engine.
+
+    This class is used to specify constraints such as maximum width, depth,
+    gate count, and optimization parameters for the synthesis engine,
+    guiding the generation of quantum circuits that satisfy these constraints.
+
+    Attributes:
+        max_width (int):
+            Maximum number of qubits allowed in the generated quantum circuit.
+            Defaults to `None`.
+        max_depth (int):
+            Maximum depth of the generated quantum circuit. Defaults to `None`.
+        max_gate_count (Dict[TranspilerBasisGates, int]):
+            A dictionary specifying the maximum allowed count for each type of gate
+            in the quantum circuit. Defaults to an empty dictionary.
+        optimization_parameter (OptimizationParameterType):
+            Determines if and how the synthesis engine should optimize
+            the solution. Defaults to `NO_OPTIMIZATION`. See `OptimizationParameterType`
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     max_width: Optional[pydantic.PositiveInt] = pydantic.Field(
         default=None,
         description="Maximum number of qubits in generated quantum circuit",
     )
     max_depth: Optional[pydantic.PositiveInt] = None
 
-    max_gate_count: Dict[TranspilerBasisGates, pydantic.NonNegativeInt] = (
+    max_gate_count: dict[TranspilerBasisGates, pydantic.NonNegativeInt] = (
         pydantic.Field(default_factory=lambda: defaultdict(int))
     )
 

classiq/interface/generator/model/model.py

@@ -1,71 +1,44 @@
 from abc import ABC
-from typing import Any, Dict, List, Literal, Mapping, NewType, Optional, Union
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.function_params import ArithmeticIODict, IOName
-from classiq.interface.generator.functions import (
-    SynthesisNativeFunctionDefinition,
-    SynthesisPortDeclaration,
-    SynthesisQuantumFunctionDeclaration,
-)
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-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,
-    SynthesisQuantumFunctionCall,
-    WireDict,
-    WireName,
-)
+from classiq.interface.generator.function_params import ArithmeticIODict
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.helpers.validation_helpers import is_list_unique
 from classiq.interface.helpers.versioned_model import VersionedModel
-
-from classiq import ForeignFunctionDefinition as SynthesisForeignFunctionDefinition
-from classiq.exceptions import ClassiqValueError
-from classiq.quantum_register import QReg, QRegGenericAlias
-
-MAIN_FUNCTION_NAME = "main"
-CLASSICAL_ENTRY_FUNCTION_NAME = "cmain"
-
-DEFAULT_PORT_SIZE = 1
-
-
-SerializedModel = NewType("SerializedModel", str)
-
-# We need to define ConcreteFunctionData so pydantic will know
-# what class to use when deserializing from object (pydantic attempts to
-# parse as each of the classes in the Union, in order).
-ConcreteFunctionDefinition = Union[
-    SynthesisForeignFunctionDefinition, SynthesisNativeFunctionDefinition
-]
+from classiq.interface.model.quantum_type import RegisterQuantumTypeDict
 
 TYPE_LIBRARY_DUPLICATED_TYPE_NAMES = (
     "Cannot have multiple struct types with the same name"
 )
 
 
-def _create_default_functions() -> List[ConcreteFunctionDefinition]:
-    return [SynthesisNativeFunctionDefinition(name=MAIN_FUNCTION_NAME)]
-
-
 class ClassiqBaseModel(VersionedModel, ABC):
     """
     All the relevant data for evaluating execution in one place.
     """
 
-    types: List[StructDeclaration] = pydantic.Field(
+    enums: list[EnumDeclaration] = pydantic.Field(
         default_factory=list,
-        description="The user-defined custom function library.",
+        description="user-defined enums",
     )
 
-    constants: List[Constant] = pydantic.Field(
+    types: list[StructDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined structs",
+    )
+
+    qstructs: list[QStructDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined quantum structs",
+    )
+
+    constants: list[Constant] = pydantic.Field(
         default_factory=list,
     )
 
@@ -77,8 +50,9 @@ class ClassiqBaseModel(VersionedModel, ABC):
         default_factory=ExecutionPreferences
     )
 
-    @pydantic.validator("types")
-    def types_validator(cls, types: List[StructDeclaration]) -> List[StructDeclaration]:
+    @pydantic.field_validator("types")
+    @classmethod
+    def types_validator(cls, types: list[StructDeclaration]) -> list[StructDeclaration]:
         if not is_list_unique([struct_type.name for struct_type in types]):
             raise ClassiqValueError(TYPE_LIBRARY_DUPLICATED_TYPE_NAMES)
 
@@ -90,147 +64,10 @@ class ExecutionModel(ClassiqBaseModel):
         description="Mapping between a measured register name and its arithmetic type",
         default_factory=dict,
     )
-
-
-class SynthesisModel(ClassiqBaseModel):
-    """
-    All the relevant data for generating quantum circuit in one place.
-    """
-
-    kind: Literal["synthesis"] = pydantic.Field(default="synthesis")
-
-    # Must be validated before logic_flow
-    functions: List[ConcreteFunctionDefinition] = pydantic.Field(
-        default_factory=_create_default_functions,
-        description="The quantum functions of the model.",
+    circuit_output_types: RegisterQuantumTypeDict = pydantic.Field(
+        description="Mapping between a measured register name and its qmod type",
+        default=dict(),
+    )
+    register_filter_bitstrings: dict[str, list[str]] = pydantic.Field(
+        default_factory=dict,
     )
-
-    constraints: Constraints = pydantic.Field(default_factory=Constraints)
-    preferences: Preferences = pydantic.Field(default_factory=Preferences)
-
-    def __init__(
-        self,
-        *,
-        body: Optional[List[SynthesisQuantumFunctionCall]] = None,
-        inputs: Optional[WireDict] = None,
-        outputs: Optional[WireDict] = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(**kwargs)
-        if body:
-            self.main_func.body.extend(body)
-        if inputs:
-            self.set_inputs(
-                {
-                    name: QRegGenericAlias(
-                        QReg(DEFAULT_PORT_SIZE), (DEFAULT_PORT_SIZE, 0)
-                    )
-                    for name in inputs.keys()
-                },
-                inputs,
-            )
-        if outputs:
-            self.set_outputs(
-                {name: QReg(DEFAULT_PORT_SIZE) for name in outputs.keys()}, outputs
-            )
-
-    @property
-    def main_func(self) -> SynthesisNativeFunctionDefinition:
-        return self.function_dict[MAIN_FUNCTION_NAME]  # type:ignore[return-value]
-
-    @property
-    def body(self) -> List[SynthesisQuantumFunctionCall]:
-        return self.main_func.body
-
-    @property
-    def inputs(self) -> WireDict:
-        return self.main_func.input_ports_wiring
-
-    def set_inputs(
-        self,
-        inputs: Mapping[IOName, QRegGenericAlias],
-        input_wiring: Mapping[IOName, WireName],
-    ) -> None:
-        self._update_main_declarations(inputs, PortDeclarationDirection.Input)
-        self.main_func.input_ports_wiring.update(input_wiring)
-
-    @property
-    def outputs(self) -> WireDict:
-        return self.main_func.output_ports_wiring
-
-    def set_outputs(
-        self, outputs: Mapping[IOName, QReg], output_wiring: Mapping[IOName, WireName]
-    ) -> None:
-        self._update_main_declarations(outputs, PortDeclarationDirection.Output)
-        self.main_func.output_ports_wiring.update(output_wiring)
-
-    @pydantic.validator("preferences", always=True)
-    def _seed_suffix_randomizer(cls, preferences: Preferences) -> Preferences:
-        SUFFIX_RANDOMIZER.seed(preferences.random_seed)
-        return preferences
-
-    def _get_qualified_direction(
-        self, port_name: str, direction: PortDeclarationDirection
-    ) -> PortDeclarationDirection:
-        if port_name in self.main_func.port_declarations:
-            return PortDeclarationDirection.Inout
-        return direction
-
-    def _update_main_declarations(
-        self,
-        value: Union[Mapping[IOName, QReg], Mapping[IOName, QRegGenericAlias]],
-        direction: PortDeclarationDirection,
-    ) -> None:
-        for port_name, register in value.items():
-            if isinstance(register, QReg):
-                size = len(register)
-                is_signed = getattr(register, "is_signed", False) or False
-                fraction_places = getattr(register, "fraction_places", 0) or 0
-            else:
-                size = register.size if register.size is not None else DEFAULT_PORT_SIZE
-                is_signed = False
-                fraction_places = (
-                    register.fraction_places
-                    if register.fraction_places is not None
-                    else 0
-                )
-
-            self.main_func.port_declarations[port_name] = SynthesisPortDeclaration(
-                name=port_name,
-                size=size,
-                direction=self._get_qualified_direction(port_name, direction),
-                is_signed=is_signed,
-                fraction_places=fraction_places,
-            )
-
-    @property
-    def function_dict(self) -> Dict[str, SynthesisQuantumFunctionDeclaration]:
-        return nameables_to_dict(self.functions)
-
-    @pydantic.validator("functions", each_item=True)
-    def validate_static_correctness(
-        cls, func_def: ConcreteFunctionDefinition
-    ) -> ConcreteFunctionDefinition:
-        if isinstance(func_def, SynthesisNativeFunctionDefinition):
-            func_def.validate_body()
-        return func_def
-
-    @pydantic.validator("functions")
-    def validate_main_function_exists(
-        cls, func_defs: List[ConcreteFunctionDefinition]
-    ) -> List[ConcreteFunctionDefinition]:
-        if MAIN_FUNCTION_NAME not in {func.name for func in func_defs}:
-            raise ClassiqValueError("The model must contain a `main` function")
-        return func_defs
-
-    def get_model(self) -> SerializedModel:
-        return SerializedModel(self.json(exclude_defaults=True, indent=2))
-
-    def classical_model(self) -> ExecutionModel:
-        return ExecutionModel(
-            types=self.types,
-            constants=self.constants,
-            classical_execution_code=self.classical_execution_code,
-            execution_preferences=self.execution_preferences,
-            circuit_outputs=self.main_func.outputs,
-        )

classiq/interface/generator/model/preferences/preferences.py

@@ -1,17 +1,24 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from collections.abc import Sequence
+from enum import IntEnum
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union
 
 import pydantic
-from typing_extensions import TypeAlias
+from pydantic import Field
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self, TypeAlias
 
 from classiq.interface.backend.backend_preferences import (
     BackendPreferences,
-    validate_backend_service_provider,
 )
 from classiq.interface.backend.quantum_backend_providers import (
     AllBackendsNameByVendor,
     ProviderVendor,
 )
-from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.arith.machine_precision import (
+    DEFAULT_MACHINE_PRECISION,
+)
 from classiq.interface.generator.hardware.hardware_data import (
     BACKEND_VALIDATION_ERROR_MESSAGE,
     CustomHardwareSettings,
@@ -20,20 +27,17 @@ from classiq.interface.generator.model.preferences.randomness import create_rand
 from classiq.interface.hardware import Provider
 from classiq.interface.helpers.custom_pydantic_types import PydanticMachinePrecision
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 if TYPE_CHECKING:
     VisualizationLevel: TypeAlias = Optional[int]
 else:
-    VisualizationLevel: TypeAlias = Optional[pydantic.conint(ge=-1)]
+    VisualizationLevel: TypeAlias = Optional[Annotated[int, Field(ge=-1)]]
 
 if TYPE_CHECKING:
     PydanticBackendName = str
 else:
-    PydanticBackendName = pydantic.constr(
-        strict=True, min_length=1, regex="^([.A-Za-z0-9_-]*)$"
-    )
+    PydanticBackendName = Annotated[
+        str, Field(strict=True, min_length=1, pattern="^([.A-Za-z0-9_-]*)$")
+    ]
 
 
 class QuantumFormat(StrEnum):
@@ -45,7 +49,7 @@ class QuantumFormat(StrEnum):
     QASM_CIRQ_COMPATIBLE = "qasm_cirq_compatible"
 
 
-_SERVICE_PROVIDER_TO_FORMAT: Dict[Provider, QuantumFormat] = {
+_SERVICE_PROVIDER_TO_FORMAT: dict[Provider, QuantumFormat] = {
     Provider.CLASSIQ: QuantumFormat.QASM,
     Provider.IONQ: QuantumFormat.IONQ,
     Provider.AZURE_QUANTUM: QuantumFormat.QSHARP,
@@ -54,11 +58,18 @@ _SERVICE_PROVIDER_TO_FORMAT: Dict[Provider, QuantumFormat] = {
 }
 
 if TYPE_CHECKING:
-    PydanticConstrainedQuantumFormatList = List[QuantumFormat]
+    PydanticConstrainedQuantumFormatList = list[QuantumFormat]
 else:
-    PydanticConstrainedQuantumFormatList = pydantic.conlist(
-        QuantumFormat, min_items=1, max_items=len(QuantumFormat)
-    )
+    PydanticConstrainedQuantumFormatList = Annotated[
+        list[QuantumFormat], Field(min_length=1, max_length=len(QuantumFormat))
+    ]
+
+
+class OptimizationLevel(IntEnum):
+    NONE = 0
+    LIGHT = 1
+    MEDIUM = 2
+    HIGH = 3
 
 
 class TranspilationOption(StrEnum):
@@ -74,11 +85,60 @@ class TranspilationOption(StrEnum):
         return self != TranspilationOption.NONE
 
 
-class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
+class Preferences(pydantic.BaseModel, extra="forbid"):
+    """
+    Preferences for synthesizing a quantum circuit.
+
+    Attributes:
+        machine_precision (int): Specifies the precision used for quantum operations.
+            Defaults to `DEFAULT_MACHINE_PRECISION`.
+        backend_service_provider (str): The provider company or cloud service for the
+            requested backend. Defaults to `None`.
+        backend_name (str): The name of the requested backend or target. Defaults to `None`.
+        custom_hardware_settings (CustomHardwareSettings): Defines custom hardware
+            settings for optimization. This field is ignored if backend preferences are
+            specified.
+        debug_mode (bool): If `True`, debug information is added to the
+            synthesized result, potentially slowing down the synthesis. Useful for
+            executing interactive algorithms. Defaults to `True`.
+        output_format (List[QuantumFormat]): Lists the output format(s)
+            for the quantum circuit. Defaults to `[QuantumFormat.QASM]`.
+            `QuantumFormat` Options:
+                - QASM = "qasm"
+                - QSHARP = "qsharp"
+                - QIR = "qir"
+                - IONQ = "ionq"
+                - CIRQ_JSON = "cirq_json"
+                - QASM_CIRQ_COMPATIBLE = "qasm_cirq_compatible"
+        pretty_qasm (bool): If `True`, formats OpenQASM 2 outputs with line breaks
+            inside gate declarations, improving readability. Defaults to `True`.
+        qasm3 (Optional[bool]): If `True`, outputs OpenQASM 3.0 in addition to 2.0,
+            applicable to relevant attributes in `GeneratedCircuit`. Defaults to `None`.
+        transpilation_option (TranspilationOption): Sets the transpilation option to
+            optimize the circuit. Defaults to `AUTO_OPTIMIZE`. See `TranspilationOption`
+        solovay_kitaev_max_iterations (Optional[int]): Specifies the
+            maximum number of iterations for the Solovay-Kitaev algorithm, if used.
+            Defaults to `None`.
+        timeout_seconds (int): Timeout setting for circuit synthesis
+            in seconds. Defaults to `300`.
+        optimization_timeout_seconds (Optional[int]): Specifies the
+            timeout for optimization in seconds, or `None` for no optimization timeout.
+            This will still adhere to the overall synthesis timeout. Defaults to `None`.
+        random_seed (int): Random seed for circuit synthesis.
+
+    Raises:
+        ClassiqValueError:
+            - If the optimization timeout is greater than or equal to the synthesis timeout.
+            - If the `output_format` contains duplicate entries.
+            - If `backend_name` is provided without `backend_service_provider` or vice versa.
+        ValueError:
+            - If `backend_service_provider` is not valid.
+    """
+
     _backend_preferences: Optional[BackendPreferences] = pydantic.PrivateAttr(
         default=None
     )
-    machine_precision: PydanticMachinePrecision = MAXIMAL_MACHINE_PRECISION
+    machine_precision: PydanticMachinePrecision = DEFAULT_MACHINE_PRECISION
 
     backend_service_provider: Optional[Union[Provider, ProviderVendor, str]] = (
         pydantic.Field(
@@ -102,6 +162,15 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         "Setting this option to False can potentially speed up the synthesis, and is "
         "recommended for executing iterative algorithms.",
     )
+    synthesize_all_separately: bool = pydantic.Field(
+        default=False,
+        description="If true, a heuristic is used to determine if a function should be synthesized separately",
+        deprecated=True,
+    )
+    optimization_level: OptimizationLevel = pydantic.Field(
+        default=OptimizationLevel.HIGH,
+        description="The optimization level used during synthesis; determines the trade-off between synthesis speed and the quality of the results",
+    )
     output_format: PydanticConstrainedQuantumFormatList = pydantic.Field(
         default=[QuantumFormat.QASM],
         description="The quantum circuit output format(s). ",
@@ -125,6 +194,11 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         "transpiled circuit and its depth",
     )
 
+    solovay_kitaev_max_iterations: Optional[pydantic.PositiveInt] = pydantic.Field(
+        None,
+        description="Maximum iterations for the Solovay-Kitaev algorithm (if applied).",
+    )
+
     timeout_seconds: pydantic.PositiveInt = pydantic.Field(
         default=300, description="Generation timeout in seconds"
     )
@@ -134,27 +208,19 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         description="Optimization timeout in seconds, or None for no "
         "optimization timeout (will still timeout when the generation timeout is over)",
     )
-
     random_seed: int = pydantic.Field(
         default_factory=create_random_seed,
         description="The random seed used for the generation",
     )
 
-    @pydantic.validator("backend_service_provider", pre=True)
-    def validate_backend_service_provider(
-        cls, backend_service_provider: Any
-    ) -> Optional[Provider]:
-        if backend_service_provider is None:
-            return None
-        return validate_backend_service_provider(backend_service_provider)
-
-    @pydantic.validator("optimization_timeout_seconds")
+    @pydantic.field_validator("optimization_timeout_seconds", mode="before")
+    @classmethod
     def optimization_timeout_less_than_generation_timeout(
         cls,
         optimization_timeout_seconds: Optional[pydantic.PositiveInt],
-        values: Dict[str, Any],
+        info: ValidationInfo,
     ) -> Optional[pydantic.PositiveInt]:
-        generation_timeout_seconds = values.get("timeout_seconds")
+        generation_timeout_seconds = info.data.get("timeout_seconds")
         if generation_timeout_seconds is None or optimization_timeout_seconds is None:
             return optimization_timeout_seconds
         if optimization_timeout_seconds >= generation_timeout_seconds:
@@ -165,16 +231,20 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
             )
         return optimization_timeout_seconds
 
-    @pydantic.validator("output_format", pre=True)
-    def make_output_format_list(cls, output_format: Any) -> List:
-        if not pydantic.utils.sequence_like(output_format):
+    @pydantic.field_validator("output_format", mode="before")
+    @classmethod
+    def make_output_format_list(cls, output_format: Any) -> list:
+        if not isinstance(output_format, Sequence) or isinstance(output_format, str):
             output_format = [output_format]
 
         return output_format
 
-    @pydantic.validator("output_format", always=True)
+    @pydantic.field_validator("output_format", mode="before")
+    @classmethod
     def validate_output_format(
-        cls, output_format: PydanticConstrainedQuantumFormatList, values: Dict[str, Any]
+        cls,
+        output_format: PydanticConstrainedQuantumFormatList,
+        info: ValidationInfo,
     ) -> PydanticConstrainedQuantumFormatList:
         if len(output_format) != len(set(output_format)):
             raise ClassiqValueError(
@@ -182,7 +252,7 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
                 "has at least one format that appears twice or more"
             )
 
-        service_provider = values.get("backend_service_provider")
+        service_provider = info.data.get("backend_service_provider")
         if service_provider is None:
             return output_format
 
@@ -192,16 +262,20 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
 
         return output_format
 
-    @pydantic.root_validator()
-    def validate_backend(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        backend_name = values.get("backend_name")
-        backend_service_provider = values.get("backend_service_provider")
+    @pydantic.model_validator(mode="after")
+    def validate_backend(self) -> Self:
+        backend_name = self.backend_name
+        backend_service_provider = self.backend_service_provider
         if (backend_name is None) != (backend_service_provider is None):
             raise ClassiqValueError(BACKEND_VALIDATION_ERROR_MESSAGE)
-        return values
+        return self
 
     @property
     def backend_preferences(self) -> Optional[BackendPreferences]:
+        """
+        Returns the backend preferences. If the backend preferences are not provided, the function sets the backend preferences according to backend name and provider.
+
+        """
         if self.backend_name is None or self.backend_service_provider is None:
             return None
         if self._backend_preferences is None: