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

classiq/__init__.py

@@ -1,6 +1,5 @@
 """Classiq SDK."""
 
-import sys
 from typing import List
 
 from classiq.interface._version import VERSION as _VERSION
@@ -13,17 +12,12 @@ from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.expressions.enums.pauli import Pauli
 from classiq.interface.generator.functions import *  # noqa: F403
 from classiq.interface.generator.functions import __all__ as _ifunc_all
+from classiq.interface.generator.model import *  # noqa: F403
+from classiq.interface.generator.model import __all__ as _md_all
 from classiq.interface.generator.quantum_program import QuantumProgram
 from classiq.interface.ide.show import show
 
-from classiq import (
-    applications,
-    builtin_functions,
-    exceptions,
-    execution,
-    model,
-    synthesis,
-)
+from classiq import applications, exceptions, execution, synthesis
 from classiq._internals import _qfunc_ext, logger
 from classiq._internals.async_utils import (
     enable_jupyter_notebook,
@@ -34,23 +28,23 @@ from classiq._internals.client import configure
 from classiq._internals.config import Configuration
 from classiq._internals.help import open_help
 from classiq.analyzer import Analyzer
-from classiq.applications_model_constructors import *  # noqa: F403
-from classiq.applications_model_constructors import (
-    __all__ as _application_constructors_all,
+from classiq.applications.chemistry import (
+    construct_chemistry_model,
+    molecule_problem_to_qmod,
+)
+from classiq.applications.combinatorial_optimization import (
+    construct_combinatorial_optimization_model,
 )
+from classiq.applications.finance import construct_finance_model
+from classiq.applications.grover import construct_grover_model
+from classiq.applications.qsvm import construct_qsvm_model
 from classiq.executor import (
     execute,
     execute_async,
     set_quantum_program_execution_preferences,
 )
-from classiq.model import *  # noqa: F403
-from classiq.model import __all__ as _md_all
 from classiq.qmod import *  # noqa: F403
 from classiq.qmod import __all__ as _qmod_all
-from classiq.quantum_functions import *  # noqa: F403
-from classiq.quantum_functions import __all__ as _qfuncs_all
-from classiq.quantum_register import *  # noqa: F403
-from classiq.quantum_register import __all__ as _qregs_all
 from classiq.synthesis import (
     set_constraints,
     set_execution_preferences,
@@ -59,6 +53,15 @@ from classiq.synthesis import (
     synthesize_async,
 )
 
+_application_constructors_all = [
+    "construct_qsvm_model",
+    "construct_combinatorial_optimization_model",
+    "construct_chemistry_model",
+    "construct_finance_model",
+    "construct_grover_model",
+    "molecule_problem_to_qmod",
+]
+
 __version__ = _VERSION
 
 if _is_notebook():
@@ -67,10 +70,8 @@ if _is_notebook():
 _sub_modules = [
     "analyzer",
     "applications",
-    "builtin_functions",
     "exceptions",
     "execution",
-    "model",
     "open_help",
     "qmod",
     "synthesis",
@@ -95,8 +96,6 @@ __all__ = (
         "show",
         "Pauli",
     ]
-    + _qregs_all
-    + _qfuncs_all
     + _md_all
     + _ifunc_all
     + _sub_modules

classiq/_internals/api_wrapper.py

@@ -1,5 +1,5 @@
 import json
-from typing import Dict, Optional, Protocol, Type, TypeVar
+from typing import Dict, List, Optional, Protocol, Type, TypeVar
 
 import pydantic
 
@@ -14,6 +14,7 @@ from classiq.interface.execution.jobs import (
 )
 from classiq.interface.executor import execution_request, result as execute_result
 from classiq.interface.generator import quantum_program as generator_result
+from classiq.interface.hardware import HardwareInformation
 from classiq.interface.jobs import (
     JobDescriptionBase,
     JobDescriptionFailure,
@@ -297,6 +298,17 @@ class ApiWrapper:
         )
         return analysis_result.DevicesResult.parse_obj(data)
 
+    @classmethod
+    async def call_get_all_hardware_devices(cls) -> List[HardwareInformation]:
+        data = await client().call_api(
+            http_method=HTTPMethod.GET,
+            url="/hardware-catalog/v1/hardwares",
+            use_versioned_url=False,
+        )
+        if not isinstance(data, list):
+            raise ClassiqAPIError(f"Unexpected value: {data}")
+        return [HardwareInformation.parse_obj(info) for info in data]
+
     @classmethod
     async def call_generate_hamiltonian_task(
         cls, problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE

classiq/_internals/client.py

@@ -6,7 +6,17 @@ import os
 import platform
 import ssl
 import sys
-from typing import Any, Awaitable, Callable, Dict, NoReturn, Optional, TypeVar, Union
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    NoReturn,
+    Optional,
+    TypeVar,
+    Union,
+)
 
 import httpx
 from packaging.version import Version
@@ -214,7 +224,7 @@ class Client:
         params: Optional[Dict] = None,
         use_versioned_url: bool = True,
         headers: Optional[Dict[str, str]] = None,
-    ) -> Union[Dict, str]:
+    ) -> Union[Dict, List, str]:
         if use_versioned_url:
             url = self.make_versioned_url(url)
         async with self.async_client() as async_client:

classiq/analyzer/analyzer.py

@@ -81,7 +81,9 @@ class Analyzer(AnalyzerUtilities):
     def get_available_devices(
         self, providers: Optional[List[ProviderNameEnum]] = None
     ) -> Dict[ProviderNameEnum, List[DeviceName]]:
-        """Returns dict of the available devices by the providers. only devices
+        """Deprecated. Use get_all_hardware_devices instead.
+
+        Returns dict of the available devices by the providers. only devices
         with sufficient number of qubits are returns
 
         Args: providers (): List of providers (string or `AnalyzerProviderVendor`).

classiq/applications/__init__.py

@@ -1,15 +1,8 @@
 from typing import List
 
-from classiq.applications import (
-    benchmarking,
-    chemistry,
-    combinatorial_optimization,
-    finance,
-    qsvm,
-)
+from classiq.applications import chemistry, combinatorial_optimization, finance, qsvm
 
 __all__ = [
-    "benchmarking",
     "combinatorial_optimization",
     "chemistry",
     "finance",

classiq/applications/chemistry/__init__.py

@@ -15,6 +15,10 @@ from classiq.interface.chemistry.operator import PauliOperator, PauliOperators
 from . import ground_state_problem
 from .ansatz_parameters import HEAParameters, HVAParameters, UCCParameters
 from .chemistry_execution_parameters import ChemistryExecutionParameters
+from .chemistry_model_constructor import (
+    construct_chemistry_model,
+    molecule_problem_to_qmod,
+)
 
 __all__ = [
     "Molecule",
@@ -29,6 +33,8 @@ __all__ = [
     "HVAParameters",
     "HEAParameters",
     "ChemistryExecutionParameters",
+    "construct_chemistry_model",
+    "molecule_problem_to_qmod",
 ]
 
 

classiq/{applications_model_constructors → applications}/combinatorial_helpers/arithmetic/arithmetic_expression.py

@@ -5,7 +5,7 @@ from pyomo.core.expr.sympy_tools import PyomoSympyBimap
 from scipy.optimize import differential_evolution
 from sympy import Expr
 
-from classiq.applications_model_constructors.combinatorial_helpers import encoding_utils
+from classiq.applications.combinatorial_helpers import encoding_utils
 
 
 def sympy_lambdify(*args: Any, **kwargs: Any) -> Any:

classiq/{applications_model_constructors → applications}/combinatorial_helpers/combinatorial_problem_utils.py

@@ -1,5 +1,5 @@
 import itertools
-from typing import List, Union
+from typing import List, Union, cast
 
 import numpy as np
 import pyomo.environ as pyo
@@ -9,16 +9,19 @@ from classiq.interface.combinatorial_optimization.solver_types import QSolver
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 
-from classiq.applications_model_constructors.combinatorial_helpers.optimization_model import (
+from classiq.applications.combinatorial_helpers.optimization_model import (
     OptimizationModel,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pauli_helpers.pauli_sparsing import (
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_sparsing import (
     SparsePauliOp,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pauli_helpers.pauli_utils import (
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    PauliTerm,
+    get_pauli_operator,
     pauli_operator_to_hamiltonian,
+    pauli_string_to_int,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pyomo_utils import (
+from classiq.applications.combinatorial_helpers.pyomo_utils import (
     convert_pyomo_to_global_presentation,
 )
 
@@ -39,7 +42,7 @@ def compute_qaoa_initial_point(
     return list(itertools.chain(*zip(gamma_params, beta_params)))
 
 
-def pyo_model_to_hamiltonian(
+def _internal_pyo_model_to_hamiltonian(
     pyo_model: pyo.ConcreteModel, penalty_energy: float
 ) -> List[QmodPyStruct]:
     pauli_list = OptimizationModel(
@@ -48,6 +51,23 @@ def pyo_model_to_hamiltonian(
     return pauli_operator_to_hamiltonian(pauli_list)
 
 
+def pyo_model_to_hamiltonian(
+    pyo_model: pyo.ConcreteModel, penalty_energy: float
+) -> List[PauliTerm]:
+    hamiltonian = _internal_pyo_model_to_hamiltonian(pyo_model, penalty_energy)
+    pauli_operator = get_pauli_operator(hamiltonian).pauli_list
+    pauli_terms = []
+    for item in pauli_operator:
+        term = PauliTerm()
+        term.pauli, term.coefficient = (
+            pauli_string_to_int(item[0]),
+            cast(complex, item[1]).real,
+        )
+        pauli_terms.append(term)
+
+    return pauli_terms
+
+
 def _str_to_list_int(str_ints: str) -> List[int]:
     return list(map(int, list(str_ints)))
 

classiq/{applications_model_constructors → applications}/combinatorial_helpers/encoding_mapping.py

@@ -8,7 +8,7 @@ from pyomo.core.expr.visitor import clone_expression, identify_variables
 
 from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
 
-from classiq.applications_model_constructors.combinatorial_helpers import pyomo_utils
+from classiq.applications.combinatorial_helpers import pyomo_utils
 from classiq.exceptions import ClassiqCombOptError
 
 

classiq/{applications_model_constructors → applications}/combinatorial_helpers/encoding_utils.py

@@ -14,7 +14,7 @@ from pyomo.core.expr.numeric_expr import (
 )
 from sympy import Expr
 
-from classiq.applications_model_constructors.combinatorial_helpers import pyomo_utils
+from classiq.applications.combinatorial_helpers import pyomo_utils
 from classiq.exceptions import ClassiqCombOptNoSolutionError
 
 _INTEGER_TYPES = [pyo.NonNegativeIntegers, pyo.Integers, pyo.PositiveIntegers]

classiq/{applications_model_constructors → applications}/combinatorial_helpers/memory.py

@@ -6,10 +6,8 @@ from pyomo.core.base import _GeneralVarData
 
 from classiq.interface.generator.function_params import IOName
 
-from classiq.applications_model_constructors.combinatorial_helpers import encoding_utils
-from classiq.applications_model_constructors.combinatorial_helpers.encoding_mapping import (
-    EncodingMapping,
-)
+from classiq.applications.combinatorial_helpers import encoding_utils
+from classiq.applications.combinatorial_helpers.encoding_mapping import EncodingMapping
 
 AUXILIARY_NAME = "auxiliary"
 

classiq/{applications_model_constructors → applications}/combinatorial_helpers/optimization_model.py

@@ -13,28 +13,24 @@ from classiq.interface.combinatorial_optimization import sense
 from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
 
-from classiq.applications_model_constructors.combinatorial_helpers import (
+from classiq.applications.combinatorial_helpers import (
     encoding_utils,
     memory,
     pyomo_utils,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.encoding_mapping import (
-    EncodingMapping,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.memory import (
-    InternalQuantumReg,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.transformations import (
+from classiq.applications.combinatorial_helpers.encoding_mapping import EncodingMapping
+from classiq.applications.combinatorial_helpers.memory import InternalQuantumReg
+from classiq.applications.combinatorial_helpers.transformations import (
     encoding,
     ising_converter,
     penalty,
     slack_variables,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.transformations.fixed_variables import (
+from classiq.applications.combinatorial_helpers.transformations.fixed_variables import (
     add_fixed_variables_to_solution,
     remove_fixed_variables,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.transformations.penalty_support import (
+from classiq.applications.combinatorial_helpers.transformations.penalty_support import (
     is_model_penalty_supported,
 )
 from classiq.exceptions import ClassiqCombOptError

classiq/{applications_model_constructors → applications}/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -12,6 +12,16 @@ from classiq.exceptions import (
 )
 
 
+class PauliTerm:
+    pauli: List[int]
+    coefficient: float
+
+
+def pauli_string_to_int(pauli_str: str) -> List[int]:
+    pauli_map = {"I": 0, "X": 1, "Y": 2, "Z": 3}
+    return [pauli_map[char] for char in pauli_str]
+
+
 def _pauli_str_to_enums(pauli_str: str) -> str:
     return ", ".join(f"Pauli.{pauli_term}" for pauli_term in pauli_str)
 

classiq/{applications_model_constructors → applications}/combinatorial_helpers/pyomo_utils.py

@@ -1,6 +1,6 @@
 import json
 from enum import Enum
-from typing import Any, Dict, List, Type, TypeVar, Union
+from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union
 
 import pydantic
 import pyomo.core.expr.numeric_expr as pyo_expr
@@ -120,7 +120,9 @@ def get_name(component: Union[IndexedComponent, ComponentData]) -> str:
 
 
 class FixedSympy2PyomoVisitor(Sympy2PyomoVisitor):
-    def beforeChild(self, node, child, child_idx):  # noqa: N802
+    def beforeChild(  # noqa: N802
+        self, node: Optional[sympy.Expr], child: sympy.Expr, child_idx: Optional[int]
+    ) -> Tuple[bool, Union[int, float, None]]:
         if not child._args:
             item = self.object_map.getPyomoSymbol(child, None)
             if item is None:

classiq/{applications_model_constructors → applications}/combinatorial_helpers/transformations/encoding.py

@@ -10,16 +10,9 @@ from pyomo.core.expr.relational_expr import EqualityExpression
 from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
 
-from classiq.applications_model_constructors.combinatorial_helpers import (
-    encoding_utils,
-    pyomo_utils,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.encoding_mapping import (
-    EncodingMapping,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.encoding_utils import (
-    ONE_HOT_SUFFIX,
-)
+from classiq.applications.combinatorial_helpers import encoding_utils, pyomo_utils
+from classiq.applications.combinatorial_helpers.encoding_mapping import EncodingMapping
+from classiq.applications.combinatorial_helpers.encoding_utils import ONE_HOT_SUFFIX
 from classiq.exceptions import ClassiqCombOptInvalidEncodingTypeError
 
 

classiq/{applications_model_constructors → applications}/combinatorial_helpers/transformations/fixed_variables.py

@@ -7,18 +7,16 @@ from pyomo.core.expr.relational_expr import EqualityExpression
 from pyomo.core.expr.visitor import identify_variables
 from pyomo.repn.standard_repn import _GeneralVarData
 
-from classiq.applications_model_constructors.combinatorial_helpers import (
+from classiq.applications.combinatorial_helpers import (
     encoding_utils,
     pyomo_utils,
     sympy_utils,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.arithmetic.isolation import (
-    isolate,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.encoding_utils import (
+from classiq.applications.combinatorial_helpers.arithmetic.isolation import isolate
+from classiq.applications.combinatorial_helpers.encoding_utils import (
     deal_with_trivial_boolean_constraint,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.sympy_utils import (
+from classiq.applications.combinatorial_helpers.sympy_utils import (
     sympyify_expression,
     sympyify_vars,
 )

classiq/{applications_model_constructors → applications}/combinatorial_helpers/transformations/ising_converter.py

@@ -7,11 +7,9 @@ from pyomo.core.base import _GeneralVarData
 from classiq.interface.chemistry.operator import PauliOperator
 from classiq.interface.helpers import custom_pydantic_types
 
-from classiq.applications_model_constructors.combinatorial_helpers import memory
-from classiq.applications_model_constructors.combinatorial_helpers.memory import (
-    InternalQuantumReg,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.sympy_utils import (
+from classiq.applications.combinatorial_helpers import memory
+from classiq.applications.combinatorial_helpers.memory import InternalQuantumReg
+from classiq.applications.combinatorial_helpers.sympy_utils import (
     sympyify_expression,
     sympyify_vars,
 )

classiq/{applications_model_constructors → applications}/combinatorial_helpers/transformations/penalty_support.py

@@ -3,16 +3,12 @@ from pyomo.core.base.constraint import _GeneralConstraintData
 from pyomo.core.expr.relational_expr import EqualityExpression
 from pyomo.repn.standard_repn import _GeneralVarData
 
-from classiq.applications_model_constructors.combinatorial_helpers import (
+from classiq.applications.combinatorial_helpers import (
     allowed_constraints,
     encoding_utils,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pyomo_utils import (
-    extract,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.sympy_utils import (
-    sympyify_expression,
-)
+from classiq.applications.combinatorial_helpers.pyomo_utils import extract
+from classiq.applications.combinatorial_helpers.sympy_utils import sympyify_expression
 
 
 def is_model_penalty_supported(model: ConcreteModel) -> bool:

classiq/{applications_model_constructors → applications}/combinatorial_helpers/transformations/slack_variables.py

@@ -7,14 +7,12 @@ import pyomo.core as pyo
 from pyomo.core.base.component import _ComponentBase
 from pyomo.core.expr.sympy_tools import sympy2pyomo_expression, sympyify_expression
 
-from classiq.applications_model_constructors.combinatorial_helpers import pyomo_utils
-from classiq.applications_model_constructors.combinatorial_helpers.arithmetic.arithmetic_expression import (
+from classiq.applications.combinatorial_helpers import pyomo_utils
+from classiq.applications.combinatorial_helpers.arithmetic.arithmetic_expression import (
     multivariate_extremum,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.transformations import (
-    penalty_support,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.transformations.sign_seperation import (
+from classiq.applications.combinatorial_helpers.transformations import penalty_support
+from classiq.applications.combinatorial_helpers.transformations.sign_seperation import (
     sign_separation,
 )
 

classiq/applications/combinatorial_optimization/__init__.py

@@ -1,19 +1,25 @@
 from typing import List
 
 from classiq.interface.combinatorial_optimization import examples
+from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
 
-from classiq.applications_model_constructors.combinatorial_helpers.combinatorial_problem_utils import (
+from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
     get_optimization_solution_from_pyo,
 )
 
 from .combinatorial_optimization_config import OptimizerConfig, QAOAConfig
+from .combinatorial_optimization_model_constructor import (
+    construct_combinatorial_optimization_model,
+)
 
 __all__ = [
+    "EncodingType",
+    "OptimizerConfig",
+    "QAOAConfig",
     "QSolver",
+    "construct_combinatorial_optimization_model",
     "examples",
-    "QAOAConfig",
-    "OptimizerConfig",
     "get_optimization_solution_from_pyo",
 ]
 

classiq/{applications_model_constructors → applications/combinatorial_optimization}/combinatorial_optimization_model_constructor.py

@@ -20,19 +20,16 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
-from classiq.applications.combinatorial_optimization.combinatorial_optimization_config import (
-    OptimizerConfig,
-    QAOAConfig,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.combinatorial_problem_utils import (
+from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
+    _internal_pyo_model_to_hamiltonian,
     compute_qaoa_initial_point,
     convert_pyomo_to_global_presentation,
-    pyo_model_to_hamiltonian,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pauli_helpers.pauli_utils import (
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
     _pauli_operator_to_qmod,
     get_pauli_operator,
 )
+from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig
 
 
 def construct_combi_opt_py_model(
@@ -50,7 +47,9 @@ def construct_combi_opt_py_model(
     if optimizer_config.max_iteration is not None:
         max_iteration = optimizer_config.max_iteration
 
-    hamiltonian = pyo_model_to_hamiltonian(pyo_model, qaoa_config.penalty_energy)
+    hamiltonian = _internal_pyo_model_to_hamiltonian(
+        pyo_model, qaoa_config.penalty_energy
+    )
     qaoa_initial_point = compute_qaoa_initial_point(hamiltonian, qaoa_config.num_layers)
     len_hamiltonian = len(hamiltonian[0]["pauli"])
     pauli_oper = get_pauli_operator(hamiltonian)

classiq/applications/finance/__init__.py

@@ -4,14 +4,15 @@ from classiq.interface.finance import (
     function_input,
     gaussian_model_input,
     log_normal_model_input,
-    model_input,
 )
 
+from .finance_model_constructor import construct_finance_model
+
 __all__ = [
+    "construct_finance_model",
     "function_input",
     "gaussian_model_input",
     "log_normal_model_input",
-    "model_input",
 ]
 
 

classiq/{applications_model_constructors → applications/finance}/finance_model_constructor.py

@@ -18,10 +18,10 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
-from classiq.applications_model_constructors.libraries.ampltitude_estimation_library import (
+from classiq.applications.libraries.ampltitude_estimation_library import (
     AE_CLASSICAL_LIBRARY,
 )
-from classiq.applications_model_constructors.libraries.qmci_library import QMCI_LIBRARY
+from classiq.applications.libraries.qmci_library import QMCI_LIBRARY
 from classiq.exceptions import ClassiqError
 
 _OUTPUT_VARIABLE_NAME = "result"
@@ -75,16 +75,26 @@ def construct_finance_model(
                 },
                 body=[
                     VariableDeclarationStatement(name="unitary_port"),
+                    QuantumFunctionCall(
+                        function="allocate",
+                        positional_args=[
+                            Expression(expr=f"{num_unitary_qubits}"),
+                            HandleBinding(name="unitary_port"),
+                        ],
+                    ),
+                    QuantumFunctionCall(
+                        function="allocate_num",
+                        positional_args=[
+                            Expression(expr=f"{phase_port_size}"),
+                            Expression(expr="False"),
+                            Expression(expr=f"{phase_port_size}"),
+                            HandleBinding(name="phase_port"),
+                        ],
+                    ),
                     QuantumFunctionCall(
                         function="qmci",
-                        params={
-                            "num_phase_qubits": Expression(expr=f"{phase_port_size}"),
-                            "num_unitary_qubits": Expression(
-                                expr=f"{num_unitary_qubits}"
-                            ),
-                        },
                         operands={
-                            "sp_op": QuantumLambdaFunction(
+                            "space_transform": QuantumLambdaFunction(
                                 body=[
                                     QuantumFunctionCall(
                                         function=finance_function,
@@ -97,16 +107,16 @@ def construct_finance_model(
                                             ),
                                         },
                                         inouts={
-                                            "func_port": HandleBinding(name="reg"),
-                                            "obj_port": HandleBinding(name="ind"),
+                                            "func_port": HandleBinding(name="arg0"),
+                                            "obj_port": HandleBinding(name="arg1"),
                                         },
                                     ),
                                 ],
                             ),
                         },
-                        outputs={
-                            "phase_port": HandleBinding(name="phase_port"),
-                            "unitary_port": HandleBinding(name="unitary_port"),
+                        inouts={
+                            "phase": HandleBinding(name="phase_port"),
+                            "packed_vars": HandleBinding(name="unitary_port"),
                         },
                     ),
                 ],

classiq/applications/grover/__init__.py

@@ -0,0 +1,11 @@
+from typing import List
+
+from .grover_model_constructor import construct_grover_model
+
+__all__ = [
+    "construct_grover_model",
+]
+
+
+def __dir__() -> List[str]:
+    return __all__