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

classiq/applications/libraries/qmci_library.py

@@ -0,0 +1,35 @@
+from typing import cast
+
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+
+from classiq.qmod import (  # type:ignore[attr-defined]
+    QArray,
+    QBit,
+    QCallable,
+    QNum,
+    Z,
+    amplitude_estimation,
+    qfunc,
+)
+
+
+@qfunc
+def qmci(
+    space_transform: QCallable[QArray[QBit], QBit],
+    phase: QNum,
+    packed_vars: QArray[QBit],
+) -> None:
+    amplitude_estimation(
+        lambda reg: Z(reg[reg.len - 1]),
+        lambda reg: space_transform(reg[0 : reg.len - 1], reg[reg.len - 1]),
+        phase,
+        packed_vars,
+    )
+
+
+QMCI_LIBRARY = [
+    cast(
+        NativeFunctionDefinition,
+        qmci.create_model().function_dict["qmci"],
+    ),
+]

classiq/applications/qsvm/__init__.py

@@ -4,5 +4,9 @@ from classiq.interface.generator.expressions.enums.qsvm_feature_map_entanglement
 
 from ..qsvm import qsvm_data_generation
 from .qsvm import *  # noqa: F403
+from .qsvm_model_constructor import construct_qsvm_model
 
-__all__ = ["QSVMFeatureMapEntanglement"]
+__all__ = [
+    "QSVMFeatureMapEntanglement",
+    "construct_qsvm_model",
+]

classiq/execution/all_hardware_devices.py

@@ -0,0 +1,13 @@
+from typing import List
+
+from classiq.interface.hardware import HardwareInformation
+
+from classiq._internals import async_utils
+from classiq._internals.api_wrapper import ApiWrapper
+
+
+def get_all_hardware_devices() -> List[HardwareInformation]:
+    """
+    Returns a list of all hardware devices known to Classiq.
+    """
+    return async_utils.run(ApiWrapper.call_get_all_hardware_devices())

classiq/executor.py

@@ -29,9 +29,10 @@ from classiq.interface.generator.quantum_program import QuantumProgram
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
 from classiq.execution.jobs import ExecutionJob
-from classiq.model.model import DEFAULT_RESULT_NAME
 from classiq.synthesis import SerializedQuantumProgram
 
+DEFAULT_RESULT_NAME = "result"
+
 BatchExecutionResult: TypeAlias = Union[ExecutionDetails, BaseException]
 ProgramAndResult: TypeAlias = Tuple[QuantumCode, BatchExecutionResult]
 BackendPreferencesAndResult: TypeAlias = Tuple[

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.38.0'
+SEMVER_VERSION = '0.39.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/result.py

@@ -2,7 +2,7 @@ from typing import Dict, List, Literal, Optional, Set, Tuple, Union
 from uuid import UUID
 
 import pydantic
-from pydantic import AnyHttpUrl, Field
+from pydantic import Field
 from typing_extensions import Annotated
 
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
@@ -41,10 +41,6 @@ class QasmCode(pydantic.BaseModel):
     code: str
 
 
-class PreSignedS3Url(VersionedModel):
-    url: AnyHttpUrl
-
-
 class AnalysisStatus(StrEnum):
     NONE = "none"
     SUCCESS = "success"

classiq/interface/applications/qsvm.py

@@ -103,11 +103,13 @@ class QSVMData(VersionedModel):
         extra = "forbid"
 
     @pydantic.validator("data", pre=True)
-    def set_data(cls, data):
+    def set_data(cls, data: Union[IterableType, ArrayLike]) -> list:
         return listify(data)
 
     @pydantic.validator("labels", pre=True)
-    def set_labels(cls, labels):
+    def set_labels(
+        cls, labels: Optional[Union[IterableType, ArrayLike]]
+    ) -> Optional[list]:
         if labels is None:
             return None
         else:

classiq/interface/ast_node.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.helpers.hashable_pydantic_base_model import (
+    HashablePydanticBaseModel,
+)
+
+
+class SourceReference(pydantic.BaseModel):
+    start_line: int
+    start_column: int
+    end_line: int
+    end_column: int
+    file_name: Optional[str] = pydantic.Field(default=None)
+
+
+class ASTNode(pydantic.BaseModel):
+    source_ref: Optional[SourceReference] = pydantic.Field(default=None)
+
+
+class HashableASTNode(ASTNode, HashablePydanticBaseModel):
+    pass

classiq/interface/combinatorial_optimization/examples/mht.py

@@ -3,6 +3,7 @@ from typing import Dict, Tuple
 
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 Node = int
 Edge = Tuple[Node, Node]
@@ -22,7 +23,9 @@ def build_mht_pyomo_model(
     if has_constraints:
 
         @model.Constraint(model.Nodes)
-        def out_edges_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
+        def out_edges_rule(
+            model: pyo.ConcreteModel, idx: int
+        ) -> pyo_expr.ExpressionBase:
             out_nodes = [
                 node_id for node_id in model.Nodes if [idx, node_id] in model.Arcs
             ]
@@ -32,7 +35,9 @@ def build_mht_pyomo_model(
                 return pyo.Constraint.Feasible
 
         @model.Constraint(model.Nodes)
-        def in_edges_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
+        def in_edges_rule(
+            model: pyo.ConcreteModel, idx: int
+        ) -> pyo_expr.ExpressionBase:
             in_nodes = [
                 node_id for node_id in model.Nodes if [node_id, idx] in model.Arcs
             ]
@@ -41,7 +46,7 @@ def build_mht_pyomo_model(
             else:
                 return pyo.Constraint.Feasible
 
-    def obj_expression(model: pyo.ConcreteModel) -> pyo.ExpressionBase:
+    def obj_expression(model: pyo.ConcreteModel) -> pyo_expr.ExpressionBase:
         return sum(
             round(pubo_energy, _decimals)
             * math.prod(model.x[edge] for edge in pubo_edges)

classiq/interface/executor/execution_request.py

@@ -1,21 +1,18 @@
 from datetime import datetime
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union
 
 import pydantic
 from pydantic import BaseModel, Field
 from typing_extensions import Annotated
 
-from classiq.interface.backend.backend_preferences import IonqBackendPreferences
 from classiq.interface.executor.estimation import OperatorsEstimation
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
-from classiq.interface.executor.quantum_code import QuantumCode, QuantumInstructionSet
+from classiq.interface.executor.quantum_code import QuantumCode
 from classiq.interface.generator.quantum_program import QuantumProgram
 from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.jobs import JobStatus
 
-from classiq.exceptions import ClassiqValueError
-
 
 class QuantumProgramExecution(QuantumProgram):
     execution_type: Literal["quantum_program2"] = "quantum_program2"
@@ -42,38 +39,6 @@ class ExecutionRequest(BaseModel, json_encoders=CUSTOM_ENCODERS):
         description="preferences for the execution",
     )
 
-    @pydantic.validator("preferences")
-    def validate_ionq_backend(
-        cls, preferences: ExecutionPreferences, values: Dict[str, Any]
-    ) -> ExecutionPreferences:
-        """
-        This function implement the following check:
-        BE \\ payload | IonQ program | Qasm program | Other
-        --------------|--------------|--------------|------
-        IonQ backend  |       V      |      V       |   X
-        Other backend |       X      |      V       |   V
-        Since:
-        - We can't execute non-programs on the IonQ backends
-        - We can't execute IonQ programs on non-IonQ backends
-        """
-        quantum_program = values.get("execution_payload")
-        is_ionq_backend = isinstance(
-            preferences.backend_preferences, IonqBackendPreferences
-        )
-        if isinstance(quantum_program, QuantumCode):
-            if (
-                quantum_program.syntax == QuantumInstructionSet.IONQ
-                and not is_ionq_backend
-            ):
-                raise ClassiqValueError("Can only execute IonQ code on IonQ backend.")
-        else:
-            # If we handle anything other than a program.
-            if is_ionq_backend:
-                raise ClassiqValueError(
-                    "IonQ backend supports only execution of QuantumPrograms"
-                )
-        return preferences
-
 
 class QuantumProgramExecutionRequest(ExecutionRequest):
     execution_payload: QuantumCodeExecution

classiq/interface/executor/vqe_result.py

@@ -63,7 +63,7 @@ class VQESolverResult(SolverResult, QmodPyObject):
         self.convergence_graph.show()
 
     @property
-    def convergence_graph(self):
+    def convergence_graph(self) -> Image.Image:
         return Image.open(io.BytesIO(base64.b64decode(self.convergence_graph_str)))
 
     @property

classiq/interface/generator/builtin_api_builder.py

@@ -4,15 +4,10 @@ from classiq.interface.generator.functions.classical_function_declaration import
     ClassicalFunctionDeclaration,
 )
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
 
 
 def populate_builtin_declarations(decls: Iterable[Any]) -> None:
     for decl in decls:
-        if isinstance(decl, QuantumFunctionDeclaration):
-            QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS[decl.name] = decl
         if isinstance(decl, ClassicalFunctionDeclaration):
             ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS[decl.name] = decl
         if isinstance(decl, StructDeclaration):

classiq/interface/generator/constant.py

@@ -1,10 +1,9 @@
-import pydantic
-
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
 
 
-class Constant(pydantic.BaseModel):
+class Constant(ASTNode):
     name: str
     const_type: ConcreteClassicalType
     value: Expression

classiq/interface/generator/expressions/expression.py

@@ -4,6 +4,7 @@ from typing import Any, Mapping, Optional, Type
 import pydantic
 from pydantic import PrivateAttr
 
+from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
 )
@@ -17,14 +18,11 @@ from classiq.interface.generator.expressions.sympy_supported_expressions import
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
 from classiq.interface.generator.function_params import validate_expression_str
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
 
 from classiq.exceptions import ClassiqError
 
 
-class Expression(HashablePydanticBaseModel):
+class Expression(HashableASTNode):
     expr: str
     _evaluated_expr: Optional[EvaluatedExpression] = PrivateAttr(default=None)
 

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -4,7 +4,7 @@ from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedPr
 
 
 class QmodQScalarProxy(Symbol, QmodSizedProxy):
-    def __new__(cls, name, **assumptions):
+    def __new__(cls, name: str, **assumptions: bool) -> "QmodQScalarProxy":
         return super().__new__(cls, name, **assumptions)
 
     def __init__(self, name: str, size: int) -> None:

classiq/interface/generator/functions/__init__.py

@@ -1,7 +1,7 @@
 from typing import List
 
-import classiq.interface.generator.functions.core_lib_declarations.quantum_functions
-import classiq.interface.generator.functions.core_lib_declarations.quantum_operators
+import classiq.interface.generator.functions.builtins.core_library
+import classiq.interface.generator.functions.builtins.quantum_operators
 from classiq.interface.generator.functions.foreign_function_definition import *
 from classiq.interface.generator.functions.foreign_function_definition import (
     SynthesisForeignFunctionDefinition as ForeignFunctionDefinition,

classiq/interface/generator/functions/builtins/__init__.py

@@ -0,0 +1,15 @@
+from classiq.interface.generator.functions.builtins.core_library import CORE_LIB_DECLS
+from classiq.interface.generator.functions.builtins.open_lib_functions import (
+    OPEN_LIB_DECLS,
+)
+from classiq.interface.generator.functions.builtins.quantum_operators import (
+    STD_QMOD_OPERATORS,
+)
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+)
+
+QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS.update(
+    nameables_to_dict(STD_QMOD_OPERATORS + CORE_LIB_DECLS + OPEN_LIB_DECLS)
+)

classiq/interface/generator/functions/builtins/core_library/__init__.py

@@ -0,0 +1,14 @@
+from classiq.interface.generator.application_apis.chemistry_declarations import *  # noqa: F403
+from classiq.interface.generator.application_apis.combinatorial_optimization_declarations import *  # noqa: F403
+from classiq.interface.generator.application_apis.finance_declarations import *  # noqa: F403
+from classiq.interface.generator.application_apis.qsvm_declarations import *  # noqa: F403
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+)
+
+from .atomic_quantum_functions import *  # noqa: F403
+from .exponentiation_functions import *  # noqa: F403
+
+CORE_LIB_DECLS = [
+    func for func in vars().values() if isinstance(func, QuantumFunctionDeclaration)
+]

classiq/interface/generator/functions/builtins/internal_operators.py

@@ -0,0 +1,62 @@
+from classiq.interface.generator.functions.builtins.quantum_operators import (
+    get_single_empty_operand_operator,
+)
+from classiq.interface.generator.functions.classical_type import Bool, Integer
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+
+_CTRL_FIELD_NAME = "ctrl"
+CONTROL_OPERATOR = get_single_empty_operand_operator(
+    operator_name="control",
+    port_declarations={
+        _CTRL_FIELD_NAME: PortDeclaration(
+            name=_CTRL_FIELD_NAME,
+            direction=PortDeclarationDirection.Inout,
+        )
+    },
+)
+
+REPEAT_OPERATOR = QuantumFunctionDeclaration(
+    name="repeat",
+    param_decls={"count": Integer()},
+    operand_declarations={
+        "iteration": QuantumOperandDeclaration(
+            name="iteration", param_decls={"index": Integer()}
+        )
+    },
+)
+POWER_OPERATOR = get_single_empty_operand_operator(
+    operator_name="power", param_decls={"power": Integer()}
+)
+INVERT_OPERATOR = get_single_empty_operand_operator(operator_name="invert")
+
+IF_OPERATOR = QuantumFunctionDeclaration(
+    name="if",
+    param_decls={"condition": Bool()},
+    operand_declarations={
+        "then": QuantumOperandDeclaration(name="then"),
+        "else": QuantumOperandDeclaration(name="else"),
+    },
+)
+COMPUTE = get_single_empty_operand_operator(operator_name="compute")
+UNCOMPUTE = get_single_empty_operand_operator(operator_name="uncompute")
+
+
+INTERNAL_OPERATORS = nameables_to_dict(
+    [
+        CONTROL_OPERATOR,
+        REPEAT_OPERATOR,
+        POWER_OPERATOR,
+        INVERT_OPERATOR,
+        IF_OPERATOR,
+        COMPUTE,
+        UNCOMPUTE,
+    ]
+)