classiq 0.75.0__py3-none-any.whl → 0.77.0__py3-none-any.whl

classiq/qmod/quantum_expandable.py

@@ -28,6 +28,7 @@ from classiq.interface.generator.functions.concrete_types import (
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
 )
+from classiq.interface.model.handle_binding import GeneralHandle, HandlesList
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_call import (
     ArgValue,
@@ -52,6 +53,7 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.interface.source_reference import SourceReference
 
 from classiq.qmod.generative import generative_mode_context, is_generative_mode
+from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import (
@@ -84,6 +86,11 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
         self._py_callable: Callable = py_callable
         self._body: list[QuantumStatement] = list()
 
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, QExpandable) and self._py_callable is other._py_callable
+        )
+
     @property
     def body(self) -> list[QuantumStatement]:
         return self._body
@@ -317,8 +324,10 @@ def prepare_arg(
 def prepare_arg(
     arg_decl: AnonPositionalArg, val: Any, func_name: Optional[str], param_name: str
 ) -> ArgValue:
-    from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc
+    from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc, QFunc
 
+    if get_global_declarative_switch() and isinstance(val, GenerativeQFunc):
+        val = QFunc(val._py_callable)
     if isinstance(val, BaseQFunc):
         val.add_function_dependencies()
     if isinstance(val, GenerativeQFunc):
@@ -330,6 +339,9 @@ def prepare_arg(
         _validate_classical_arg(val, arg_decl, func_name)
         return Expression(expr=qmod_val_to_expr_str(val))
     elif isinstance(arg_decl, AnonPortDeclaration):
+        handles_list = _try_preparing_handles_list(val)
+        if handles_list is not None:
+            return handles_list
         if not isinstance(val, QVar):
             func_name_message = (
                 "" if func_name is None else f" of function {func_name!r}"
@@ -505,3 +517,19 @@ def _is_legal_iterable_element(arg: Any) -> bool:
     if isinstance(arg, Iterable):
         return all(_is_legal_iterable_element(e) for e in arg)
     return True
+
+
+def _try_preparing_handles_list(val: Any) -> Optional[HandlesList]:
+    if not isinstance(val, list):
+        return None
+    items = [
+        (
+            item.get_handle_binding()
+            if isinstance(item, QVar)
+            else _try_preparing_handles_list(item)
+        )
+        for item in val
+    ]
+    if any(item is None for item in items):
+        return None
+    return HandlesList(handles=cast(list[GeneralHandle], items))

classiq/qmod/quantum_function.py

@@ -14,7 +14,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
-from classiq.interface.model.model import Model
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
@@ -26,11 +26,13 @@ from classiq.qmod.classical_function import CFunc
 from classiq.qmod.cparam import CParamAbstract
 from classiq.qmod.declaration_inferrer import infer_func_decl, is_qvar
 from classiq.qmod.generative import set_frontend_interpreter
+from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
+from classiq.qmod.semantics.validation.main_validation import validate_main_function
 from classiq.qmod.utilities import mangle_keyword
 
 
@@ -48,6 +50,18 @@ class BaseQFunc(QExpandable):
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         raise NotImplementedError
 
+    @property
+    def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        if type(self.func_decl) is NamedParamsQuantumFunctionDeclaration:
+            return self.func_decl
+        return NamedParamsQuantumFunctionDeclaration(
+            **{
+                k: v
+                for k, v in self.func_decl.model_dump().items()
+                if k in NamedParamsQuantumFunctionDeclaration.model_fields
+            }
+        )
+
     @property
     def _has_inputs(self) -> bool:
         return any(
@@ -89,22 +103,10 @@ class QFunc(BaseQFunc):
         super().__init__(py_callable, compilation_metadata)
         self.compilation_metadata: Optional[CompilationMetadata] = None
 
-    @property
-    def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
-        if type(self.func_decl) is NamedParamsQuantumFunctionDeclaration:
-            return self.func_decl
-        return NamedParamsQuantumFunctionDeclaration(
-            **{
-                k: v
-                for k, v in self.func_decl.model_dump().items()
-                if k in NamedParamsQuantumFunctionDeclaration.model_fields
-            }
-        )
-
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         name = self._py_callable.__name__
-        if hasattr(self._qmodule, "native_defs") and name in self._qmodule.native_defs:
+        if name in self._qmodule.native_defs:
             return self._qmodule.native_defs[name]
         return infer_func_decl(self._py_callable, qmodule=self._qmodule)
 
@@ -141,7 +143,10 @@ class QFunc(BaseQFunc):
             functions_compilation_metadata=self._qmodule.functions_compilation_metadata,
             **{key: value for key, value in model_extra_settings if value},
         )
-        if len(self._qmodule.generative_functions) > 0:
+        if (
+            not get_global_declarative_switch()
+            and len(self._qmodule.generative_functions) > 0
+        ):
             return self._create_generative_model(model)
         return model
 
@@ -232,12 +237,6 @@ class ExternalQFunc(QTerminalCallable):
     def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self.func_decl
 
-    def get_implementation(self) -> NativeFunctionDefinition:
-        model = QFunc(self._py_callable).create_model()
-        return [
-            func for func in model.functions if func.name == self._py_callable.__name__
-        ][0]
-
 
 class GenerativeQFunc(BaseQFunc):
     FRAME_DEPTH = 3
@@ -250,15 +249,25 @@ class GenerativeQFunc(BaseQFunc):
     ) -> None:
         super().__init__(py_callable, compilation_metadata)
         self._func_decl = func_decl
+        self._inferred_func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
-        if self._func_decl is None:
-            self._func_decl = infer_func_decl(self._py_callable, self._qmodule)
-        return self._func_decl
+        if self._func_decl is not None:
+            return self._func_decl
+        if self._inferred_func_decl is None:
+            self._inferred_func_decl = infer_func_decl(self._py_callable, self._qmodule)
+        return self._inferred_func_decl
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
-        self._qmodule.generative_functions[self.func_decl.name] = self
+        if get_global_declarative_switch():
+            return QFunc(self._py_callable)(*args, **kwargs)
+        if self.func_decl.name not in self._qmodule.generative_functions:
+            self._qmodule.generative_functions[self.func_decl.name] = self
+            if self._func_decl is None:
+                self._inferred_func_decl = infer_func_decl(
+                    self._py_callable, self._qmodule
+                )
         super().__call__(*args, **kwargs)
 
     def create_model(
@@ -268,6 +277,17 @@ class GenerativeQFunc(BaseQFunc):
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
     ) -> Model:
+        if get_global_declarative_switch():
+            return QFunc(self._py_callable).create_model(
+                constraints,
+                execution_preferences,
+                preferences,
+                classical_execution_function,
+            )
+        self._qmodule.reset()
+        if self.func_decl.name == MAIN_FUNCTION_NAME:
+            validate_main_function(self.func_decl)
+
         def _dec_main(*args: Any, **kwargs: Any) -> None:
             self(*args, **kwargs)
 

classiq/qmod/semantics/lambdas.py

@@ -1,3 +1,4 @@
+from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -14,8 +15,11 @@ def get_renamed_parameters(
     renamed_parameters: list[str] = []
     renamed_operands: dict[str, QuantumOperandDeclaration] = {}
     renamed_ports: list[PortDeclaration] = []
-    for idx, param in enumerate(lambda_func.func_decl.positional_arg_declarations):
-        param_name = lambda_func.pos_rename_params[idx]
+    for param, param_name in zip_strict(
+        lambda_func.func_decl.positional_arg_declarations,
+        lambda_func.pos_rename_params,
+        strict=False,
+    ):
         if isinstance(param, AnonClassicalParameterDeclaration):
             renamed_parameters.append(param_name)
         elif isinstance(param, AnonQuantumOperandDeclaration):

classiq/qmod/semantics/validation/main_validation.py

@@ -1,16 +1,22 @@
-from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.exceptions import ClassiqExpansionError, ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.quantum_function_declaration import PositionalArg
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+)
 
 from classiq import ClassicalParameterDeclaration
 
 
-def validate_main_function(func: NativeFunctionDefinition) -> None:
+def validate_main_function(func: NamedParamsQuantumFunctionDeclaration) -> None:
     for param in func.positional_arg_declarations:
         _validate_main_param(param)
 
@@ -18,6 +24,8 @@ def validate_main_function(func: NativeFunctionDefinition) -> None:
 def _validate_main_param(param: PositionalArg) -> None:
     if isinstance(param, ClassicalParameterDeclaration):
         _validate_main_classical_param_type(param.classical_type, param.name)
+    if isinstance(param, PortDeclaration):
+        _validate_main_quantum_param_type(param)
 
 
 def _validate_main_classical_param_type(
@@ -30,3 +38,8 @@ def _validate_main_classical_param_type(
         )
     if isinstance(param, ClassicalArray):
         _validate_main_classical_param_type(param.element_type, param_name)
+
+
+def _validate_main_quantum_param_type(param: PortDeclaration) -> None:
+    if param.direction != PortDeclarationDirection.Output:
+        raise ClassiqValueError("Function 'main' cannot declare quantum inputs")

classiq/qmod/symbolic.py

@@ -1,5 +1,4 @@
 import sys
-from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -12,6 +11,9 @@ from typing import (
 import numpy as np
 
 from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    subscript_to_str,
+)
 
 from classiq.qmod import model_state_container
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
@@ -24,6 +26,7 @@ from classiq.qmod.qmod_parameter import (
 )
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 pi = SymbolicExpr("pi", False)
 E = SymbolicExpr("E", False)
@@ -306,27 +309,13 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
     return symbolic_function(arr)
 
 
-def _subscript_to_str(index: Any) -> str:
-    if not isinstance(index, slice):
-        return str(index)
-    expr = ""
-    if index.start is not None:
-        expr += str(index.start)
-    expr += ":"
-    if index.stop is not None:
-        expr += str(index.stop)
-    if index.step is not None:
-        expr += f":{index.step}"
-    return expr
-
-
 def subscript(
-    array: Union[
-        Sequence[Union[float, CReal, CParamScalar]], CArray[CReal], np.ndarray
-    ],
+    array: Union[list, CArray[CReal], np.ndarray],
     index: Any,
 ) -> CParamScalar:
-    return CParamScalar(expr=f"{_unwrap_numpy(array)}[{_subscript_to_str(index)}]")
+    return CParamScalar(
+        expr=f"{qmod_val_to_expr_str(_unwrap_numpy(array))}[{subscript_to_str(index)}]"
+    )
 
 
 __all__ = [

classiq/qmod/symbolic_expr.py

@@ -177,3 +177,29 @@ class SymbolicEquality(SymbolicExpr):
         super().__init__(sym_expr._expr, sym_expr.is_quantum)
         self.lhs = lhs
         self.rhs = rhs
+
+
+class SymbolicSubscriptAndField(SymbolicExpr):
+    def __getattr__(self, item: str) -> SymbolicSubscriptAndField:
+        return SymbolicSubscriptAndField(f"{self}.{item}", is_quantum=self.is_quantum)
+
+    def __getitem__(self, item: Any) -> SymbolicExpr:
+        if isinstance(item, slice):
+            start = item.start
+            stop = item.stop
+            step = item.step
+            item_is_quantum = (
+                (isinstance(start, SymbolicExpr) and start.is_quantum)
+                or (isinstance(stop, SymbolicExpr) and stop.is_quantum)
+                or (isinstance(step, SymbolicExpr) and step.is_quantum)
+            )
+            start_str = "" if start is None else qmod_val_to_expr_str(start)
+            stop_str = "" if stop is None else qmod_val_to_expr_str(stop)
+            step_str = "" if step is None else qmod_val_to_expr_str(step)
+            item_str = f"{start_str}:{stop_str}:{step_str}"
+        else:
+            item_is_quantum = isinstance(item, SymbolicExpr) and item.is_quantum
+            item_str = qmod_val_to_expr_str(item)
+        return SymbolicSubscriptAndField(
+            f"{self}[{item_str}]", is_quantum=self.is_quantum or item_is_quantum
+        )

classiq/qmod/write_qmod.py

@@ -1,9 +1,10 @@
 import json
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Optional, Union
 
 from classiq.interface.model.model import Model, SerializedModel
 
+from classiq.qmod.global_declarative_switch import set_global_declarative_switch
 from classiq.qmod.native.pretty_printer import DSLPrettyPrinter
 from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
@@ -17,8 +18,7 @@ def write_qmod(
     name: str,
     directory: Optional[Path] = None,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
-    *args: Any,
-    **kwargs: Any,
+    symbolic_only: bool = True,
 ) -> None:
     """
     Creates a native Qmod file from a serialized model and outputs the synthesis options (Preferences and Constraints) to a file.
@@ -29,20 +29,15 @@ def write_qmod(
         name: The name to save the file by.
         directory: The directory to save the files in. If None, the current working directory is used.
         decimal_precision: The number of decimal places to use for numbers, set to 4 by default.
-        args: (placeholder)
-        kwargs: (placeholder)
+        symbolic_only: If True keep function definitions un-expanded and symbolic (note that Qmod functions with parameters of Python types are not supported in this mode)
 
     Returns:
         None
     """
-    if isinstance(model, (QFunc, GenerativeQFunc)):
-        model_obj = model.create_model()
-    else:
-        model_obj = Model.model_validate_json(model)
+    model_obj = prepare_write_qmod_model(model, symbolic_only)
     pretty_printed_model = DSLPrettyPrinter(decimal_precision=decimal_precision).visit(
         model_obj
     )
-
     synthesis_options = model_obj.model_dump(
         include={"constraints", "preferences"}, exclude_none=True
     )
@@ -58,3 +53,34 @@ def write_qmod(
         native_qmod_path = directory / native_qmod_path
 
     native_qmod_path.write_text(pretty_printed_model)
+
+
+def prepare_write_qmod_model(
+    model: Union[SerializedModel, QFunc, GenerativeQFunc], symbolic_only: bool
+) -> Model:
+    if isinstance(model, str) and hasattr(model, "entry_point") and symbolic_only:
+        model_obj = Model.model_validate_json(model)
+        with set_global_declarative_switch():
+            dec_model_obj = model.entry_point.create_model(
+                constraints=model_obj.constraints,
+                execution_preferences=model_obj.execution_preferences,
+                preferences=model_obj.preferences,
+            )
+        dec_constant_names = {const.name for const in dec_model_obj.constants}
+        all_constants = dec_model_obj.constants + [
+            const
+            for const in model_obj.constants
+            if const.name not in dec_constant_names
+        ]
+        return dec_model_obj.model_copy(
+            update={
+                "constants": all_constants,
+                "classical_execution_code": model_obj.classical_execution_code,
+            }
+        )
+    if isinstance(model, (QFunc, GenerativeQFunc)):
+        if symbolic_only:
+            with set_global_declarative_switch():
+                return model.create_model()
+        return model.create_model()
+    return Model.model_validate_json(model)

classiq/synthesis.py

@@ -1,6 +1,4 @@
-from typing import Any, NewType, Optional, Union
-
-import pydantic
+from typing import Any, Optional, Union
 
 from classiq.interface.analyzer.result import QasmCode
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
@@ -12,43 +10,34 @@ from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model, SerializedM
 from classiq import QuantumProgram
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
-
-SerializedQuantumProgram = NewType("SerializedQuantumProgram", str)
+from classiq.qmod.create_model_function import add_entry_point
+from classiq.qmod.quantum_function import BaseQFunc
 
-CANT_PARSE_QUANTUM_PROGRAM_MSG = (
-    "Can not parse quantum_program into GeneratedCircuit, \n"
-)
+SerializedQuantumProgram = QuantumProgram
 
 
-def show(quantum_program: SerializedQuantumProgram, display_url: bool = True) -> None:
+def show(quantum_program: QuantumProgram, display_url: bool = True) -> None:
     """
     Displays the interactive representation of the quantum program in the Classiq IDE.
 
     Args:
         quantum_program:
-            The serialized quantum program to be displayed.
+            The quantum program to be displayed.
         display_url:
             Whether to print the url
 
     Links:
         [Visualization tool](https://docs.classiq.io/latest/reference-manual/analyzer/quantum-program-visualization-tool/)
     """
-    try:
-        circuit = QuantumProgram.model_validate_json(quantum_program)
-    except pydantic.ValidationError as exc:
-        raise ClassiqValueError(CANT_PARSE_QUANTUM_PROGRAM_MSG) from exc
-    circuit.show()  # type: ignore[attr-defined]
+    QuantumProgram.model_validate(quantum_program)
+    quantum_program.show()  # type: ignore[attr-defined]
 
 
-async def quantum_program_from_qasm_async(qasm: str) -> SerializedQuantumProgram:
-    quantum_program = await ApiWrapper.get_generated_circuit_from_qasm(
-        QasmCode(code=qasm)
-    )
-    return SerializedQuantumProgram(quantum_program.model_dump_json())
+async def quantum_program_from_qasm_async(qasm: str) -> QuantumProgram:
+    return await ApiWrapper.get_generated_circuit_from_qasm(QasmCode(code=qasm))
 
 
-def quantum_program_from_qasm(qasm: str) -> SerializedQuantumProgram:
+def quantum_program_from_qasm(qasm: str) -> QuantumProgram:
     """
     generate a quantum program from a QASM file.
 
@@ -56,25 +45,24 @@ def quantum_program_from_qasm(qasm: str) -> SerializedQuantumProgram:
         qasm: A QASM2/3 string.
 
     Returns:
-        SerializedQuantumProgram: Quantum program serialized as a string. (See: QuantumProgram)
+        QuantumProgram: Quantum program. (See: QuantumProgram)
     """
     return async_utils.run(quantum_program_from_qasm_async(qasm))
 
 
 async def synthesize_async(
     serialized_model: SerializedModel,
-) -> SerializedQuantumProgram:
+) -> QuantumProgram:
     model = Model.model_validate_json(serialized_model)
-    quantum_program = await ApiWrapper.call_generation_task(model)
-    return SerializedQuantumProgram(quantum_program.model_dump_json(indent=2))
+    return await ApiWrapper.call_generation_task(model)
 
 
 def synthesize(
-    model: Union[SerializedModel, QFunc, GenerativeQFunc],
+    model: Union[SerializedModel, BaseQFunc],
     auto_show: bool = False,
     constraints: Optional[Constraints] = None,
     preferences: Optional[Preferences] = None,
-) -> SerializedQuantumProgram:
+) -> QuantumProgram:
     """
     Synthesize a model with the Classiq engine to receive a quantum program.
     [More details](https://docs.classiq.io/latest/reference-manual/synthesis/)
@@ -86,9 +74,9 @@ def synthesize(
         preferences: Preferences for the synthesis of the model. See Preferences (Optional).
 
     Returns:
-        SerializedQuantumProgram: Quantum program serialized as a string. (See: QuantumProgram)
+        QuantumProgram: Quantum program. (See: QuantumProgram)
     """
-    if isinstance(model, (QFunc, GenerativeQFunc)):
+    if isinstance(model, BaseQFunc):
         func_name = model._py_callable.__name__
         if func_name != MAIN_FUNCTION_NAME:
             raise ClassiqError(
@@ -129,7 +117,7 @@ def set_preferences(
 
     model = Model.model_validate_json(serialized_model)
     model.preferences = preferences
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def update_preferences(
@@ -149,7 +137,7 @@ def update_preferences(
 
     for key, value in kwargs.items():
         setattr(model.preferences, key, value)
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def set_constraints(
@@ -177,7 +165,7 @@ def set_constraints(
 
     model = Model.model_validate_json(serialized_model)
     model.constraints = constraints
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def update_constraints(
@@ -197,7 +185,7 @@ def update_constraints(
 
     for key, value in kwargs.items():
         setattr(model.constraints, key, value)
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def set_execution_preferences(
@@ -226,7 +214,7 @@ def set_execution_preferences(
 
     model = Model.model_validate_json(serialized_model)
     model.execution_preferences = execution_preferences
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 def update_execution_preferences(
@@ -247,12 +235,11 @@ def update_execution_preferences(
     for key, value in kwargs.items():
         setattr(model.execution_preferences, key, value)
 
-    return model.get_model()
+    return add_entry_point(model.get_model(), serialized_model)
 
 
 __all__ = [
     "SerializedModel",
-    "SerializedQuantumProgram",
     "set_constraints",
     "set_execution_preferences",
     "set_preferences",

classiq/visualization.py

@@ -0,0 +1,35 @@
+from typing import NewType
+
+from classiq.interface.analyzer.result import DataID
+from classiq.interface.exceptions import ClassiqAPIError
+
+from classiq._internals import async_utils
+from classiq._internals.api_wrapper import ApiWrapper
+
+SerializedVisualModel = NewType("SerializedVisualModel", str)
+
+
+async def visualize_async(
+    data_id: DataID,
+) -> SerializedVisualModel:
+    try:
+        visual_model = await ApiWrapper.call_get_visual_model(data_id.id)
+    except ClassiqAPIError as error:
+        if error.status_code != 404:
+            raise error
+        analyzer_data = await ApiWrapper.get_analyzer_app_data(data_id)
+        visual_model = await ApiWrapper.call_visualization_task(analyzer_data)
+    return SerializedVisualModel(visual_model.model_dump_json(indent=2))
+
+
+def visualize(
+    data_id: DataID,
+) -> SerializedVisualModel:
+    result = async_utils.run(visualize_async(data_id))
+    return result
+
+
+__all__ = [
+    "SerializedVisualModel",
+    "visualize",
+]

{classiq-0.75.0.dist-info → classiq-0.77.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.75.0
+Version: 0.77.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL