classiq 0.38.0__py3-none-any.whl → 0.40.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,24 @@ 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,
+    pyo_model_to_hamiltonian,
 )
+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 +54,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 +71,8 @@ if _is_notebook():
 _sub_modules = [
     "analyzer",
     "applications",
-    "builtin_functions",
     "exceptions",
     "execution",
-    "model",
     "open_help",
     "qmod",
     "synthesis",
@@ -95,8 +97,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/chemistry}/chemistry_model_constructor.py

@@ -446,7 +446,7 @@ def _get_chemistry_quantum_main(
             function="allocate",
             positional_args=[
                 Expression(
-                    expr=f"len(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'))"
+                    expr=f"get_field(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'), 'len')"
                 ),
                 HandleBinding(name="qbv"),
             ],

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,18 +9,21 @@ 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 import Pauli
+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 (
+    get_pauli_operator,
     pauli_operator_to_hamiltonian,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pyomo_utils import (
+from classiq.applications.combinatorial_helpers.pyomo_utils import (
     convert_pyomo_to_global_presentation,
 )
+from classiq.qmod.builtins import PauliTerm
 
 
 def compute_qaoa_initial_point(
@@ -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,22 @@ 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(
+            [Pauli[p] for p in item[0]],  # type:ignore[arg-type]
+            cast(complex, item[1]).real,  # type:ignore[arg-type]
+        )
+        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
@@ -49,22 +45,23 @@ class OptimizationModel:
         encoding_type: Optional[EncodingType] = None,
     ) -> None:
         assert model.nobjectives() == 1, "model must have a single objective"
-        self._model_original = copy.deepcopy(model)
-        self._assigned_model = remove_fixed_variables(model)
+        model_copy = copy.deepcopy(model)
+        self._model_original = model
+        self._assigned_model = remove_fixed_variables(model_copy)
         self.qsolver = qsolver
         self._encoding_type = encoding_type
 
-        self.is_encoded = encoding_utils.is_model_encodable(model)
+        self.is_encoded = encoding_utils.is_model_encodable(model_copy)
         if self.is_encoded:
             if self._encoding_type is None:
                 self._encoding_type = EncodingType.BINARY
             self._model_encoder = encoding.ModelEncoder(
-                model, qsolver, self._encoding_type
+                model_copy, qsolver, self._encoding_type
             )
             self._model = self._model_encoder.encoded_model
             self._vars_encoding_mapping = self._model_encoder.vars_encoding_mapping
         else:
-            self._model = model
+            self._model = model_copy
             # TODO How to handle encoding_type == None
             self._vars_encoding_mapping = EncodingMapping(self._encoding_type)  # type: ignore[arg-type]
 
@@ -74,7 +71,7 @@ class OptimizationModel:
             self.vars_not_encoded, self._vars_encoding_mapping
         )
 
-        self.is_maximization = sense.is_maximization(model)
+        self.is_maximization = sense.is_maximization(model_copy)
         self.objective = next(self._model.component_objects(pyo.Objective))
 
         self.penalty_energy = penalty_energy

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,20 +1,28 @@
 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,
+    pyo_model_to_hamiltonian,
 )
 
 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",
+    "pyo_model_to_hamiltonian",
 ]
 
 

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)
@@ -89,14 +88,14 @@ def construct_combi_opt_py_model(
                     QuantumFunctionCall(
                         function="allocate",
                         positional_args=[
-                            Expression(expr="len(target)"),
+                            Expression(expr="target.len"),
                             HandleBinding(name="target"),
                         ],
                     ),
                     QuantumFunctionCall(
                         function="qaoa_penalty",
                         params={
-                            "num_qubits": Expression(expr="len(target)"),
+                            "num_qubits": Expression(expr="target.len"),
                             "params_list": Expression(expr="params_list"),
                             "hamiltonian": Expression(expr="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",
 ]