classiq 0.62.0__py3-none-any.whl → 0.63.1__py3-none-any.whl

classiq/__init__.py

@@ -46,6 +46,8 @@ from classiq.executor import (
     execute_async,
     set_quantum_program_execution_preferences,
 )
+from classiq.open_library import *  # noqa: F403
+from classiq.open_library import __all__ as _open_library_all
 from classiq.qmod import *  # noqa: F403
 from classiq.qmod import __all__ as _qmod_all
 from classiq.synthesis import (
@@ -114,6 +116,7 @@ __all__ = (
     + _sub_modules
     + _application_constructors_all
     + _qmod_all
+    + _open_library_all
 )
 
 

classiq/_internals/api_wrapper.py

@@ -33,10 +33,6 @@ from classiq._internals.client import client
 from classiq._internals.jobs import JobPoller
 
 ResultType = TypeVar("ResultType", bound=pydantic.BaseModel)
-CLASSIQ_ACCEPT_HEADER = "X-Classiq-Accept-Version"
-
-_ACCEPT_HEADER = "X-Classiq-Accept-Version"
-_CONTENT_TYPE_HEADER = "X-Classiq-Content-Type-Version"
 
 
 class HTTPMethod(StrEnum):
@@ -143,16 +139,10 @@ class ApiWrapper:
         execution_input: dict,
         http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
-        headers = {
-            _ACCEPT_HEADER: "v1",
-            _CONTENT_TYPE_HEADER: execution_input["version"],
-        }
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
-            headers=headers,
-            url=routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH,
+            url=routes.EXECUTION_JOBS_FULL_PATH,
             body=execution_input,
-            use_versioned_url=False,
             http_client=http_client,
         )
         return execution_request.ExecutionJobDetails.model_validate(data)
@@ -163,12 +153,9 @@ class ApiWrapper:
         job_id: JobID,
         http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
-        headers = {_ACCEPT_HEADER: "v1"}
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            headers=headers,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
-            use_versioned_url=False,
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
             http_client=http_client,
         )
         return execution_request.ExecutionJobDetails.model_validate(data)
@@ -177,14 +164,11 @@ class ApiWrapper:
     async def call_get_execution_job_result(
         cls,
         job_id: JobID,
-        version: str,
         http_client: Optional[httpx.AsyncClient] = None,
     ) -> classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}/result",
-            use_versioned_url=False,
-            headers={CLASSIQ_ACCEPT_HEADER: version},
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}/result",
             http_client=http_client,
         )
         return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.model_validate(
@@ -200,11 +184,10 @@ class ApiWrapper:
     ) -> ExecutionJobDetailsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.PATCH,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
             params={
                 "name": name,
             },
-            use_versioned_url=False,
             http_client=http_client,
         )
         return ExecutionJobDetailsV1.model_validate(data)
@@ -217,8 +200,7 @@ class ApiWrapper:
     ) -> None:
         await cls._call_task(
             http_method=HTTPMethod.PUT,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}/cancel",
-            use_versioned_url=False,
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}/cancel",
             allow_none=True,
             http_client=http_client,
         )
@@ -232,12 +214,11 @@ class ApiWrapper:
     ) -> ExecutionJobsQueryResultsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}",
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}",
             params={
                 "offset": offset,
                 "limit": limit,
             },
-            use_versioned_url=False,
             http_client=http_client,
         )
         return ExecutionJobsQueryResultsV1.model_validate(data)
@@ -395,7 +376,6 @@ class ApiWrapper:
     ) -> operator.PauliOperator:
         poller = JobPoller(
             base_url=routes.GENERATE_HAMILTONIAN_FULL_PATH,
-            use_versioned_url=False,
         )
         result = await poller.run_pydantic(
             problem, timeout_sec=None, http_client=http_client

classiq/_internals/client.py

@@ -9,14 +9,7 @@ import sys
 import time
 from collections.abc import Awaitable
 from types import TracebackType
-from typing import (
-    Any,
-    Callable,
-    NoReturn,
-    Optional,
-    TypeVar,
-    Union,
-)
+from typing import Any, Callable, NoReturn, Optional, TypeVar, Union
 
 import httpx
 from typing_extensions import ParamSpec
@@ -170,7 +163,6 @@ class Client:
     _UNKNOWN_VERSION = HostChecker._UNKNOWN_VERSION
     _SESSION_HEADER = "Classiq-Session"
     _WARNINGS_HEADER = "X-Classiq-Warnings"
-    _LATEST_VERSION_API_PREFIX = "/api/v1"
     _HTTP_TIMEOUT_SECONDS = 3600  # Needs to be synced with load-balancer timeout
 
     def __init__(self, conf: config.Configuration) -> None:

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -53,7 +53,7 @@ from classiq.applications.chemistry.chemistry_execution_parameters import (
 )
 from classiq.interface.exceptions import ClassiqError
 from classiq.qmod.utilities import qmod_val_to_expr_str
-from classiq.qmod.builtins.functions.hea import full_hea
+from classiq.open_library.functions.hea import full_hea
 
 _LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {
     "+": "PLUS",

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -7,6 +7,7 @@ import pyomo.environ as pyo
 
 from classiq.interface.combinatorial_optimization.sense import is_maximization
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 
@@ -20,6 +21,7 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
     pauli_operator_to_hamiltonian,
 )
 from classiq.applications.combinatorial_helpers.pyomo_utils import (
+    add_var_domain_constraints,
     convert_pyomo_to_global_presentation,
     evaluate_objective,
     pyomo_to_qmod_qstruct,
@@ -56,14 +58,30 @@ def pyo_model_to_hamiltonian(
 def pyo_model_to_qmod_problem(
     pyo_model: pyo.ConcreteModel, penalty_energy: float
 ) -> tuple[type[QStruct], Callable]:
-    optimization_model = OptimizationModel(
-        pyo_model, penalty_energy=penalty_energy, qsolver=QSolver.QAOAPenalty
-    )
-    qmod_struct = pyomo_to_qmod_qstruct("QAOAVars", optimization_model.vars_not_encoded)
-    cost_func = partial(
-        evaluate_objective, *optimization_model.objective_not_encoded_sympy
-    )
-    return qmod_struct, cost_func
+    with add_var_domain_constraints(pyo_model):
+        optimization_model = OptimizationModel(
+            pyo_model, penalty_energy=penalty_energy, qsolver=QSolver.QAOAPenalty
+        )
+        _validate_var_domains(optimization_model)
+        qmod_struct = pyomo_to_qmod_qstruct(
+            "QAOAVars", optimization_model.vars_not_encoded
+        )
+        cost_func = partial(
+            evaluate_objective, *optimization_model.objective_not_encoded_sympy
+        )
+        return qmod_struct, cost_func
+
+
+def _validate_var_domains(model: OptimizationModel) -> None:
+    for var in model.vars_not_encoded:
+        if (
+            isinstance(var.bounds, tuple)
+            and len(var.bounds) == 2
+            and var.bounds[0] != 0
+        ):
+            raise ClassiqValueError(
+                f"Bounds of variable {var.local_name} must start at 0, got {var.bounds}"
+            )
 
 
 def _str_to_list_int(str_ints: str) -> list[int]:

classiq/applications/combinatorial_helpers/optimization_model.py

@@ -25,6 +25,7 @@ from classiq.applications.combinatorial_helpers.encoding_mapping import Encoding
 from classiq.applications.combinatorial_helpers.memory import InternalQuantumReg
 from classiq.applications.combinatorial_helpers.pyomo_utils import (
     get_field_name,
+    index_as_tuple,
     is_index_var,
 )
 from classiq.applications.combinatorial_helpers.transformations import (
@@ -182,7 +183,10 @@ class OptimizationModel:
             sympy_var: (
                 get_field_name(pyomo_var)
                 if not is_index_var(pyomo_var)
-                else (get_field_name(pyomo_var.parent_component()), pyomo_var.index())
+                else (
+                    get_field_name(pyomo_var.parent_component()),
+                    index_as_tuple(pyomo_var.index()),
+                )
             )
             for pyomo_var, sympy_var in objective_map.pyomo2sympy.items()
         }

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -1,7 +1,11 @@
 import math
 import re
 from collections import defaultdict
+from collections.abc import Iterator
+from contextlib import contextmanager
 from enum import Enum
+from functools import reduce
+from operator import mul
 from typing import Any, Optional, TypeVar, Union
 
 import pydantic
@@ -14,6 +18,7 @@ from pyomo.core.base.component import ComponentData
 from pyomo.core.base.constraint import _GeneralConstraintData
 from pyomo.core.base.indexed_component import IndexedComponent
 from pyomo.core.base.objective import ScalarObjective
+from pyomo.core.expr.base import ExpressionBase
 from pyomo.core.expr.sympy_tools import (
     Pyomo2SympyVisitor,
     PyomoSympyBimap,
@@ -268,44 +273,67 @@ def pyomo_to_qmod_qstruct(
 
 
 def _get_qstruct_fields(vars: list[_GeneralVarData]) -> dict[str, type[QVar]]:
-    array_types = _get_array_types(vars)
-    array_type_sizes = _get_array_sizes(array_types)
+    array_type_sizes = _get_array_sizes(vars)
     fields: dict[str, type[QVar]] = {}
     for var in vars:
         _add_qmod_field(var, array_type_sizes, fields)
     return fields
 
 
-def _get_array_types(vars: list[_GeneralVarData]) -> dict[str, set[int]]:
-    array_types: dict[str, set[int]] = defaultdict(set)
+def _get_array_sizes(vars: list[_GeneralVarData]) -> dict[str, tuple[int, ...]]:
+    array_types: dict[str, set[tuple]] = defaultdict(set)
     for var in vars:
         if is_index_var(var):
-            array_types[var.parent_component().name].add(var.index())
-    return array_types
-
-
-def _get_array_sizes(array_types: dict[str, set[int]]) -> dict[str, int]:
+            array_types[get_field_name(var.parent_component())].add(
+                index_as_tuple(var.index())
+            )
     return {
-        name: array_size
+        name: dimensions
         for name, indices in array_types.items()
-        if indices == set(range(array_size := len(indices)))
+        if (dimensions := _get_indices_dimensions(indices)) is not None
     }
 
 
+def _get_indices_dimensions(indices: set[tuple[int, ...]]) -> Optional[tuple[int, ...]]:
+    indices_list = list(indices)
+    if len(indices) == 0:
+        return None
+    first_idx = indices_list[0]
+    if len(first_idx) == 0:
+        return None
+    if any(len(idx) != len(first_idx) for idx in indices_list[1:]):
+        return None
+    dimension_bounds = [(idx, idx) for idx in first_idx]
+    for multi_idx in indices_list[1:]:
+        for dim_idx, idx in enumerate(multi_idx):
+            dimension_bounds[dim_idx] = (
+                min(dimension_bounds[dim_idx][0], idx),
+                max(dimension_bounds[dim_idx][1], idx),
+            )
+    if any(lb != 0 for lb, ub in dimension_bounds):
+        return None
+    dimensions = tuple(ub + 1 for _, ub in dimension_bounds)
+    if reduce(mul, dimensions) != len(indices_list):
+        return None
+    return dimensions
+
+
 def _add_qmod_field(
     var: _GeneralVarData,
-    array_type_sizes: dict[str, int],
+    array_type_sizes: dict[str, tuple[int, ...]],
     fields: dict[str, type[QVar]],
 ) -> None:
-    parent_name = var.parent_component().name
+    parent_name = get_field_name(var.parent_component())
     if parent_name not in array_type_sizes:
         var_name = get_field_name(var)
         fields[var_name] = _get_qmod_field_type(var_name, var)
-    elif var.index() == 0:
-        fields[parent_name] = QArray[  # type:ignore[misc]
-            _get_qmod_field_type(parent_name, var),
-            array_type_sizes[parent_name],
-        ]
+        return
+    dimensions = array_type_sizes[parent_name]
+    if index_as_tuple(var.index()) == tuple(0 for _ in range(len(dimensions))):
+        qmod_type: type[QVar] = _get_qmod_field_type(parent_name, var)
+        for dim in reversed(dimensions):
+            qmod_type = QArray[qmod_type, dim]  # type:ignore[valid-type]
+        fields[parent_name] = qmod_type
 
 
 def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]:
@@ -325,14 +353,12 @@ def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]
         raise ClassiqValueError(
             f"Non-integer bounds for variable {var_name!r} are not supported"
         )
-    if lb > 0:
-        ub -= lb
     qnum: Any = QNum  # mypy shenanigans
-    return qnum[math.ceil(math.log2(ub - lb)), False, 0]
+    return qnum[math.ceil(math.log2(ub - lb + 1)), False, 0]
 
 
 def evaluate_objective(
-    var_mapping: dict[Any, Union[str, tuple[str, int]]],
+    var_mapping: dict[Any, Union[str, tuple[str, tuple[int, ...]]]],
     sympy_expr: sympy.Expr,
     struct_obj: Any,
 ) -> Any:
@@ -340,7 +366,7 @@ def evaluate_objective(
         sympy_var: (
             getattr(struct_obj, field_accessor)
             if isinstance(field_accessor, str)
-            else getattr(struct_obj, field_accessor[0])[field_accessor[1]]
+            else _get_item(getattr(struct_obj, field_accessor[0]), field_accessor[1])
         )
         for sympy_var, field_accessor in var_mapping.items()
     }
@@ -357,12 +383,65 @@ def evaluate_objective(
     return SymbolicExpr(expr=expr_str, is_quantum=True)
 
 
+def _get_item(obj: Any, multi_index: tuple[int, ...]) -> Any:
+    for idx in multi_index:
+        obj = obj[idx]
+    return obj
+
+
 def get_field_name(var: _GeneralVarData) -> str:
-    return var.local_name.replace("[", "_").replace("]", "")
+    return var.local_name.replace("[", "_").replace("]", "").replace(",", "_")
 
 
 def is_index_var(var: _GeneralVarData) -> bool:
-    return (
-        isinstance(var.index(), int)
-        and "[" not in var.parent_component().name  # nested arrays not supported
+    index = var.index()
+    return isinstance(index, int) or (
+        isinstance(index, tuple) and all(isinstance(idx, int) for idx in index)
     )
+
+
+def index_as_tuple(index: Union[int, tuple[int, ...]]) -> tuple[int, ...]:
+    if isinstance(index, int):
+        return (index,)
+    return index
+
+
+@contextmanager
+def add_var_domain_constraints(model: ConcreteModel) -> Iterator[None]:
+    vars = extract(model, _GeneralVarData)
+    constraints = [
+        constraint
+        for var in vars
+        if (constraint := _get_var_domain_constraint(var)) is not None
+    ]
+    if len(constraints) == 0:
+        yield
+        return
+    model.var_domain_constraints = pyo.ConstraintList()
+    for constraint in constraints:
+        model.var_domain_constraints.add(constraint)
+    yield
+    model.del_component("var_domain_constraints")
+
+
+def _get_var_domain_constraint(var: _GeneralVarData) -> Optional[ExpressionBase]:
+    bounds = var.bounds
+    if (
+        type(bounds) is not tuple
+        or len(bounds) != 2
+        or not all(isinstance(bounds[idx], int) for idx in (0, 1))
+    ):
+        raise ClassiqValueError(
+            f"Missing bounds for variable {var.local_name}. Expected both lower and "
+            f"upper bounds, got {bounds}"
+        )
+    lb, ub = bounds
+    if ub < lb:
+        raise ClassiqValueError(
+            f"Illegal bounds for variable {var.local_name}. The upper bound ({ub}) is "
+            f"lesser than the lower bound ({lb})"
+        )
+    ub_norm = ub - lb + 1
+    if ub_norm & (ub_norm - 1) == 0:
+        return None
+    return var <= ub

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -33,7 +33,7 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
     _pauli_terms_to_qmod,
 )
 from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig
-from classiq.qmod.builtins.functions import qaoa_penalty
+from classiq.open_library.functions.qaoa_penalty import qaoa_penalty
 
 
 def construct_combi_opt_py_model(

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -17,11 +17,13 @@ from classiq.applications.combinatorial_helpers.combinatorial_problem_utils impo
     pyo_model_to_qmod_problem,
 )
 from classiq.execution import ExecutionSession
+from classiq.open_library.functions.utility_functions import (
+    apply_to_all,
+    hadamard_transform,
+)
 from classiq.qmod.builtins.functions import (
     RX,
     allocate,
-    apply_to_all,
-    hadamard_transform,
 )
 from classiq.qmod.builtins.operations import phase, repeat
 from classiq.qmod.cparam import CReal

classiq/applications/grover/grover_model_constructor.py

@@ -19,7 +19,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 
 from classiq import RegisterUserInput
-from classiq.qmod.builtins.functions.grover import grover_search, phase_oracle
+from classiq.open_library.functions.grover import grover_search, phase_oracle
 
 _OUTPUT_VARIABLE_NAME = "result"
 

classiq/applications/libraries/qmci_library.py

@@ -1,4 +1,5 @@
-from classiq.qmod.builtins.functions import Z, amplitude_estimation
+from classiq.open_library.functions.amplitude_estimation import amplitude_estimation
+from classiq.qmod.builtins.functions import Z
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable