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

classiq/_internals/api_wrapper.py

@@ -24,8 +24,10 @@ from classiq.interface.execution.iqcc import (
 )
 from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import execution_request
+from classiq.interface.executor.user_budget import UserBudget
 from classiq.interface.generator import quantum_program as generator_result
 from classiq.interface.hardware import HardwareInformation, Provider
+from classiq.interface.ide.visual_model import ProgramVisualModel
 from classiq.interface.jobs import JobDescription, JobID, JSONObject
 from classiq.interface.model.model import Model
 from classiq.interface.server import routes
@@ -122,6 +124,31 @@ class ApiWrapper:
         )
         return _parse_job_response(result, generator_result.QuantumProgram)
 
+    @classmethod
+    async def call_get_visual_model(
+        cls,
+        program_id: str,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> ProgramVisualModel:
+        raw_result = await cls._call_task(
+            http_method=HTTPMethod.GET,
+            url=f"{routes.ANALYZER_GET_VISUAL_MODEL_FULL_PATH}/{program_id}",
+            http_client=http_client,
+        )
+        return ProgramVisualModel.model_validate(raw_result)
+
+    @classmethod
+    async def call_visualization_task(
+        cls,
+        circuit: generator_result.QuantumProgram,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> ProgramVisualModel:
+        poller = JobPoller(base_url=routes.TASKS_VISUAL_MODEL_FULL_PATH)
+        result = await poller.run_pydantic(
+            circuit, timeout_sec=None, http_client=http_client
+        )
+        return _parse_job_response(result, ProgramVisualModel)
+
     @classmethod
     async def call_create_execution_session(
         cls,
@@ -488,3 +515,12 @@ class ApiWrapper:
             http_client=http_client,
         )
         return IQCCAuthItemsDetails.model_validate(response)
+
+    @classmethod
+    async def call_get_all_budgets(cls) -> list[UserBudget]:
+        data = await client().call_api(
+            http_method=HTTPMethod.GET,
+            url=routes.USER_BUDGETS_FULL_PATH,
+        )
+
+        return [UserBudget.model_validate(info) for info in data]

classiq/analyzer/show_interactive_hack.py

@@ -1,4 +1,6 @@
+import os
 import webbrowser
+from typing import Callable, Union
 from urllib.parse import urljoin
 
 from classiq.interface.exceptions import ClassiqAnalyzerVisualizationError
@@ -6,8 +8,54 @@ from classiq.interface.generator.model.preferences.preferences import QuantumFor
 from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq._internals.async_utils import syncify_function
+from classiq._internals.async_utils import is_notebook, syncify_function
 from classiq.analyzer.url_utils import circuit_page_uri, client_ide_base_url
+from classiq.visualization import (
+    SerializedVisualModel,
+    visualize_async,
+)
+
+VisualizationRenderer = Callable[[SerializedVisualModel, str], None]
+
+
+def is_classiq_studio() -> bool:
+    # Perhaps in the future we should add a dedicated unique environment var
+    #  but so far should work just fine.
+    return bool(os.environ.get("OPENVSCODE"))
+
+
+def get_visualization_renderer() -> Union[VisualizationRenderer, None]:
+    # Skip non-interactive environments
+    if not is_notebook():
+        return None
+    # Ideally, we should check if a notebook renderer is available to handle custom
+    #  mime type, or at least if the Classiq vscode extension is installed.
+    #  There's no such capabilities in IPython, so we make assumption from a fact that
+    #  it's a Classiq Studio env.
+    #  (Studio always has the extension, and the extension always supports mime type).
+    if not is_classiq_studio():
+        return None
+    try:
+        # Must be available since is_notebook passed
+        from IPython.display import display  # type: ignore[import]
+    except ImportError:
+        # Just in case it failed anyway, fallback to IDE link open
+        return None
+
+    def renderer(visual_model: SerializedVisualModel, fallback: str) -> None:
+        display(
+            {
+                # Attempt to handle by notebook renderer from Classiq vscode extension
+                "application/vnd.classiq+qviz": visual_model,
+                # Fallback to IDE link display when no extension available.
+                #  Shouldn't normally happen.
+                #  Otherwise, is_classiq_studio detection is not correct.
+                "text/plain": fallback,
+            },
+            raw=True,
+        )
+
+    return renderer
 
 
 async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -> None:
@@ -22,9 +70,17 @@ async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -
         client_ide_base_url(),
         circuit_page_uri(circuit_id=circuit_dataid.id, circuit_version=circuit.version),
     )
+    link_label = f"Quantum program link: {app_url}"
+
+    renderer = get_visualization_renderer()
+    if renderer:
+        # Visualize in-place
+        visual_model = await visualize_async(circuit_dataid)
+        renderer(visual_model, link_label)
+        return
 
     if display_url:
-        print(f"Quantum program link: {app_url}")  # noqa: T201
+        print(link_label)  # noqa: T201
 
     webbrowser.open_new_tab(app_url)
 

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -21,6 +21,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -52,6 +53,7 @@ from classiq.qmod.builtins.structs import (
     MoleculeProblem as QmodMoleculeProblem,
     Position as QmodPosition,
 )
+from classiq.qmod.global_declarative_switch import set_global_declarative_switch
 from classiq.qmod.utilities import qmod_val_to_expr_str
 
 # isort: split
@@ -59,6 +61,11 @@ from classiq.qmod.utilities import qmod_val_to_expr_str
 # This import causes a circular import if done earlier. We use isort: split to avoid it
 from classiq.open_library.functions.hea import full_hea
 
+with set_global_declarative_switch():
+    _FULL_HEA = cast(
+        NativeFunctionDefinition, full_hea.create_model().function_dict["full_hea"]
+    )
+
 _LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {
     "+": "PLUS",
     "-": "MINUS",
@@ -464,7 +471,13 @@ def _get_chemistry_quantum_main(
         positional_arg_declarations=_get_chemistry_quantum_main_params(
             ansatz_parameters
         )
-        + [PortDeclaration(name="qbv", direction=PortDeclarationDirection.Output)],
+        + [
+            PortDeclaration(
+                name="qbv",
+                direction=PortDeclarationDirection.Output,
+                type_qualifier=TypeQualifier.Quantum,
+            )
+        ],
         body=body,
     )
 
@@ -499,12 +512,7 @@ def construct_chemistry_model(
         )
     ]
     if isinstance(ansatz_parameters, HEAParameters):
-        chemistry_functions.append(
-            cast(
-                NativeFunctionDefinition,
-                full_hea.create_model().function_dict["full_hea"],
-            )
-        )
+        chemistry_functions.append(_FULL_HEA)
     model = Model(
         functions=chemistry_functions,
         classical_execution_code=_get_chemistry_classical_code(

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -14,6 +14,7 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -35,6 +36,14 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
 )
 from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig
 from classiq.open_library.functions.qaoa_penalty import qaoa_penalty
+from classiq.qmod.global_declarative_switch import set_global_declarative_switch
+
+with set_global_declarative_switch():
+    _LIBRARY_FUNCTIONS = [
+        f.model_dump()
+        for f in qaoa_penalty.create_model().functions
+        if f.name != "main"
+    ]
 
 
 def construct_combi_opt_py_model(
@@ -87,6 +96,7 @@ def construct_combi_opt_py_model(
                             length=Expression(expr=f"{len_hamiltonian}"),
                         ),
                         direction=PortDeclarationDirection.Output,
+                        type_qualifier=TypeQualifier.Quantum,
                     ),
                 ],
                 body=[
@@ -105,7 +115,7 @@ def construct_combi_opt_py_model(
                     ),
                 ],
             ),
-            *[f for f in qaoa_penalty.create_model().functions if f.name != "main"],
+            *_LIBRARY_FUNCTIONS,
         ],
         classical_execution_code=f"""
 vqe_result = vqe(

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -12,7 +12,7 @@ from classiq.interface.executor.execution_preferences import ExecutionPreference
 from classiq.interface.executor.result import ExecutionDetails
 from classiq.interface.model.model import SerializedModel
 
-from classiq import Constraints, Preferences
+from classiq import Constraints, Preferences, QuantumProgram
 from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
     pyo_model_to_qmod_problem,
 )
@@ -24,10 +24,11 @@ from classiq.open_library.functions.utility_functions import (
 from classiq.qmod.builtins.functions import RX
 from classiq.qmod.builtins.operations import allocate, phase, repeat
 from classiq.qmod.cparam import CReal
+from classiq.qmod.create_model_function import create_model
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import Output, QVar
-from classiq.synthesis import SerializedQuantumProgram, synthesize
+from classiq.synthesis import synthesize
 
 
 class CombinatorialProblem:
@@ -80,12 +81,12 @@ class CombinatorialProblem:
                 ],
             )
 
-        self.model_ = main.create_model(
-            constraints=constraints, preferences=preferences
-        ).get_model()  # type:ignore[assignment]
+        self.model_ = create_model(
+            main, constraints=constraints, preferences=preferences
+        )  # type:ignore[assignment]
         return self.model_  # type:ignore[return-value]
 
-    def get_qprog(self) -> SerializedQuantumProgram:
+    def get_qprog(self) -> QuantumProgram:
         if self.model_ is None:
             self.get_model()
         self.qprog_ = synthesize(self.model_)  # type:ignore[assignment,arg-type]
@@ -170,7 +171,7 @@ def execute_qaoa(
     num_layers: int,
     maxiter: int,
     execution_preferences: Optional[ExecutionPreferences] = None,
-) -> tuple[SerializedModel, SerializedQuantumProgram, ExecutionDetails]:
+) -> tuple[SerializedModel, QuantumProgram, ExecutionDetails]:
     """
     Implements a simple QAOA algorithm, including the creation and synthesis of the QAOA
     ansatz and the classical optimization loop.

classiq/applications/qnn/gradients/quantum_gradient.py

@@ -8,13 +8,12 @@ from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.qnn.circuit_utils import extract_parameters, validate_circuit
 from classiq.applications.qnn.types import ExecuteFunction, PostProcessFunction
-from classiq.synthesis import SerializedQuantumProgram
 
 
 class QuantumGradient(abc.ABC):
     def __init__(
         self,
-        quantum_program: SerializedQuantumProgram,
+        quantum_program: QuantumProgram,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
         *args: Any,
@@ -23,10 +22,9 @@ class QuantumGradient(abc.ABC):
         self._execute = execute
         self._post_process = post_process
 
-        circuit = QuantumProgram.model_validate_json(quantum_program)
-        validate_circuit(circuit)
+        validate_circuit(quantum_program)
         self._quantum_program = quantum_program
-        self._parameters_names = extract_parameters(circuit)
+        self._parameters_names = extract_parameters(quantum_program)
 
         self.execute = functools.partial(execute, quantum_program)
 

classiq/applications/qnn/gradients/simple_quantum_gradient.py

@@ -5,6 +5,7 @@ from typing import Any
 import torch
 from torch import Tensor
 
+from classiq import QuantumProgram
 from classiq.applications.qnn.circuit_utils import (
     batch_map_parameters,
     is_single_layer_circuit,
@@ -18,7 +19,6 @@ from classiq.applications.qnn.types import (
     Shape,
     TensorToArgumentsCallable,
 )
-from classiq.synthesis import SerializedQuantumProgram
 
 #
 # Types
@@ -66,7 +66,7 @@ def _differentiate_tensor(
 class SimpleQuantumGradient(QuantumGradient):
     def __init__(
         self,
-        quantum_program: SerializedQuantumProgram,
+        quantum_program: QuantumProgram,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
         epsilon: float = EPSILON,

classiq/applications/qnn/qlayer.py

@@ -13,6 +13,7 @@ from torch.nn.parameter import Parameter
 from classiq.interface.exceptions import ClassiqQNNError, ClassiqTorchError
 from classiq.interface.executor.execution_result import ResultsCollection
 
+from classiq import QuantumProgram
 from classiq.applications.qnn.circuit_utils import (
     extract_parameters,
     is_single_layer_circuit,
@@ -36,7 +37,6 @@ from classiq.applications.qnn.types import (
 )
 from classiq.execution import ExecutionSession
 from classiq.execution.qnn import _MAX_ARGUMENTS_SIZE, _execute_qnn_sample
-from classiq.synthesis import SerializedQuantumProgram
 
 
 class QLayerFunction(torch.autograd.Function):
@@ -45,7 +45,7 @@ class QLayerFunction(torch.autograd.Function):
         ctx: Any,
         inputs: Tensor,
         weights: Tensor,
-        quantum_program: SerializedQuantumProgram,
+        quantum_program: QuantumProgram,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
         epsilon: Optional[float] = EPSILON,
@@ -63,8 +63,7 @@ class QLayerFunction(torch.autograd.Function):
         """
         if epsilon is None:
             epsilon = EPSILON
-        circuit = Circuit.model_validate_json(quantum_program)
-        validate_circuit(circuit)
+        validate_circuit(quantum_program)
 
         # save for backward
         ctx.save_for_backward(inputs, weights)
@@ -82,7 +81,7 @@ class QLayerFunction(torch.autograd.Function):
             ctx.num_out_features, ctx.num_weights = weights.shape
 
         # Todo: avoid computing `_get_extracted_parameters` on every `forward`
-        extracted_parameters = extract_parameters(circuit)
+        extracted_parameters = extract_parameters(quantum_program)
 
         # Todo: avoid defining `convert_tensors_to_arguments` on every `forward`
         def convert_tensors_to_arguments(
@@ -141,11 +140,11 @@ class QLayerFunction(torch.autograd.Function):
         )
 
 
-CalcNumOutFeatures = Callable[[SerializedQuantumProgram], int]
+CalcNumOutFeatures = Callable[[QuantumProgram], int]
 
 
 def calc_num_out_features_single_output(
-    quantum_program: SerializedQuantumProgram,
+    quantum_program: QuantumProgram,
 ) -> int:
     return 1
 
@@ -156,7 +155,7 @@ class QLayer(nn.Module):
     @overload
     def __init__(
         self,
-        quantum_program: SerializedQuantumProgram,
+        quantum_program: QuantumProgram,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
         # Optional parameters:
@@ -169,7 +168,7 @@ class QLayer(nn.Module):
     @overload
     def __init__(
         self,
-        quantum_program: SerializedQuantumProgram,
+        quantum_program: QuantumProgram,
         post_process: PostProcessFunction,
         /,
         # Optional parameters:
@@ -181,12 +180,11 @@ class QLayer(nn.Module):
 
     def __init__(
         self,
-        quantum_program: SerializedQuantumProgram,
+        quantum_program: QuantumProgram,
         *args: Any,
         **kwargs: Any,
     ) -> None:
-        circuit = Circuit.model_validate_json(quantum_program)
-        validate_circuit(circuit)
+        validate_circuit(quantum_program)
 
         super().__init__()
 
@@ -201,12 +199,11 @@ class QLayer(nn.Module):
         else:
             execute = arg_list.pop(0)
 
-        self._initialize(quantum_program, circuit, execute, *arg_list, **kwargs)
+        self._initialize(quantum_program, execute, *arg_list, **kwargs)
         self._initialize_parameters()
 
     def _initialize(
         self,
-        quantum_program: SerializedQuantumProgram,
         circuit: Circuit,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
@@ -219,11 +216,11 @@ class QLayer(nn.Module):
         self._head_start = head_start
         self._epsilon = epsilon
 
-        self.quantum_program = quantum_program
+        self.quantum_program = circuit
 
         weights, _ = extract_parameters(circuit)
         self.in_features: int = len(weights)
-        self.out_features: int = calc_num_out_features(quantum_program)
+        self.out_features: int = calc_num_out_features(circuit)
 
     def _initialize_parameters(self) -> None:
         shape: tuple[int, ...] = (
@@ -245,9 +242,7 @@ class QLayer(nn.Module):
 
         self.weight = Parameter(value)
 
-    def _make_execute(
-        self, quantum_program: SerializedQuantumProgram
-    ) -> ExecuteFunction:
+    def _make_execute(self, quantum_program: QuantumProgram) -> ExecuteFunction:
         if os.environ.get("SDK_ENV") == "Studio":
             try:
                 import classiq_studio_simulation

classiq/applications/qnn/types.py

@@ -6,15 +6,12 @@ from torch import Tensor
 from classiq.interface.executor.execution_result import ResultsCollection, SavedResult
 
 from classiq import QuantumProgram
-from classiq.synthesis import SerializedQuantumProgram
 
 Arguments = dict[str, float]
 MultipleArguments = tuple[Arguments, ...]
 
 Circuit = QuantumProgram
-ExecuteFunction = Callable[
-    [SerializedQuantumProgram, MultipleArguments], ResultsCollection
-]
+ExecuteFunction = Callable[[QuantumProgram, MultipleArguments], ResultsCollection]
 ExecuteFuncitonOnlyArguments = Callable[[MultipleArguments], ResultsCollection]
 PostProcessFunction = Callable[[SavedResult], Tensor]
 TensorToArgumentsCallable = Callable[[Tensor, Tensor], MultipleArguments]

classiq/execution/__init__.py

@@ -11,6 +11,7 @@ from .execution_session import ExecutionSession
 from .iqcc import generate_iqcc_token, generate_iqcc_token_async
 from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
 from .qnn import execute_qnn
+from .user_budgets import get_budget, get_budget_async
 
 __all__ = (
     _be_all
@@ -27,6 +28,8 @@ __all__ = (
         "execute_qnn",
         "generate_iqcc_token",
         "generate_iqcc_token_async",
+        "get_budget",
+        "get_budget_async",
     ]
 )
 

classiq/execution/execution_session.py

@@ -16,7 +16,6 @@ from classiq.interface.executor.result import (
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.generator.quantum_program import (
-    OMIT_DEBUG_INFO_FLAG,
     QuantumProgram,
 )
 from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
@@ -33,10 +32,8 @@ from classiq.qmod.builtins.classical_execution_primitives import (
     CARRAY_SEPARATOR,
     ExecutionParams,
 )
-from classiq.synthesis import SerializedQuantumProgram
 
 Hamiltonian = Union[list[QmodPyStruct], list[PauliTerm]]
-Program = Union[SerializedQuantumProgram, QuantumProgram]
 ParsedExecutionParams = dict[str, Union[float, int]]
 ExecutionParameters = Optional[Union[ExecutionParams, list[ExecutionParams]]]
 ParsedExecutionParameters = Optional[
@@ -44,16 +41,6 @@ ParsedExecutionParameters = Optional[
 ]
 
 
-def _deserialize_program(program: Program) -> QuantumProgram:
-    return (
-        program
-        if isinstance(program, QuantumProgram)
-        else QuantumProgram.model_validate_json(
-            program, context={OMIT_DEBUG_INFO_FLAG: True}
-        )
-    )
-
-
 def hamiltonian_to_pauli_terms(hamiltonian: Hamiltonian) -> list[PauliTerm]:
     if isinstance(hamiltonian[0], PauliTerm):
         return cast(list[PauliTerm], hamiltonian)
@@ -93,16 +80,16 @@ class ExecutionSession:
     The session must be closed in order to ensure resources are properly cleaned up. It's recommended to use `ExecutionSession` as a context manager for this purpose. Alternatively, you can directly use the `close` method.
 
     Attributes:
-        quantum_program (Union[SerializedQuantumProgram, QuantumProgram]): The quantum program to execute.
+        quantum_program (QuantumProgram): The quantum program to execute.
         execution_preferences (Optional[ExecutionPreferences]): Execution preferences for the Quantum Program.
     """
 
     def __init__(
         self,
-        quantum_program: Program,
+        quantum_program: QuantumProgram,
         execution_preferences: Optional[ExecutionPreferences] = None,
     ):
-        self.program: QuantumProgram = _deserialize_program(quantum_program)
+        self.program: QuantumProgram = quantum_program
         self.update_execution_preferences(execution_preferences)
         # We never use classical_execution_code in ExecutionSession, and we don't want
         # the conversion route to fail because cmain is expected in some cases

classiq/execution/qnn.py

@@ -13,11 +13,11 @@ from classiq.interface.executor.execution_result import (
 )
 from classiq.interface.executor.quantum_code import Arguments, MultipleArguments
 
+from classiq import QuantumProgram
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
     pauli_operator_to_hamiltonian,
 )
 from classiq.execution.execution_session import ExecutionSession
-from classiq.synthesis import SerializedQuantumProgram
 
 _MAX_ARGUMENTS_SIZE = 1024
 
@@ -55,7 +55,7 @@ def _execute_qnn_sample(
 
 
 def execute_qnn(
-    quantum_program: SerializedQuantumProgram,
+    quantum_program: QuantumProgram,
     arguments: MultipleArguments,
     observable: Optional[PauliOperator] = None,
 ) -> ResultsCollection:

classiq/execution/user_budgets.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from classiq.interface.backend.quantum_backend_providers import ProviderVendor
+from classiq.interface.executor.user_budget import UserBudgets
+
+from classiq._internals.api_wrapper import ApiWrapper
+from classiq._internals.async_utils import syncify_function
+
+PROVIDER_MAPPER = {
+    ProviderVendor.IONQ: "IONQ",
+    ProviderVendor.IBM_QUANTUM: "IBMQ",
+    ProviderVendor.AZURE_QUANTUM: "AZURE",
+    ProviderVendor.AMAZON_BRAKET: "AMAZON",
+    ProviderVendor.GOOGLE: "GOOGLE",
+    ProviderVendor.ALICE_AND_BOB: "ALICE_AND_BOB",
+    ProviderVendor.OQC: "OQC",
+    ProviderVendor.INTEL: "INTEL",
+    ProviderVendor.AQT: "AQT",
+    ProviderVendor.IQCC: "IQCC",
+    ProviderVendor.CLASSIQ: "CLASSIQ",
+}
+
+
+async def get_budget_async(
+    provider_vendor: Optional[ProviderVendor] = None,
+) -> UserBudgets:
+
+    budgets_list = await ApiWrapper().call_get_all_budgets()
+    if provider_vendor:
+        provider = PROVIDER_MAPPER.get(provider_vendor, None)
+        budgets_list = [
+            budget for budget in budgets_list if budget.provider == provider
+        ]
+
+    return UserBudgets(budgets=budgets_list)
+
+
+get_budget = syncify_function(get_budget_async)

classiq/executor.py

@@ -11,14 +11,12 @@ from classiq.interface.executor.quantum_code import QuantumCode
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.result import ExecutionDetails
 from classiq.interface.generator.quantum_program import (
-    OMIT_DEBUG_INFO_FLAG,
     QuantumProgram,
 )
 
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq.execution.jobs import ExecutionJob
-from classiq.synthesis import SerializedQuantumProgram
 
 BatchExecutionResult: TypeAlias = Union[ExecutionDetails, BaseException]
 ProgramAndResult: TypeAlias = tuple[QuantumCode, BatchExecutionResult]
@@ -27,22 +25,13 @@ BackendPreferencesAndResult: TypeAlias = tuple[
 ]
 
 
-def _parse_serialized_qprog(
-    quantum_program: SerializedQuantumProgram,
-) -> QuantumProgram:
-    return QuantumProgram.model_validate_json(
-        quantum_program, context={OMIT_DEBUG_INFO_FLAG: True}
-    )
-
-
-async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
-    circuit = _parse_serialized_qprog(quantum_program)
-    execution_input = await ApiWrapper.call_convert_quantum_program(circuit)
+async def execute_async(quantum_program: QuantumProgram) -> ExecutionJob:
+    execution_input = await ApiWrapper.call_convert_quantum_program(quantum_program)
     result = await ApiWrapper.call_execute_execution_input(execution_input)
     return ExecutionJob(details=result)
 
 
-def execute(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
+def execute(quantum_program: QuantumProgram) -> ExecutionJob:
     """
     Execute a quantum program. The preferences for execution are set on the quantum program using the method `set_execution_preferences`.
 
@@ -58,12 +47,11 @@ def execute(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
 
 
 def set_quantum_program_execution_preferences(
-    quantum_program: SerializedQuantumProgram,
+    quantum_program: QuantumProgram,
     preferences: ExecutionPreferences,
-) -> SerializedQuantumProgram:
-    circuit = _parse_serialized_qprog(quantum_program)
-    circuit.model.execution_preferences = preferences
-    return SerializedQuantumProgram(circuit.model_dump_json())
+) -> QuantumProgram:
+    quantum_program.model.execution_preferences = preferences
+    return quantum_program
 
 
 __all__ = [

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.75.0'
+SEMVER_VERSION = '0.77.0'
 VERSION = str(Version(SEMVER_VERSION))