classiq 0.92.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

classiq/__init__.py

@@ -1,19 +1,11 @@
 """Classiq SDK."""
 
-import sys
-import warnings
-
-from classiq.interface.exceptions import ClassiqDeprecationWarning
-
-if sys.version_info[0:2] <= (3, 9):
-    warnings.warn(
-        "Python version 3.9 will no longer be supported starting on 2025-10-01 "
-        "at the earliest",
-        ClassiqDeprecationWarning,
-        stacklevel=2,
-    )
-
 from classiq.interface._version import VERSION as _VERSION
+from classiq.interface.backend.quantum_backend_providers import (
+    ProviderVendor,
+    __all__ as _be_all,
+)
+from classiq.interface.exceptions import ClassiqDeprecationWarning
 from classiq.interface.generator.application_apis import *  # noqa: F403
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
@@ -36,10 +28,6 @@ from classiq._internals.client import configure
 from classiq._internals.config import Configuration
 from classiq._internals.help import open_help
 from classiq.analyzer import Analyzer
-from classiq.applications.chemistry import (
-    construct_chemistry_model,
-    molecule_problem_to_qmod,
-)
 from classiq.applications.combinatorial_optimization import (
     CombinatorialProblem,
     compute_qaoa_initial_point,
@@ -51,6 +39,7 @@ from classiq.applications.hamiltonian.pauli_decomposition import (
     hamiltonian_to_matrix,
     matrix_to_hamiltonian,
     matrix_to_pauli_operator,
+    pauli_operator_to_matrix,
 )
 from classiq.execution import *  # noqa: F403
 from classiq.execution import __all__ as _execution_all
@@ -65,6 +54,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 (
+    QmodFormat,
     qasm_to_qmod,
     quantum_program_from_qasm,
     quantum_program_from_qasm_async,
@@ -81,8 +71,6 @@ from classiq.synthesis import (
 
 _application_constructors_all = [
     "construct_combinatorial_optimization_model",
-    "construct_chemistry_model",
-    "molecule_problem_to_qmod",
 ]
 
 __version__ = _VERSION
@@ -113,6 +101,7 @@ __all__ = (
         "synthesize_async",
         "execute",
         "execute_async",
+        "qasm_to_qmod",
         "set_preferences",
         "set_constraints",
         "set_execution_preferences",
@@ -125,8 +114,10 @@ __all__ = (
         "hamiltonian_to_matrix",
         "matrix_to_hamiltonian",
         "matrix_to_pauli_operator",
+        "pauli_operator_to_matrix",
         "quantum_program_from_qasm",
         "quantum_program_from_qasm_async",
+        "QmodFormat",
     ]
     + _md_all
     + _sub_modules
@@ -134,6 +125,7 @@ __all__ = (
     + _qmod_all
     + _execution_all
     + _open_library_all
+    + _be_all
 )
 
 

classiq/_analyzer_extras/_ipywidgets_async_extension.py

@@ -1,11 +1,11 @@
 import asyncio
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from functools import wraps
-from typing import TYPE_CHECKING, Callable
-
-from ipywidgets import widgets  # type: ignore[import]
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from ipywidgets import widgets  # type: ignore[import]
+
     from classiq._analyzer_extras.interactive_hardware import InteractiveHardware
 
 WidgetName = str
@@ -30,7 +30,7 @@ def widget_callback(widget_name: WidgetName) -> Callable[[WidgetFunc], Callable]
     def decorator(function: WidgetFunc) -> Callable:
         @wraps(function)
         async def wrapper(self: "InteractiveHardware", **kwargs: WidgetValue) -> None:
-            widget: widgets = getattr(self, widget_name)
+            widget: "widgets" = getattr(self, widget_name)
             interactive_loop = _create_interactive_loop_async(
                 function=function, self=self, widget=widget
             )
@@ -43,7 +43,7 @@ def widget_callback(widget_name: WidgetName) -> Callable[[WidgetFunc], Callable]
 
 
 async def _create_interactive_loop_async(
-    function: WidgetFunc, self: "InteractiveHardware", widget: widgets
+    function: WidgetFunc, self: "InteractiveHardware", widget: "widgets"
 ) -> None:
     while True:
         value: WidgetValue = await _wait_for_change(widget=widget)
@@ -51,7 +51,7 @@ async def _create_interactive_loop_async(
         await function(self, value)
 
 
-def _wait_for_change(widget: widgets) -> asyncio.Future:
+def _wait_for_change(widget: "widgets") -> asyncio.Future:
     future: asyncio.Future = asyncio.Future()
 
     def _get_value(change) -> None:  # type: ignore[no-untyped-def]

classiq/_analyzer_extras/interactive_hardware.py

@@ -1,8 +1,5 @@
 import json
-from typing import Optional
-
-import plotly.graph_objects as go
-from ipywidgets import Combobox, HBox, VBox  # type: ignore[import]
+from typing import TYPE_CHECKING
 
 from classiq.interface.analyzer import analysis_params
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
@@ -17,6 +14,10 @@ from classiq.analyzer.analyzer_utilities import (
     ProviderNameEnum,
 )
 
+if TYPE_CHECKING:
+    import plotly.graph_objects as go
+    from ipywidgets import Combobox, VBox  # type: ignore[import]
+
 
 class InteractiveHardware(AnalyzerUtilities):
     def __init__(
@@ -31,7 +32,9 @@ class InteractiveHardware(AnalyzerUtilities):
         self.devices_combobox = self._initialize_devices_combobox()
         self.hardware_graph = self._initialize_hardware_graph()
 
-    def show_interactive_graph(self) -> VBox:
+    def show_interactive_graph(self) -> "VBox":
+        from ipywidgets import HBox, VBox
+
         combobox_layout = HBox([self.providers_combobox, self.devices_combobox])
         return VBox([combobox_layout, self.hardware_graph])
 
@@ -40,7 +43,9 @@ class InteractiveHardware(AnalyzerUtilities):
         await self._device_selection_response_async()
 
     @staticmethod
-    def _initialize_providers_combobox() -> Combobox:
+    def _initialize_providers_combobox() -> "Combobox":
+        from ipywidgets import Combobox
+
         combobox = Combobox(
             placeholder="Choose provider",
             options=list(AnalyzerProviderVendor),
@@ -51,7 +56,9 @@ class InteractiveHardware(AnalyzerUtilities):
         return combobox
 
     @staticmethod
-    def _initialize_devices_combobox() -> Combobox:
+    def _initialize_devices_combobox() -> "Combobox":
+        from ipywidgets import Combobox
+
         combobox = Combobox(
             placeholder="Choose first provider",
             description="devices:",
@@ -61,12 +68,14 @@ class InteractiveHardware(AnalyzerUtilities):
         return combobox
 
     @staticmethod
-    def _initialize_hardware_graph() -> go.FigureWidget:
+    def _initialize_hardware_graph() -> "go.FigureWidget":
+        import plotly.graph_objects as go
+
         return go.FigureWidget()
 
     @widget_callback(widget_name="providers_combobox")
     async def _provider_selection_response_async(
-        self, provider: Optional[ProviderNameEnum]
+        self, provider: ProviderNameEnum | None
     ) -> None:
         if not provider:
             return
@@ -76,9 +85,7 @@ class InteractiveHardware(AnalyzerUtilities):
         self.devices_combobox.placeholder = "Choose device"
 
     @widget_callback(widget_name="devices_combobox")
-    async def _device_selection_response_async(
-        self, device: Optional[DeviceName]
-    ) -> None:
+    async def _device_selection_response_async(self, device: DeviceName | None) -> None:
         provider = self.providers_combobox.value
         if not device or not provider:
             return

classiq/_internals/api_wrapper.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Optional, Protocol, TypeVar
+from typing import Any, Protocol, TypeVar
 
 import httpx
 import pydantic
@@ -10,18 +10,8 @@ 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, QmodCode
-from classiq.interface.chemistry import ground_state_problem, operator
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqAPIError, ClassiqValueError
-from classiq.interface.execution.iqcc import (
-    IQCCAuthItemsDetails,
-    IQCCInitAuthData,
-    IQCCInitAuthResponse,
-    IQCCListAuthMethods,
-    IQCCListAuthTargets,
-    IQCCProbeAuthData,
-    IQCCProbeAuthResponse,
-)
 from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import execution_request
 from classiq.interface.executor.quantum_program_params import (
@@ -75,8 +65,8 @@ class ApiWrapper:
         url: str,
         model: pydantic.BaseModel,
         use_versioned_url: bool = True,
-        http_client: Optional[httpx.AsyncClient] = None,
-        exclude: Optional[IncEx] = None,
+        http_client: httpx.AsyncClient | None = None,
+        exclude: IncEx | None = None,
     ) -> dict:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
         # This was added because JSON serializer doesn't serialize complex type, and pydantic does.
@@ -95,12 +85,12 @@ class ApiWrapper:
         cls,
         http_method: str,
         url: str,
-        body: Optional[dict] = None,
-        params: Optional[dict] = None,
+        body: dict | None = None,
+        params: dict | None = None,
         use_versioned_url: bool = True,
-        headers: Optional[dict[str, str]] = None,
+        headers: dict[str, str] | None = None,
         allow_none: bool = False,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> dict:
         res: Any = await client().call_api(
             http_method=http_method,
@@ -123,7 +113,7 @@ class ApiWrapper:
         url: str,
         job_input: pydantic.BaseModel,
         result_type: type[ResultType],
-        http_client: Optional[httpx.AsyncClient],
+        http_client: httpx.AsyncClient | None,
     ) -> ResultType:
         poller = JobPoller(base_url=url)
         result = await poller.run_pydantic(
@@ -135,7 +125,7 @@ class ApiWrapper:
     async def call_generation_task(
         cls,
         model: Model,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> generator_result.QuantumProgram:
         return await cls._call_job_and_poll(
             routes.TASKS_GENERATE_FULL_PATH,
@@ -148,7 +138,7 @@ class ApiWrapper:
     async def call_transpilation_task(
         cls,
         params: TranspilationParams,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> generator_result.QuantumProgram:
         return await cls._call_job_and_poll(
             routes.TRANSPILATION_FULL_PATH,
@@ -161,7 +151,7 @@ class ApiWrapper:
     async def call_assign_parameters_task(
         cls,
         params: ParameterAssignmentsParams,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> generator_result.QuantumProgram:
         return await cls._call_job_and_poll(
             routes.ASSIGN_PARAMETERS_FULL_PATH,
@@ -174,7 +164,7 @@ class ApiWrapper:
     async def call_qasm_to_qmod_task(
         cls,
         params: QasmToQmodParams,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> QmodCode:
         return await cls._call_job_and_poll(
             routes.QASM_TO_QMOD_FULL_PATH,
@@ -187,7 +177,7 @@ class ApiWrapper:
     async def call_get_visual_model(
         cls,
         program_id: str,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> ProgramVisualModel:
         raw_result = await cls._call_task(
             http_method=HTTPMethod.GET,
@@ -200,7 +190,7 @@ class ApiWrapper:
     async def call_visualization_task(
         cls,
         circuit: generator_result.QuantumProgram,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> ProgramVisualModel:
         return await cls._call_job_and_poll(
             routes.TASKS_VISUAL_MODEL_FULL_PATH,
@@ -213,7 +203,7 @@ class ApiWrapper:
     async def call_create_execution_session(
         cls,
         circuit: generator_result.QuantumProgram,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> str:
         raw_result = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -229,7 +219,7 @@ class ApiWrapper:
         cls,
         session_id: str,
         primitives_input: PrimitivesInput,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -243,7 +233,7 @@ class ApiWrapper:
     async def call_convert_quantum_program(
         cls,
         circuit: generator_result.QuantumProgram,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> dict:
         return await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -257,7 +247,7 @@ class ApiWrapper:
     async def call_execute_execution_input(
         cls,
         execution_input: dict,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
@@ -271,7 +261,7 @@ class ApiWrapper:
     async def call_get_execution_job_details(
         cls,
         job_id: JobID,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
@@ -284,7 +274,7 @@ class ApiWrapper:
     async def call_get_execution_job_result(
         cls,
         job_id: JobID,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
@@ -300,7 +290,7 @@ class ApiWrapper:
         cls,
         job_id: JobID,
         name: str,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task(
             http_method=HTTPMethod.PATCH,
@@ -316,7 +306,7 @@ class ApiWrapper:
     async def call_cancel_execution_job(
         cls,
         job_id: JobID,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> None:
         await cls._call_task(
             http_method=HTTPMethod.PUT,
@@ -330,7 +320,7 @@ class ApiWrapper:
         cls,
         offset: int,
         limit: int,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> execution_request.ExecutionJobsQueryResults:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
@@ -347,7 +337,7 @@ class ApiWrapper:
     async def call_analysis_task(
         cls,
         params: analysis_params.AnalysisParams,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> analysis_result.Analysis:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -358,25 +348,11 @@ class ApiWrapper:
 
         return analysis_result.Analysis.model_validate(data)
 
-    @classmethod
-    async def call_analyzer_app(
-        cls,
-        params: generator_result.QuantumProgram,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> analysis_result.DataID:
-        data = await cls._call_task_pydantic(
-            http_method=HTTPMethod.POST,
-            url=routes.ANALYZER_DATA_FULL_PATH,
-            model=params,
-            http_client=http_client,
-        )
-        return analysis_result.DataID.model_validate(data)
-
     @classmethod
     async def get_generated_circuit_from_qasm(
         cls,
         params: analysis_result.QasmCode,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> generator_result.QuantumProgram:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -390,7 +366,7 @@ class ApiWrapper:
     async def get_analyzer_app_data(
         cls,
         params: analysis_result.DataID,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> generator_result.QuantumProgram:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
@@ -403,7 +379,7 @@ class ApiWrapper:
     async def call_rb_analysis_task(
         cls,
         params: AnalysisRBParams,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> analysis_result.RbResults:
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
@@ -418,7 +394,7 @@ class ApiWrapper:
     async def call_hardware_connectivity_task(
         cls,
         params: analysis_params.AnalysisHardwareParams,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> analysis_result.GraphResult:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -432,7 +408,7 @@ class ApiWrapper:
     async def call_table_graphs_task(
         cls,
         params: analysis_params.AnalysisHardwareListParams,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> analysis_result.GraphResult:
         return await cls._call_job_and_poll(
             routes.ANALYZER_HC_TABLE_GRAPH_FULL_PATH,
@@ -445,7 +421,7 @@ class ApiWrapper:
     async def call_available_devices_task(
         cls,
         params: analysis_params.AnalysisOptionalDevicesParams,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> analysis_result.DevicesResult:
         hardware_info = await cls.call_get_all_hardware_devices(http_client=http_client)
         return cls._get_devices_from_hardware_info(hardware_info, params)
@@ -477,7 +453,7 @@ class ApiWrapper:
     @classmethod
     async def call_get_all_hardware_devices(
         cls,
-        http_client: Optional[httpx.AsyncClient] = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> list[HardwareInformation]:
         data = await client().call_api(
             http_method=HTTPMethod.GET,
@@ -489,93 +465,6 @@ class ApiWrapper:
             raise ClassiqAPIError(f"Unexpected value: {data}")
         return [HardwareInformation.model_validate(info) for info in data]
 
-    @classmethod
-    async def call_generate_hamiltonian_task(
-        cls,
-        problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> operator.PauliOperator:
-        return await cls._call_job_and_poll(
-            routes.GENERATE_HAMILTONIAN_FULL_PATH,
-            problem,
-            operator.PauliOperator,
-            http_client,
-        )
-
-    @classmethod
-    async def call_iqcc_init_auth(
-        cls,
-        data: IQCCInitAuthData,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> IQCCInitAuthResponse:
-        response = await cls._call_task_pydantic(
-            http_method=HTTPMethod.PUT,
-            url=f"{routes.IQCC_INIT_AUTH_FULL_PATH}",
-            model=data,
-            http_client=http_client,
-        )
-        return IQCCInitAuthResponse.model_validate(response)
-
-    @classmethod
-    async def call_iqcc_probe_auth(
-        cls,
-        data: IQCCProbeAuthData,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> Optional[IQCCProbeAuthResponse]:
-        try:
-            response = await cls._call_task_pydantic(
-                http_method=HTTPMethod.PUT,
-                url=f"{routes.IQCC_PROBE_AUTH_FULL_PATH}",
-                model=data,
-                http_client=http_client,
-            )
-        except ClassiqAPIError as ex:
-            if ex.status_code == 418:
-                return None
-            raise
-
-        return IQCCProbeAuthResponse.model_validate(response)
-
-    @classmethod
-    async def call_iqcc_list_auth_scopes(
-        cls,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> IQCCAuthItemsDetails:
-        response = await cls._call_task(
-            http_method=HTTPMethod.GET,
-            url=routes.IQCC_LIST_AUTH_SCOPES_FULL_PATH,
-            http_client=http_client,
-        )
-        return IQCCAuthItemsDetails.model_validate(response)
-
-    @classmethod
-    async def call_iqcc_list_auth_methods(
-        cls,
-        data: IQCCListAuthMethods,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> IQCCAuthItemsDetails:
-        response = await cls._call_task_pydantic(
-            http_method=HTTPMethod.PUT,
-            url=routes.IQCC_LIST_AUTH_METHODS_FULL_PATH,
-            model=data,
-            http_client=http_client,
-        )
-        return IQCCAuthItemsDetails.model_validate(response)
-
-    @classmethod
-    async def call_iqcc_list_auth_targets(
-        cls,
-        data: IQCCListAuthTargets,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> IQCCAuthItemsDetails:
-        response = await cls._call_task_pydantic(
-            http_method=HTTPMethod.PUT,
-            url=routes.IQCC_LIST_AUTH_TARGETS_FULL_PATH,
-            model=data,
-            http_client=http_client,
-        )
-        return IQCCAuthItemsDetails.model_validate(response)
-
     @classmethod
     async def call_get_all_budgets(cls) -> list[UserBudget]:
         data = await client().call_api(

classiq/_internals/async_utils.py

@@ -3,14 +3,11 @@ import functools
 import itertools
 import logging
 import time
-from collections.abc import AsyncGenerator, Awaitable, Iterable
+from collections.abc import AsyncGenerator, Awaitable, Callable, Iterable
 from typing import (
     Any,
-    Callable,
-    Optional,
     SupportsFloat,
     TypeVar,
-    Union,
 )
 
 T = TypeVar("T")
@@ -58,7 +55,7 @@ def enable_jupyter_notebook() -> None:
 
 
 def _make_iterable_interval(
-    interval_sec: Union[SupportsFloat, Iterable[SupportsFloat]],
+    interval_sec: SupportsFloat | Iterable[SupportsFloat],
 ) -> Iterable[float]:
     if isinstance(interval_sec, Iterable):
         return map(float, interval_sec)
@@ -67,8 +64,8 @@ def _make_iterable_interval(
 
 async def poll_for(
     poller: Callable[..., Awaitable[T]],
-    timeout_sec: Optional[float],
-    interval_sec: Union[float, Iterable[float]],
+    timeout_sec: float | None,
+    interval_sec: float | Iterable[float],
 ) -> AsyncGenerator[T, None]:
     if timeout_sec is not None:
         end_time = time.perf_counter() + timeout_sec