classiq 0.89.0__py3-none-any.whl → 0.90.0__py3-none-any.whl

classiq/__init__.py

@@ -52,6 +52,7 @@ from classiq.qmod import *  # noqa: F403
 from classiq.qmod import __all__ as _qmod_all
 from classiq.quantum_program import ExecutionParams, assign_parameters, transpile
 from classiq.synthesis import (
+    qasm_to_qmod,
     quantum_program_from_qasm,
     quantum_program_from_qasm_async,
     set_constraints,

classiq/_internals/api_wrapper.py

@@ -9,7 +9,7 @@ import classiq.interface.executor.execution_result
 import classiq.interface.pyomo_extension
 from classiq.interface.analyzer import analysis_params, result as analysis_result
 from classiq.interface.analyzer.analysis_params import AnalysisRBParams
-from classiq.interface.analyzer.result import GraphStatus
+from classiq.interface.analyzer.result import GraphStatus, QmodCode
 from classiq.interface.chemistry import ground_state_problem, operator
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqAPIError, ClassiqValueError
@@ -23,13 +23,14 @@ from classiq.interface.execution.iqcc import (
     IQCCProbeAuthResponse,
 )
 from classiq.interface.execution.primitives import PrimitivesInput
-from classiq.interface.executor import execution_request, quantum_program_params
+from classiq.interface.executor import execution_request
 from classiq.interface.executor.quantum_program_params import (
     ParameterAssignmentsParams,
     TranspilationParams,
 )
 from classiq.interface.executor.user_budget import UserBudget
 from classiq.interface.generator import quantum_program as generator_result
+from classiq.interface.generator.preferences.qasm_to_qmod_params import QasmToQmodParams
 from classiq.interface.hardware import HardwareInformation, Provider
 from classiq.interface.ide.visual_model import ProgramVisualModel
 from classiq.interface.jobs import JobDescription, JobID, JSONObject
@@ -169,6 +170,19 @@ class ApiWrapper:
             http_client,
         )
 
+    @classmethod
+    async def call_qasm_to_qmod_task(
+        cls,
+        params: QasmToQmodParams,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> QmodCode:
+        return await cls._call_job_and_poll(
+            routes.QASM_TO_QMOD_FULL_PATH,
+            params,
+            QmodCode,
+            http_client,
+        )
+
     @classmethod
     async def call_get_visual_model(
         cls,
@@ -239,36 +253,6 @@ class ApiWrapper:
             exclude={"debug_info"},
         )
 
-    @classmethod
-    async def transpile_quantum_program(
-        cls,
-        params: quantum_program_params.TranspilationParams,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> generator_result.QuantumProgram:
-        data = await cls._call_task_pydantic(
-            http_method=HTTPMethod.POST,
-            url=routes.TRANSPILATION_FULL_PATH,
-            model=params,
-            http_client=http_client,
-            exclude={"debug_info"},
-        )
-        return generator_result.QuantumProgram.model_validate(data)
-
-    @classmethod
-    async def assign_parameters_quantum_program(
-        cls,
-        params: quantum_program_params.ParameterAssignmentsParams,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> generator_result.QuantumProgram:
-        data = await cls._call_task_pydantic(
-            http_method=HTTPMethod.POST,
-            url=routes.ASSIGN_PARAMETERS_FULL_PATH,
-            model=params,
-            http_client=http_client,
-            exclude={"debug_info"},
-        )
-        return generator_result.QuantumProgram.model_validate(data)
-
     @classmethod
     async def call_execute_execution_input(
         cls,

classiq/analyzer/show_interactive_hack.py

@@ -1,3 +1,4 @@
+import json
 import os
 import subprocess
 import webbrowser
@@ -19,6 +20,7 @@ VisualizationRenderer = Callable[[DataID, QuantumProgram], Awaitable[None]]
 
 # In Classiq Studio (openvscode env) we use this command to open files
 VSCODE_COMMAND = "code"
+MODEL_SIZE_THRESHOLD = 0.5 * 1024 * 1024  # 0.5MiB
 
 
 def is_classiq_studio() -> bool:
@@ -54,15 +56,37 @@ async def editor_renderer(data_id: DataID, circuit: QuantumProgram) -> None:
     subprocess.run([VSCODE_COMMAND, file.name])
 
 
+def is_large_file_content(value: str) -> bool:
+    if len(value) > MODEL_SIZE_THRESHOLD:
+        # Skip encoding when it already exceeds the threshold
+        return True
+    return len(value.encode("utf-8", errors="ignore")) > MODEL_SIZE_THRESHOLD
+
+
 async def notebook_renderer(data_id: DataID, circuit: QuantumProgram) -> None:
     from IPython.display import display  # type: ignore[import]
 
     visual_model = await visualize_async(data_id)
     app_url = get_app_url(data_id, circuit)
+
+    # In case the visual model is large, pass it as transient data,
+    # so that it won't be saved into the notebook as cell output (performance concern).
+    #
+    # For the data argument, provide only "program_id", so the renderer could still
+    # retrieve visualization from the API (via extension host).
+    # This will happen on further notebook reload - when the transient data is already
+    # lost, but the cell hasn't yet been executed.
+    if is_large_file_content(visual_model):
+        data_payload = json.dumps({"program_id": data_id.id})
+        transient_payload = {"visual_model": visual_model}
+    else:
+        data_payload = visual_model
+        transient_payload = None
+
     display(
         {
             # Attempt to handle by notebook renderer from Classiq vscode extension
-            "application/vnd.classiq+qviz": visual_model,
+            "application/vnd.classiq+qviz": data_payload,
             # Fallback to IDE link display when no extension available.
             #  Shouldn't normally happen.
             #  Otherwise, is_classiq_studio detection is not correct.
@@ -72,6 +96,7 @@ async def notebook_renderer(data_id: DataID, circuit: QuantumProgram) -> None:
         metadata={
             "url": app_url,
         },
+        transient=transient_payload,
     )
 
 

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -1,3 +1,4 @@
+import warnings
 from collections.abc import Mapping
 from typing import Optional, cast
 
@@ -11,7 +12,7 @@ from classiq.interface.chemistry.ground_state_problem import (
     MoleculeProblem,
 )
 from classiq.interface.chemistry.molecule import Atom
-from classiq.interface.exceptions import ClassiqError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.function_params import IOName
 from classiq.interface.generator.functions.classical_type import (
@@ -454,7 +455,7 @@ def _get_chemistry_quantum_main(
     body.append(
         Allocate(
             size=Expression(
-                expr=f"get_field(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'), 'len')"
+                expr=f"{_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0].pauli.len"
             ),
             target=HandleBinding(name="qbv"),
         ),
@@ -502,6 +503,17 @@ def construct_chemistry_model(
     ansatz_parameters: AnsatzParameters,
     execution_parameters: ChemistryExecutionParameters,
 ) -> SerializedModel:
+    warnings.warn(
+        (
+            "The function `construct_chemistry_model` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
+
     chemistry_functions = [
         _get_chemistry_quantum_main(
             chemistry_problem,

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -240,12 +240,15 @@ def pyomo2qmod(
                 bounds_set = True
 
     constraint_exprs: list[sympy.Expr] = []
-
-    constraint_exprs.extend(
-        Pyomo2SympyVisitor(symbols_map).walk_expression(constraint_dict[key].expr)
-        for constraint_dict in pyo_model.component_objects(Constraint)
-        for key in constraint_dict
-    )
+    for constraint_dict in pyo_model.component_objects(Constraint):
+        for key in constraint_dict:
+            constraint_expr = Pyomo2SympyVisitor(symbols_map).walk_expression(
+                constraint_dict[key].expr
+            )
+            if constraint_expr is False:
+                ClassiqValueError(f"Constraint {constraint_dict[key]} is infeasible")
+            if constraint_expr is not True:
+                constraint_exprs.append(constraint_expr)
 
     pyo_objective: ScalarObjective = next(pyo_model.component_objects(Objective))
     objective_type_str = "Max" if pyo_objective.sense == maximize else "Min"

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -101,13 +101,13 @@ def construct_combi_opt_py_model(
                 ],
                 body=[
                     Allocate(
-                        size=Expression(expr="get_field(target, 'len')"),
+                        size=Expression(expr="target.len"),
                         target=HandleBinding(name="target"),
                     ),
                     QuantumFunctionCall(
                         function="qaoa_penalty",
                         positional_args=[
-                            Expression(expr="get_field(target, 'len')"),
+                            Expression(expr="target.len"),
                             Expression(expr="params_list"),
                             Expression(expr="hamiltonian"),
                             HandleBinding(name="target"),

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -96,24 +96,32 @@ class CombinatorialProblem:
         execution_preferences: Optional[ExecutionPreferences] = None,
         maxiter: int = 20,
         quantile: float = 1.0,
+        initial_params: Optional[list[float]] = None,
     ) -> list[float]:
         if self.qprog_ is None:
             self.get_qprog()
         _es = ExecutionSession(
             self.qprog_, execution_preferences  # type:ignore[arg-type]
         )
-        initial_params = (
-            np.concatenate(
-                (
-                    np.linspace(1 / self.num_layers_, 1, self.num_layers_),
-                    np.linspace(1, 1 / self.num_layers_, self.num_layers_),
+        if initial_params is not None:
+            assert (
+                len(initial_params) == 2 * self.num_layers_
+            ), "inital_params should be twice the size of the number of layers"
+            initial_params = np.array(initial_params)  # type:ignore[assignment]
+        else:
+            initial_params = (
+                np.concatenate(
+                    (
+                        np.linspace(1 / self.num_layers_, 1, self.num_layers_),
+                        np.linspace(1, 1 / self.num_layers_, self.num_layers_),
+                    )
                 )
+                * math.pi
             )
-            * math.pi
-        )
+
         result = _es.minimize(
             lambda v: self.cost_func(v),  # type:ignore[arg-type]
-            {"params": initial_params.tolist()},
+            {"params": initial_params.tolist()},  # type:ignore[union-attr]
             maxiter,
             quantile,
         )

classiq/evaluators/classical_expression.py

@@ -1,53 +1,75 @@
-from typing import get_args
+import ast
+from enum import IntEnum
+from typing import Any
+
+import sympy
 
-from classiq.interface.generator.expressions.evaluated_expression import (
-    EvaluatedExpression,
-)
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.expression_types import ExpressionValue
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
 )
-from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.generator.expressions.proxies.classical.utils import (
+    get_proxy_type,
+)
+from classiq.interface.generator.functions.classical_type import ClassicalArray, Integer
 
-from classiq.evaluators.expression_evaluator import evaluate
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_bwc import (
+    QmodExpressionBwc,
+)
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_evaluator import (
+    evaluate_qmod_expression,
+)
+from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.scope import (
-    ClassicalSymbol,
+    ClassicalVariable,
     Evaluated,
-    QuantumSymbol,
+    QuantumVariable,
     Scope,
 )
+from classiq.qmod.model_state_container import QMODULE
 
 
-def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
-    all_symbols = scope.items()
-    locals_dict = (
-        {
-            name: EvaluatedExpression(value=evaluated.value)
-            for name, evaluated in all_symbols
-            if isinstance(evaluated.value, get_args(ExpressionValue))
-        }
-        | {
-            name: EvaluatedExpression(
-                value=(
-                    evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
-                    if evaluated.value.quantum_type.is_evaluated
-                    else AnyClassicalValue(name)
-                )
-            )
-            for name, evaluated in all_symbols
-            if isinstance(evaluated.value, QuantumSymbol)
-        }
-        | {
-            name: EvaluatedExpression(
-                value=evaluated.value.classical_type.get_classical_proxy(
-                    HandleBinding(name=name)
-                )
+def process_scope_val(val: Any) -> Any:
+    if isinstance(val, list):
+        if len(val) > 0 and isinstance(val[0], FunctionClosure):
+            return ClassicalArray(
+                element_type=Integer(), length=Expression(expr=str(len(val)))
             )
-            for name, evaluated in all_symbols
-            if isinstance(evaluated.value, ClassicalSymbol)
-        }
-    )
+        return val
+    if isinstance(val, (int, float, bool, IntEnum, QmodStructInstance)):
+        return val
+    if isinstance(val, ClassicalProxy):
+        return get_proxy_type(val)
+    if isinstance(val, ClassicalVariable):
+        return val.classical_type
+    if isinstance(val, QuantumVariable):
+        return val.quantum_type
+    if isinstance(val, QmodAnnotatedExpression):
+        return val.get_type(val.root)
+    if isinstance(val, sympy.Basic):
+        return val
+    return None
 
-    ret = evaluate(expr, locals_dict)
-    return Evaluated(value=ret.value)
+
+def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
+    if expr.is_evaluated():
+        return Evaluated(value=expr.value.value)
+    expr_ast = ast.parse(expr.expr)
+    expr_ast = QmodExpressionBwc().visit(expr_ast)
+    expr_val = evaluate_qmod_expression(
+        ast.unparse(expr_ast),
+        classical_struct_declarations=list(QMODULE.type_decls.values()),
+        enum_declarations=list(QMODULE.enum_decls.values()),
+        scope={
+            name: processed_val
+            for name, val in scope.items()
+            if (processed_val := process_scope_val(val.value)) is not None
+        },
+    )
+    if expr_val.has_value(expr_val.root):
+        expr_val = expr_val.get_value(expr_val.root)
+    return Evaluated(value=expr_val)

classiq/evaluators/control.py

@@ -1,61 +1,55 @@
-from typing import Any
-
-from sympy import Equality
-from sympy.core.numbers import Number
+import ast
+from typing import cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.arith.argument_utils import (
     unsigned_integer_interpretation,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
-    QmodQNumProxy,
-    QmodQScalarProxy,
-    QmodSizedProxy,
-)
-
-CONTROL_INOUT_NAME = "ctrl"
+from classiq.interface.model.quantum_type import QuantumScalar
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import is_classical_type
+from classiq.model_expansions.scope import QuantumSymbol
 
-def type_name(obj: Any) -> str:
-    if isinstance(obj, QmodSizedProxy):
-        return obj.type_name
-    return type(obj).__name__
+CONTROL_INOUT_NAME = "ctrl"
 
 
-def resolve_num_condition(condition: Equality) -> tuple[QmodSizedProxy, str]:
-    ctrl, ctrl_val = condition.args
-    if isinstance(ctrl, Number) and isinstance(ctrl_val, QmodQScalarProxy):
+def resolve_num_condition(
+    condition: QmodAnnotatedExpression,
+) -> tuple[QuantumSymbol, str]:
+    expr_ast = cast(ast.Compare, condition.root)
+    ctrl, ctrl_val = expr_ast.left, expr_ast.comparators[0]
+    if is_classical_type(condition.get_type(ctrl)):
         ctrl, ctrl_val = ctrl_val, ctrl
-    if not isinstance(ctrl, QmodSizedProxy) or not (isinstance(ctrl_val, Number)):
-        _raise_numeric_condition_error(ctrl, ctrl_val)
-    return ctrl, _calculate_ctrl_state(ctrl, float(ctrl_val))
+    ctrl_sym = QuantumSymbol(
+        handle=condition.get_var(ctrl), quantum_type=condition.get_quantum_type(ctrl)
+    )
+    return ctrl_sym, _calculate_ctrl_state(
+        ctrl_sym, float(condition.get_value(ctrl_val))
+    )
 
 
-def _calculate_ctrl_state(ctrl: QmodSizedProxy, ctrl_val: float) -> str:
-    is_signed, fraction_places = _get_numeric_attributes(ctrl)
+def _calculate_ctrl_state(ctrl: QuantumSymbol, ctrl_val: float) -> str:
+    ctrl_type = cast(QuantumScalar, ctrl.quantum_type)
+    is_signed = ctrl_type.sign_value
+    fraction_places = ctrl_type.fraction_digits_value
 
     reg = RegisterArithmeticInfo(
-        size=ctrl.size, is_signed=is_signed, fraction_places=fraction_places
+        size=ctrl.quantum_type.size_in_bits,
+        is_signed=is_signed,
+        fraction_places=fraction_places,
     )
     uint_ctrl_val = unsigned_integer_interpretation(ctrl_val, reg)
 
     _validate_control_value_sign(ctrl, ctrl_val, is_signed)
     _validate_control_var_qubits(ctrl, uint_ctrl_val, fraction_places, ctrl_val)
 
-    return _to_twos_complement(uint_ctrl_val, ctrl.size)
-
-
-def _get_numeric_attributes(ctrl: QmodSizedProxy) -> tuple[bool, int]:
-    return (
-        (ctrl.is_signed, ctrl.fraction_digits)
-        if isinstance(ctrl, QmodQNumProxy)
-        else (False, 0)
-    )
+    return _to_twos_complement(uint_ctrl_val, ctrl.quantum_type.size_in_bits)
 
 
 def _validate_control_value_sign(
-    ctrl: QmodSizedProxy, ctrl_val: float, is_signed: bool
+    ctrl: QuantumSymbol, ctrl_val: float, is_signed: bool
 ) -> None:
     if not is_signed and ctrl_val < 0:
         raise ClassiqExpansionError(
@@ -65,7 +59,7 @@ def _validate_control_value_sign(
 
 
 def _validate_control_var_qubits(
-    ctrl: QmodSizedProxy,
+    ctrl: QuantumSymbol,
     ctrl_val: int,
     fraction_places: int,
     orig_ctrl_val: float,
@@ -74,28 +68,13 @@ def _validate_control_var_qubits(
     fraction_places_message = (
         f" with {fraction_places} fraction digits" if fraction_places else ""
     )
-    if ctrl.size < required_qubits:
+    if ctrl.quantum_type.size_in_bits < required_qubits:
         raise ClassiqExpansionError(
-            f"Variable {str(ctrl)!r} has {ctrl.size} qubits{fraction_places_message} but control value "
+            f"Variable {str(ctrl)!r} has {ctrl.quantum_type.size_in_bits} qubits{fraction_places_message} but control value "
             f"{str(orig_ctrl_val if fraction_places else int(orig_ctrl_val))!r} requires at least {required_qubits} qubits{fraction_places_message}"
         )
 
 
-def _raise_numeric_condition_error(ctrl: Any, ctrl_val: Any) -> None:
-    message = (
-        "Control condition must be of the form '<quantum-variable> == "
-        "<classical-number-expression>' or vice versa. "
-    )
-    prefix = f"Neither {ctrl!r} (type {type_name(ctrl)}) or {ctrl_val!r} (type {type_name(ctrl_val)}) is a "
-    if not isinstance(ctrl, QmodSizedProxy) and not isinstance(
-        ctrl_val, QmodSizedProxy
-    ):
-        message += prefix + "quantum variable."
-    elif not isinstance(ctrl, Number) and not isinstance(ctrl_val, Number):
-        message += prefix + "classical number."
-    raise ClassiqExpansionError(message)
-
-
 def _min_unsigned_bit_length(number: int) -> int:
     if number < 0:
         raise ClassiqExpansionError(

classiq/evaluators/expression_evaluator.py

@@ -20,10 +20,12 @@ from classiq.interface.generator.expressions.sympy_supported_expressions import
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
 
+from classiq.evaluators.classical_expression import evaluate_classical_expression
 from classiq.model_expansions.atomic_expression_functions_defs import (
     ATOMIC_EXPRESSION_FUNCTIONS,
     qmod_val_to_python,
 )
+from classiq.model_expansions.scope import Evaluated, Scope
 from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
     translate_to_sympy,
 )
@@ -33,10 +35,12 @@ from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.model_state_container import QMODULE
 
 
-def evaluate_constants(constants: list[Constant]) -> dict[str, EvaluatedExpression]:
-    result: dict[str, EvaluatedExpression] = {}
+def evaluate_constants(constants: list[Constant]) -> Scope:
+    result = Scope()
     for constant in constants:
-        result[constant.name] = evaluate(constant.value, result)
+        expr_val = evaluate_classical_expression(constant.value, result).value
+        result[constant.name] = Evaluated(value=expr_val)
+
     return result
 
 
@@ -69,7 +73,7 @@ def evaluate(
     if val is not None:
         return EvaluatedExpression(value=val)
 
-    model_locals: dict[str, ExpressionValue] = {}
+    model_locals: dict[str, Any] = {}
     model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
     model_locals.update(
         {