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

classiq/model/function_handler.py

@@ -25,7 +25,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.identity import Identity
 from classiq.interface.generator.quantum_function_call import (
     SynthesisQuantumFunctionCall,
-    WireName,
+    WireDict,
 )
 from classiq.interface.generator.slice_parsing_utils import parse_io_slicing
 from classiq.interface.generator.user_defined_function_params import CustomFunction
@@ -46,8 +46,6 @@ SupportedInputArgs = Union[
     QReg,
 ]
 
-WireNameDict = Dict[IOName, WireName]
-
 _SAME_INPUT_NAME_ERROR_MSG: str = "Cannot create multiple inputs with the same name"
 _INPUT_AS_OUTPUT_ERROR_MSG: str = "Can't connect input directly to output"
 ILLEGAL_INPUT_OR_SLICING_ERROR_MSG: str = "is not a valid input name/slice"
@@ -64,7 +62,7 @@ class FunctionHandler(abc.ABC):
     def __init__(self) -> None:
         self._function_library: Optional[FunctionLibrary] = None
         self._port_declarations: Dict[IOName, SynthesisPortDeclaration] = dict()
-        self._external_port_wiring: Dict[PortDirection, WireNameDict] = {
+        self._external_port_wiring: Dict[PortDirection, WireDict] = {
             PortDirection.Input: dict(),
             PortDirection.Output: dict(),
         }
@@ -72,11 +70,11 @@ class FunctionHandler(abc.ABC):
         self._logic_flow_builder: LogicFlowBuilder = LogicFlowBuilder()
 
     @property
-    def input_wires(self) -> WireNameDict:
+    def input_wires(self) -> WireDict:
         return self._external_port_wiring[PortDirection.Input]
 
     @property
-    def output_wires(self) -> WireNameDict:
+    def output_wires(self) -> WireDict:
         return self._external_port_wiring[PortDirection.Output]
 
     def _verify_unique_inputs(self, input_names: Iterable[IOName]) -> None:
@@ -372,9 +370,7 @@ class FunctionHandler(abc.ABC):
         call: SynthesisQuantumFunctionCall,
         out_wires: Mapping[IOName, QReg],
     ) -> Dict[IOName, QReg]:
-        if not all(
-            output_name in call.output_regs_dict.keys() for output_name in out_wires
-        ):
+        if not all(output_name in call.output_regs_dict for output_name in out_wires):
             raise ClassiqWiringError(ILLEGAL_OUTPUT_ERROR_MSG)
         output_dict = {}
         for output_name, reg_user_input in call.output_regs_dict.items():

classiq/model/model.py

@@ -3,9 +3,7 @@
 from __future__ import annotations
 
 import logging
-import tempfile
-from contextlib import nullcontext
-from typing import IO, Any, ContextManager, Dict, List, Mapping, Optional, Union, cast
+from typing import Any, Dict, List, Mapping, Optional, cast
 
 from classiq.interface.chemistry.operator import PauliOperator
 from classiq.interface.executor.execution_preferences import (
@@ -25,7 +23,6 @@ from classiq.interface.generator.quantum_function_call import (
     SynthesisQuantumFunctionCall,
 )
 
-from classiq._internals.async_utils import AsyncifyABC
 from classiq.exceptions import ClassiqError, ClassiqValueError
 from classiq.model import function_handler
 from classiq.quantum_functions.function_library import FunctionLibrary
@@ -33,8 +30,6 @@ from classiq.quantum_register import QReg, QRegGenericAlias
 
 _logger = logging.getLogger(__name__)
 
-_SupportedIO = Union[IO, str]
-
 # TODO: Add docstrings for auto generated methods.
 
 
@@ -56,23 +51,11 @@ def _pauli_operator_to_qmod(hamiltonian: PauliOperator) -> str:
     )
 
 
-def _file_handler(fp: Optional[_SupportedIO], mode: str = "r") -> ContextManager[IO]:
-    if fp is None:
-        temp_file = tempfile.NamedTemporaryFile(mode, suffix=".qmod", delete=False)
-        print(f"Using temporary file: {temp_file.name!r}")
-        return temp_file
-
-    if isinstance(fp, str):
-        return open(fp, mode)
-
-    return nullcontext(fp)
-
-
 DEFAULT_RESULT_NAME = "result"
 DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME = "estimation"
 
 
-class Model(function_handler.FunctionHandler, metaclass=AsyncifyABC):
+class Model(function_handler.FunctionHandler):
     """Facility to generate circuits, based on the model."""
 
     def __init__(self, **kwargs: Any) -> None:

classiq/qmod/__init__.py

@@ -1,12 +1,16 @@
 from . import symbolic
 from .builtins import *  # noqa: F403
 from .builtins import __all__ as _builtins_all
-from .classical_function import CFunc
+from .cfunc import cfunc
+from .expression_query import get_expression_numeric_attributes
+from .qfunc import qfunc
+from .qmod_constant import QConstant
 from .qmod_parameter import Array, QParam
-from .qmod_struct import QStruct
+from .qmod_struct import struct
 from .qmod_variable import Input, Output, QArray, QBit, QNum
 from .quantum_callable import QCallable, QCallableList
-from .quantum_function import QFunc, create_model
+from .quantum_function import create_model
+from .write_qmod import write_qmod
 
 __all__ = [
     "QParam",
@@ -18,9 +22,12 @@ __all__ = [
     "QNum",
     "QCallable",
     "QCallableList",
-    "QStruct",
-    "QFunc",
-    "CFunc",
+    "QConstant",
+    "struct",
+    "qfunc",
+    "cfunc",
     "create_model",
     "symbolic",
+    "write_qmod",
+    "get_expression_numeric_attributes",
 ] + _builtins_all

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
 from classiq.interface.executor.iqae_result import IQAEResult
@@ -6,32 +6,38 @@ from classiq.interface.executor.result import EstimationResult, ExecutionDetails
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.expressions.enums import Optimizer
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
-from classiq.interface.generator.types.combinatorial_problem import (
-    CombinatorialOptimizationStructDeclaration,
-)
 
 from classiq.applications.qsvm.qsvm import Data, Labels
+from classiq.exceptions import ClassiqError
+
+ExecutionParams = Dict[str, Union[float, int]]
+
+_CALL_IN_QFUNC_ERROR = (
+    'Cannot call "{}" in a quantum context. "{}" is a classical execution primitive.'
+)
+
 
-ExecutionParams = Dict[str, float]
+def _raise_error(primitive_name: str) -> None:
+    raise ClassiqError(_CALL_IN_QFUNC_ERROR.format(primitive_name, primitive_name))
 
 
 def save(values_to_save: dict) -> None:
-    pass
+    _raise_error("save")
 
 
-def sample(  # type: ignore
+def sample(  # type: ignore[return]
     execution_params: Optional[ExecutionParams] = None,
 ) -> ExecutionDetails:
-    pass
+    _raise_error("sample")
 
 
-def estimate(  # type: ignore
+def estimate(  # type: ignore[return]
     hamiltonian: List[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
 ) -> EstimationResult:
-    pass
+    _raise_error("estimate")
 
 
-def vqe(  # type: ignore
+def vqe(  # type: ignore[return]
     hamiltonian: List[QmodPyStruct],
     maximize: bool,
     initial_point: List[int],
@@ -42,56 +48,43 @@ def vqe(  # type: ignore
     skip_compute_variance: bool,
     alpha_cvar: float,
 ) -> VQESolverResult:
-    pass
+    _raise_error("vqe")
 
 
-def qae_with_qpe_result_post_processing(  # type: ignore
+def qae_with_qpe_result_post_processing(  # type: ignore[return]
     estimation_register_size: int,
     estimation_method: QaeWithQpeEstimationMethod,
     result: ExecutionDetails,
 ) -> float:
-    pass
+    _raise_error("qae_with_qpe_result_post_processing")
 
 
-def qsvm_full_run(  # type: ignore
+def qsvm_full_run(  # type: ignore[return]
     train_data: Data,
     train_labels: Labels,
     test_data: Data,
     test_labels: Labels,
     predict_data: Data,
 ) -> QmodPyStruct:
-    pass
+    _raise_error("qsvm_full_run")
 
 
-def iqae(  # type: ignore
+def iqae(  # type: ignore[return]
     epsilon: float,
     alpha: float,
     execution_params: Optional[ExecutionParams] = None,
 ) -> IQAEResult:
-    pass
+    _raise_error("iqae")
 
 
-def molecule_ground_state_solution_post_process(  # type: ignore
+def molecule_ground_state_solution_post_process(  # type: ignore[return]
     problem: QmodPyStruct, vqe_result: VQESolverResult
 ) -> QmodPyStruct:
-    pass
-
-
-def optimization_problem_to_hamiltonian(  # type: ignore
-    problem_struct: CombinatorialOptimizationStructDeclaration, penalty_energy: float
-) -> List[QmodPyStruct]:
-    pass
-
-
-def get_optimization_solution(  # type: ignore
-    problem_struct: CombinatorialOptimizationStructDeclaration,
-    vqe_result: VQESolverResult,
-    penalty_energy: float,
-) -> List[QmodPyStruct]:
-    pass
+    _raise_error("molecule_ground_state_solution_post_process")
 
 
 __all__ = [
+    "ExecutionParams",
     "save",
     "sample",
     "estimate",
@@ -100,8 +93,6 @@ __all__ = [
     "qsvm_full_run",
     "iqae",
     "molecule_ground_state_solution_post_process",
-    "optimization_problem_to_hamiltonian",
-    "get_optimization_solution",
 ]
 
 

classiq/qmod/builtins/classical_functions.py

@@ -8,23 +8,16 @@ from classiq.qmod.symbolic import symbolic_function
 from .structs import *
 
 
-def compute_qaoa_initial_point(
-    hamiltonian: QParam[List[PauliTerm]],
-    repetitions: QParam[int],
-) -> QParam[List[float]]:
-    return symbolic_function(hamiltonian, repetitions)
-
-
 def molecule_problem_to_hamiltonian(
     problem: QParam[MoleculeProblem],
 ) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem)
+    return symbolic_function(problem, return_type=QParam[List[PauliTerm]])
 
 
 def fock_hamiltonian_problem_to_hamiltonian(
     problem: QParam[FockHamiltonianProblem],
 ) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem)
+    return symbolic_function(problem, return_type=QParam[List[PauliTerm]])
 
 
 def grid_entangler_graph(
@@ -32,13 +25,18 @@ def grid_entangler_graph(
     schmidt_rank: QParam[int],
     grid_randomization: QParam[bool],
 ) -> QParam[List[List[int]]]:
-    return symbolic_function(num_qubits, schmidt_rank, grid_randomization)
+    return symbolic_function(
+        num_qubits,
+        schmidt_rank,
+        grid_randomization,
+        return_type=QParam[List[List[int]]],
+    )
 
 
 def hypercube_entangler_graph(
     num_qubits: QParam[int],
 ) -> QParam[List[List[int]]]:
-    return symbolic_function(num_qubits)
+    return symbolic_function(num_qubits, return_type=QParam[List[List[int]]])
 
 
 def log_normal_finance_post_process(
@@ -46,7 +44,9 @@ def log_normal_finance_post_process(
     estimation_method: QParam[FinanceFunction],
     probability: QParam[float],
 ) -> QParam[float]:
-    return symbolic_function(finance_model, estimation_method, probability)
+    return symbolic_function(
+        finance_model, estimation_method, probability, return_type=QParam[float]
+    )
 
 
 def gaussian_finance_post_process(
@@ -54,15 +54,25 @@ def gaussian_finance_post_process(
     estimation_method: QParam[FinanceFunction],
     probability: QParam[float],
 ) -> QParam[float]:
-    return symbolic_function(finance_model, estimation_method, probability)
+    return symbolic_function(
+        finance_model, estimation_method, probability, return_type=QParam[float]
+    )
+
+
+def qft_const_adder_phase(
+    bit_index: QParam[int],
+    value: QParam[int],
+    reg_len: QParam[int],
+) -> QParam[float]:
+    return symbolic_function(bit_index, value, reg_len, return_type=QParam[float])
 
 
 __all__ = [
-    "compute_qaoa_initial_point",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "grid_entangler_graph",
     "hypercube_entangler_graph",
     "log_normal_finance_post_process",
     "gaussian_finance_post_process",
+    "qft_const_adder_phase",
 ]