classiq 0.79.1__py3-none-any.whl → 0.80.1__py3-none-any.whl

classiq/__init__.py

@@ -38,6 +38,8 @@ from classiq.applications.hamiltonian.pauli_decomposition import (
     hamiltonian_to_matrix,
     matrix_to_hamiltonian,
 )
+from classiq.execution import *  # noqa: F403
+from classiq.execution import __all__ as _execution_all
 from classiq.executor import (
     execute,
     execute_async,
@@ -47,6 +49,7 @@ 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.quantum_program import ExecutionParams, assign_parameters, transpile
 from classiq.synthesis import (
     quantum_program_from_qasm,
     quantum_program_from_qasm_async,
@@ -87,8 +90,10 @@ __all__ = (
         "RegisterArithmeticInfo",
         "ControlState",
         "Analyzer",
+        "ExecutionParams",
         "QuantumProgram",
         "authenticate",
+        "assign_parameters",
         "synthesize",
         "synthesize_async",
         "execute",
@@ -96,6 +101,7 @@ __all__ = (
         "set_preferences",
         "set_constraints",
         "set_execution_preferences",
+        "transpile",
         "update_preferences",
         "update_constraints",
         "update_execution_preferences",
@@ -110,6 +116,7 @@ __all__ = (
     + _sub_modules
     + _application_constructors_all
     + _qmod_all
+    + _execution_all
     + _open_library_all
 )
 

classiq/_internals/api_wrapper.py

@@ -23,7 +23,11 @@ from classiq.interface.execution.iqcc import (
     IQCCProbeAuthResponse,
 )
 from classiq.interface.execution.primitives import PrimitivesInput
-from classiq.interface.executor import execution_request
+from classiq.interface.executor import execution_request, quantum_program_params
+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.hardware import HardwareInformation, Provider
@@ -112,17 +116,58 @@ class ApiWrapper:
             raise ClassiqValueError(f"Unexpected returned value: {res}")
         return res
 
+    @classmethod
+    async def _call_job_and_poll(
+        cls,
+        url: str,
+        job_input: pydantic.BaseModel,
+        result_type: type[ResultType],
+        http_client: Optional[httpx.AsyncClient],
+    ) -> ResultType:
+        poller = JobPoller(base_url=url)
+        result = await poller.run_pydantic(
+            job_input, timeout_sec=None, http_client=http_client
+        )
+        return _parse_job_response(result, result_type)
+
     @classmethod
     async def call_generation_task(
         cls,
         model: Model,
         http_client: Optional[httpx.AsyncClient] = None,
     ) -> generator_result.QuantumProgram:
-        poller = JobPoller(base_url=routes.TASKS_GENERATE_FULL_PATH)
-        result = await poller.run_pydantic(
-            model, timeout_sec=None, http_client=http_client
+        return await cls._call_job_and_poll(
+            routes.TASKS_GENERATE_FULL_PATH,
+            model,
+            generator_result.QuantumProgram,
+            http_client,
+        )
+
+    @classmethod
+    async def call_transpilation_task(
+        cls,
+        params: TranspilationParams,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> generator_result.QuantumProgram:
+        return await cls._call_job_and_poll(
+            routes.TRANSPILATION_FULL_PATH,
+            params,
+            generator_result.QuantumProgram,
+            http_client,
+        )
+
+    @classmethod
+    async def call_assign_parameters_task(
+        cls,
+        params: ParameterAssignmentsParams,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> generator_result.QuantumProgram:
+        return await cls._call_job_and_poll(
+            routes.ASSIGN_PARAMETERS_FULL_PATH,
+            params,
+            generator_result.QuantumProgram,
+            http_client,
         )
-        return _parse_job_response(result, generator_result.QuantumProgram)
 
     @classmethod
     async def call_get_visual_model(
@@ -143,11 +188,12 @@ class ApiWrapper:
         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 await cls._call_job_and_poll(
+            routes.TASKS_VISUAL_MODEL_FULL_PATH,
+            circuit,
+            ProgramVisualModel,
+            http_client,
         )
-        return _parse_job_response(result, ProgramVisualModel)
 
     @classmethod
     async def call_create_execution_session(
@@ -193,6 +239,36 @@ 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,
@@ -374,11 +450,12 @@ class ApiWrapper:
         params: analysis_params.AnalysisHardwareListParams,
         http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.GraphResult:
-        poller = JobPoller(base_url=routes.ANALYZER_HC_TABLE_GRAPH_FULL_PATH)
-        result = await poller.run_pydantic(
-            params, timeout_sec=None, http_client=http_client
+        return await cls._call_job_and_poll(
+            routes.ANALYZER_HC_TABLE_GRAPH_FULL_PATH,
+            params,
+            analysis_result.GraphResult,
+            http_client,
         )
-        return _parse_job_response(result, analysis_result.GraphResult)
 
     @classmethod
     async def call_available_devices_task(
@@ -434,13 +511,12 @@ class ApiWrapper:
         problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE,
         http_client: Optional[httpx.AsyncClient] = None,
     ) -> operator.PauliOperator:
-        poller = JobPoller(
-            base_url=routes.GENERATE_HAMILTONIAN_FULL_PATH,
-        )
-        result = await poller.run_pydantic(
-            problem, timeout_sec=None, http_client=http_client
+        return await cls._call_job_and_poll(
+            routes.GENERATE_HAMILTONIAN_FULL_PATH,
+            problem,
+            operator.PauliOperator,
+            http_client,
         )
-        return _parse_job_response(result, operator.PauliOperator)
 
     @classmethod
     async def call_iqcc_init_auth(

classiq/analyzer/show_interactive_hack.py

@@ -1,8 +1,11 @@
 import os
+import subprocess
 import webbrowser
-from typing import Callable, Union
+from collections.abc import Awaitable, Callable
+from tempfile import NamedTemporaryFile
 from urllib.parse import urljoin
 
+from classiq.interface.analyzer.result import DataID
 from classiq.interface.exceptions import ClassiqAnalyzerVisualizationError
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 from classiq.interface.generator.quantum_program import QuantumProgram
@@ -10,12 +13,12 @@ from classiq.interface.generator.quantum_program import QuantumProgram
 from classiq._internals.api_wrapper import ApiWrapper
 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,
-)
+from classiq.visualization import visualize_async
 
-VisualizationRenderer = Callable[[SerializedVisualModel, str], None]
+VisualizationRenderer = Callable[[DataID, QuantumProgram], Awaitable[None]]
+
+# In Classiq Studio (openvscode env) we use this command to open files
+VSCODE_COMMAND = "code"
 
 
 def is_classiq_studio() -> bool:
@@ -24,38 +27,61 @@ def is_classiq_studio() -> bool:
     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.
+def get_app_url(data_id: DataID, circuit: QuantumProgram) -> str:
+    return urljoin(
+        client_ide_base_url(),
+        circuit_page_uri(circuit_id=data_id.id, circuit_version=circuit.version),
+    )
+
+
+async def ide_renderer(data_id: DataID, circuit: QuantumProgram) -> None:
+    app_url = get_app_url(data_id, circuit)
+    webbrowser.open_new_tab(app_url)
+
+
+async def editor_renderer(data_id: DataID, circuit: QuantumProgram) -> None:
+    with NamedTemporaryFile(
+        delete=False, prefix=f"{data_id.id}-", suffix=".qprog", mode="w"
+    ) as file:
+        analyzer_data = await ApiWrapper.get_analyzer_app_data(data_id)
+        file.write(analyzer_data.model_dump_json())
+    subprocess.run([VSCODE_COMMAND, file.name])
+
+
+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)
+    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": app_url,
+        },
+        raw=True,
+        metadata={
+            "url": app_url,
+        },
+    )
+
+
+def get_visualization_renderer() -> VisualizationRenderer:
+    # Ideally, we should check if a registered custom mime type handler is available,
+    #  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
+        return ide_renderer
+    # For non-interactive environments, write a temporary file and open it
+    if not is_notebook():
+        return editor_renderer
+    # For interactive notebooks, visualize and render as inline content
+    return notebook_renderer
 
 
 async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -> None:
@@ -66,23 +92,12 @@ async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -
             "synthesis preferences"
         )
     circuit_dataid = await ApiWrapper.call_analyzer_app(circuit)
-    app_url = urljoin(
-        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(link_label)  # noqa: T201
-
-    webbrowser.open_new_tab(app_url)
+        app_url = get_app_url(circuit_dataid, circuit)
+        print(f"Quantum program link: {app_url}")  # noqa: T201
+    await renderer(circuit_dataid, circuit)
 
 
 async def _show_interactive(self: QuantumProgram, display_url: bool = True) -> None:

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -436,7 +436,7 @@ def _get_chemistry_quantum_main_params(
             name="t",
             classical_type=ClassicalArray(
                 element_type=Real(),
-                size=_get_hea_port_size(ansatz_parameters),
+                length=Expression(expr=str(_get_hea_port_size(ansatz_parameters))),
             ),
         ),
     ]

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -7,7 +7,6 @@ from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
-    ClassicalList,
     Real,
 )
 from classiq.interface.generator.functions.port_declaration import (
@@ -76,7 +75,7 @@ def construct_combi_opt_py_model(
         constants=[
             Constant(
                 name="hamiltonian",
-                const_type=ClassicalList(element_type=Struct(name="PauliTerm")),
+                const_type=ClassicalArray(element_type=Struct(name="PauliTerm")),
                 value=Expression(expr=f"[{pauli_qmod}]"),
             )
         ],
@@ -87,7 +86,8 @@ def construct_combi_opt_py_model(
                     ClassicalParameterDeclaration(
                         name="params_list",
                         classical_type=ClassicalArray(
-                            element_type=Real(), size=qaoa_config.num_layers * 2
+                            element_type=Real(),
+                            length=Expression(expr=str(qaoa_config.num_layers * 2)),
                         ),
                     ),
                     PortDeclaration(

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.79.1'
+SEMVER_VERSION = '0.80.1'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/result.py

@@ -37,7 +37,7 @@ class DataID(pydantic.BaseModel):
 
 
 class QasmCode(pydantic.BaseModel):
-    code: str = Field(..., max_length=MAX_FILE_LENGTH)
+    code: str = Field(..., max_length=MAX_FILE_LENGTH * 100)
 
 
 class AnalysisStatus(StrEnum):

classiq/interface/chemistry/operator.py

@@ -1,12 +1,7 @@
-from collections.abc import Collection
+from collections.abc import Collection, Iterable
 from functools import reduce
 from itertools import combinations
-from typing import (
-    Any,
-    Optional,
-    Union,
-    cast,
-)
+from typing import Any, Optional, Union, cast
 
 import numpy as np
 import pydantic
@@ -283,7 +278,7 @@ def validate_operator_has_no_complex_coefficients(
     return pauli_operator
 
 
-def pauli_integers_to_str(paulis: list[Pauli]) -> str:
+def pauli_integers_to_str(paulis: Iterable[Pauli]) -> str:
     return "".join([Pauli(pauli).name for pauli in paulis])
 
 

classiq/interface/executor/quantum_program_params.py

@@ -0,0 +1,18 @@
+from typing import Union
+
+from pydantic import BaseModel
+
+from classiq.interface.generator.model.preferences.preferences import Preferences
+from classiq.interface.generator.quantum_program import QuantumProgram
+
+ExecutionParams = dict[str, Union[float, int, list[int], list[float]]]
+
+
+class TranspilationParams(BaseModel):
+    quantum_program: QuantumProgram
+    preferences: Preferences
+
+
+class ParameterAssignmentsParams(BaseModel):
+    quantum_program: QuantumProgram
+    parameters: ExecutionParams

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -4,7 +4,7 @@ from classiq.interface.generator.functions.classical_function_declaration import
     ClassicalFunctionDeclaration,
 )
 from classiq.interface.generator.functions.classical_type import (
-    ClassicalList,
+    ClassicalArray,
     VQEResult,
 )
 from classiq.interface.generator.functions.type_name import Struct
@@ -35,7 +35,7 @@ MOLECULE_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
             name="problem", classical_type=Struct(name="MoleculeProblem")
         ),
     ],
-    return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
+    return_type=ClassicalArray(element_type=Struct(name="PauliTerm")),
 )
 
 FOCK_HAMILTONIAN_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
@@ -45,7 +45,7 @@ FOCK_HAMILTONIAN_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
             name="problem", classical_type=Struct(name="FockHamiltonianProblem")
         ),
     ],
-    return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
+    return_type=ClassicalArray(element_type=Struct(name="PauliTerm")),
 )
 
 

classiq/interface/generator/application_apis/combinatorial_optimization_declarations.py

@@ -2,7 +2,7 @@ from classiq.interface.generator.functions.classical_function_declaration import
     ClassicalFunctionDeclaration,
 )
 from classiq.interface.generator.functions.classical_type import (
-    ClassicalList,
+    ClassicalArray,
     Real,
     StructMetaType,
     VQEResult,
@@ -20,7 +20,7 @@ OPTIMIZATION_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
         ),
         ClassicalParameterDeclaration(name="penalty_energy", classical_type=Real()),
     ],
-    return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
+    return_type=ClassicalArray(element_type=Struct(name="PauliTerm")),
 )
 
 GET_OPTIMIZATION_SOLUTION = ClassicalFunctionDeclaration(
@@ -34,7 +34,7 @@ GET_OPTIMIZATION_SOLUTION = ClassicalFunctionDeclaration(
         ),
         ClassicalParameterDeclaration(name="penalty_energy", classical_type=Real()),
     ],
-    return_type=ClassicalList(
+    return_type=ClassicalArray(
         element_type=Struct(name="CombinatorialOptimizationSolution")
     ),
 )

classiq/interface/generator/application_apis/entangler_declarations.py

@@ -3,7 +3,7 @@ from classiq.interface.generator.functions.classical_function_declaration import
 )
 from classiq.interface.generator.functions.classical_type import (
     Bool,
-    ClassicalList,
+    ClassicalArray,
     Integer,
 )
 from classiq.interface.model.classical_parameter_declaration import (
@@ -17,7 +17,7 @@ GRID_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
         ClassicalParameterDeclaration(name="schmidt_rank", classical_type=Integer()),
         ClassicalParameterDeclaration(name="grid_randomization", classical_type=Bool()),
     ],
-    return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
+    return_type=ClassicalArray(element_type=ClassicalArray(element_type=Integer())),
 )
 
 HYPERCUBE_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
@@ -25,5 +25,5 @@ HYPERCUBE_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
     positional_parameters=[
         ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
     ],
-    return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
+    return_type=ClassicalArray(element_type=ClassicalArray(element_type=Integer())),
 )

classiq/interface/generator/arith/number_utils.py

@@ -100,6 +100,14 @@ def bounds_to_integer_part_size(lb: float, ub: float) -> int:
     )
 
 
+def bounds_to_attributes(
+    lb: float, ub: float, fraction_places: int, machine_precision: int
+) -> tuple[int, bool, int]:
+    fraction_places = min(fraction_places, machine_precision)
+    integers = bounds_to_integer_part_size(lb, ub)
+    return max(1, integers + fraction_places), lb < 0, fraction_places
+
+
 def limit_fraction_places(number: float, machine_precision: int) -> float:
     orig_bin_rep = binary_string(number)[::-1]
     orig_fractions = fraction_places(number)

classiq/interface/generator/expressions/proxies/classical/utils.py

@@ -1,4 +1,8 @@
 from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
     ClassicalTupleProxy,
@@ -14,7 +18,6 @@ from classiq.interface.generator.expressions.proxies.classical.classical_struct_
 )
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     ClassicalType,
 )
@@ -26,8 +29,10 @@ def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
         return proxy._classical_type
     if isinstance(proxy, ClassicalArrayProxy):
         if not isinstance(proxy.length, int):
-            return ClassicalList(element_type=proxy._element_type)
-        return ClassicalArray(element_type=proxy._element_type, size=proxy.length)
+            return ClassicalArray(element_type=proxy._element_type)
+        length = Expression(expr=str(proxy.length))
+        length._evaluated_expr = EvaluatedExpression(value=proxy.length)
+        return ClassicalArray(element_type=proxy._element_type, length=length)
     if isinstance(proxy, ClassicalTupleProxy):
         return ClassicalTuple(element_types=proxy._element_types)
     if isinstance(proxy, ClassicalStructProxy):