classiq 0.100.0__py3-none-any.whl → 0.102.0__py3-none-any.whl

classiq/__init__.py

@@ -68,6 +68,8 @@ from classiq.synthesis import (
     update_execution_preferences,
     update_preferences,
 )
+from classiq.synthesis_action import *  # noqa: F403
+from classiq.synthesis_action import __all__ as _synthesis_all
 
 _application_constructors_all = [
     "construct_combinatorial_optimization_model",
@@ -124,6 +126,7 @@ __all__ = (
     + _application_constructors_all
     + _qmod_all
     + _execution_all
+    + _synthesis_all
     + _open_library_all
     + _be_all
 )

classiq/_internals/api_wrapper.py

@@ -20,6 +20,7 @@ from classiq.interface.executor.quantum_program_params import (
 )
 from classiq.interface.executor.user_budget import UserBudget
 from classiq.interface.generator import quantum_program as generator_result
+from classiq.interface.generator.generation_request import SynthesisActionsQueryResults
 from classiq.interface.generator.preferences.qasm_to_qmod_params import QasmToQmodParams
 from classiq.interface.hardware import HardwareInformation, Provider
 from classiq.interface.ide.visual_model import ProgramVisualModel
@@ -321,18 +322,42 @@ class ApiWrapper:
         offset: int,
         limit: int,
         http_client: httpx.AsyncClient | None = None,
+        **extra_query_params: Any,
     ) -> execution_request.ExecutionJobsQueryResults:
+        params: dict[str, Any] = {
+            "offset": offset,
+            "limit": limit,
+        }
+        params.update(extra_query_params)
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
             url=f"{routes.EXECUTION_JOBS_FULL_PATH}",
-            params={
-                "offset": offset,
-                "limit": limit,
-            },
+            params=params,
             http_client=http_client,
         )
         return execution_request.ExecutionJobsQueryResults.model_validate(data)
 
+    @classmethod
+    async def call_query_synthesis_actions(
+        cls,
+        offset: int,
+        limit: int,
+        http_client: httpx.AsyncClient | None = None,
+        **extra_query_params: Any | None,
+    ) -> SynthesisActionsQueryResults:
+        params: dict[str, Any] = {
+            "offset": offset,
+            "limit": limit,
+        }
+        params.update(extra_query_params)
+        data = await cls._call_task(
+            http_method=HTTPMethod.GET,
+            url=f"{routes.TASKS_GENERATE_FULL_PATH}",
+            params=params,
+            http_client=http_client,
+        )
+        return SynthesisActionsQueryResults.model_validate(data)
+
     @classmethod
     async def call_analysis_task(
         cls,

classiq/applications/chemistry/op_utils.py

@@ -1,10 +1,11 @@
+import warnings
 from typing import cast
 
 import numpy as np
 from openfermion.ops.operators.qubit_operator import QubitOperator
 from openfermion.utils.operator_utils import count_qubits
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 
 from classiq.qmod.builtins.enums import Pauli
 from classiq.qmod.builtins.structs import IndexedPauli, SparsePauliOp, SparsePauliTerm
@@ -25,6 +26,13 @@ def _get_n_qubits(qubit_op: QubitOperator, n_qubits: int | None) -> int:
 def qubit_op_to_pauli_terms(
     qubit_op: QubitOperator, n_qubits: int | None = None
 ) -> SparsePauliOp:
+    warnings.warn(
+        "The function 'qubit_op_to_pauli_terms' is deprecated due to incorrect order "
+        "of qubits in its result. It will no longer be supported starting on 2026-01-22 "
+        "at the earliest. Please use 'qubit_op_to_qmod' instead.",
+        ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     n_qubits = _get_n_qubits(qubit_op, n_qubits)
     return SparsePauliOp(
         terms=[
@@ -44,6 +52,28 @@ def qubit_op_to_pauli_terms(
     )
 
 
+def qubit_op_to_qmod(
+    qubit_op: QubitOperator, n_qubits: int | None = None
+) -> SparsePauliOp:
+    n_qubits = _get_n_qubits(qubit_op, n_qubits)
+    return SparsePauliOp(
+        terms=[
+            SparsePauliTerm(
+                paulis=[  # type:ignore[arg-type]
+                    IndexedPauli(
+                        pauli=getattr(Pauli, pauli),
+                        index=qubit,
+                    )
+                    for qubit, pauli in term
+                ],
+                coefficient=coeff,
+            )
+            for term, coeff in qubit_op.terms.items()
+        ],
+        num_qubits=n_qubits,
+    )
+
+
 _PAULIS_TO_XZ = {"I": (0, 0), "X": (1, 0), "Z": (0, 1), "Y": (1, 1)}
 _XZ_TO_PAULIS = {(0, 0): "I", (1, 0): "X", (0, 1): "Z", (1, 1): "Y"}
 

classiq/applications/chemistry/problems.py

@@ -1,3 +1,4 @@
+import warnings
 from collections.abc import Sequence
 from typing import cast
 
@@ -9,7 +10,7 @@ from openfermion.transforms import (
 )
 from openfermion.utils import count_qubits
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 
 
 class FermionHamiltonianProblem:
@@ -21,7 +22,7 @@ class FermionHamiltonianProblem:
     Attributes:
         fermion_hamiltonian (FermionOperator): The fermionic hamiltonian of the problem.
             Assumed to be in the block-spin labeling.
-        n_orbitals (int): Number of spatial orbitlas.
+        n_orbitals (int): Number of spatial orbitals.
         n_alpha (int): Number of alpha particles.
         n_beta (int): Number of beta particles.
         n_particles (tuple[int, int]): Number of alpha and beta particles.
@@ -116,6 +117,7 @@ class FermionHamiltonianProblem:
         molecule: MolecularData,
         first_active_index: int = 0,
         remove_orbitlas: Sequence[int] | None = None,
+        remove_orbitals: Sequence[int] | None = None,
         op_compression_tol: float = 1e-13,
     ) -> "FermionHamiltonianProblem":
         """
@@ -125,12 +127,22 @@ class FermionHamiltonianProblem:
             molecule (MolecularData): The molecule data.
             first_active_index (int): The first active index, indicates all prior
                 indices are freezed.
-            remove_orbitlas (Sequence[int], optional): Active indices to be removed.
+            remove_orbitals (Sequence[int], optional): Active indices to be removed.
             op_compression_tol (float): Tolerance for trimming the fermion operator.
 
         Returns:
             The fermion hamiltonian problem.
         """
+        if remove_orbitlas is not None:
+            warnings.warn(
+                "The `remove_orbitlas` parameter is deprecated and will not longer be "
+                "supported starting on 2026-01-15 at the earliest. Use the "
+                "'remove_orbitals' parameter instead",
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+            remove_orbitals = remove_orbitlas
+
         if molecule.n_orbitals is None:
             raise ClassiqValueError(
                 "The molecular data is not populated. Hint: call `run_pyscf` with the molecule."
@@ -145,8 +157,8 @@ class FermionHamiltonianProblem:
 
         freezed_indices = list(range(first_active_index))
         active_indices = list(range(first_active_index, molecule.n_orbitals))
-        if remove_orbitlas:
-            active_indices = list(set(active_indices) - set(remove_orbitlas))
+        if remove_orbitals:
+            active_indices = list(set(active_indices) - set(remove_orbitals))
 
         molecular_hamiltonian = molecule.get_molecular_hamiltonian(
             occupied_indices=freezed_indices,
@@ -167,7 +179,7 @@ class FermionHamiltonianProblem:
                 f"and {n_particles} electrons. "
                 f"This can happen if too many orbitals were frozen."
                 f"Before freezing number of particle was ({n_alpha, n_beta})."
-                f"Consider adjusting `first_active_index` or `remove_orbitlas` "
+                f"Consider adjusting `first_active_index` or `remove_orbitals` "
                 f"to ensure the active space is non-empty."
             )
 

classiq/applications/chemistry/ucc.py

@@ -6,7 +6,7 @@ from openfermion.ops.operators.fermion_operator import FermionOperator
 from openfermion.ops.operators.qubit_operator import QubitOperator
 
 from classiq.applications.chemistry.mapping import FermionToQubitMapper
-from classiq.applications.chemistry.op_utils import qubit_op_to_pauli_terms
+from classiq.applications.chemistry.op_utils import qubit_op_to_qmod
 from classiq.applications.chemistry.problems import FermionHamiltonianProblem
 from classiq.qmod.builtins.structs import (
     SparsePauliOp,
@@ -44,7 +44,7 @@ def get_ucc_hamiltonians(
 
     n_qubits = mapper.get_num_qubits(problem)
     return [
-        qubit_op_to_pauli_terms(q_op, n_qubits)
+        qubit_op_to_qmod(q_op, n_qubits)
         for f_op in f_ops
         if (q_op := mapper.map(f_op))
         not in (

classiq/evaluators/parameter_types.py

@@ -133,9 +133,6 @@ def _evaluate_type_from_arg(
     # FIXME: Remove suzuki_trotter overloading (CLS-2912)
     if closure.name == "suzuki_trotter" and parameter.name == "pauli_operator":
         return parameter
-    # FIXME: Remove qdrift overloading (CLS-4347)
-    if closure.name == "qdrift" and parameter.name == "pauli_operator":
-        return parameter
     if isinstance(parameter, ClassicalParameterDeclaration):
         return _evaluate_classical_type_from_arg(parameter, argument, closure)
     if isinstance(parameter, PortDeclaration):
@@ -257,7 +254,7 @@ def _evaluate_op_type_from_arg(
             first_lambda = arg_val[0]
             if isinstance(first_lambda, FunctionClosure):
                 _raise_argument_type_error(
-                    arg_val,
+                    f"[{', '.join(['<lambda>'] * len(arg_val))}]",
                     first_lambda.as_operand_declaration(is_list=True),
                     parameter.name,
                     parameter,

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -2,7 +2,10 @@ from typing import Union, cast
 
 import sympy
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
@@ -108,7 +111,7 @@ def get_sympy_val(val: sympy.Basic) -> bool | int | float | complex:
         hasattr(val, "is_imaginary") and val.is_imaginary
     ):
         return complex(val)
-    raise ClassiqInternalExpansionError("Unidentified sympy value")
+    raise ClassiqExpansionError(f"{str(val)!r} is not a number")
 
 
 def get_sympy_type(val: sympy.Basic) -> ClassicalType:
@@ -124,4 +127,4 @@ def get_sympy_type(val: sympy.Basic) -> ClassicalType:
         or (hasattr(val, "is_imaginary") and val.is_imaginary)
     ):
         return Real()
-    raise ClassiqInternalExpansionError("Unidentified sympy value")
+    raise ClassiqExpansionError(f"{str(val)!r} is not a number")

classiq/execution/__init__.py

@@ -8,7 +8,14 @@ from ..interface.executor.execution_preferences import __all__ as _ep_all
 from ..interface.executor.result import ExecutionDetails
 from ..interface.executor.vqe_result import VQESolverResult
 from .execution_session import ExecutionSession
-from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
+from .jobs import (
+    ExecutionJob,
+    ExecutionJobFilters,
+    get_execution_actions,
+    get_execution_actions_async,
+    get_execution_jobs,
+    get_execution_jobs_async,
+)
 from .qnn import execute_qnn
 from .user_budgets import (
     clear_budget_limit,
@@ -28,6 +35,9 @@ __all__ = (
         "VQESolverResult",
         "IQAEResult",
         "ExecutionJob",
+        "ExecutionJobFilters",
+        "get_execution_actions",
+        "get_execution_actions_async",
         "get_execution_jobs",
         "get_execution_jobs_async",
         "ExecutionSession",

classiq/execution/jobs.py

@@ -1,7 +1,11 @@
 import warnings
 import webbrowser
+from dataclasses import asdict, dataclass
 from datetime import datetime
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import pandas as pd
 from urllib.parse import urljoin
 
 import httpx
@@ -29,6 +33,10 @@ from classiq._internals.async_utils import syncify_function
 from classiq._internals.client import client
 from classiq._internals.jobs import JobID, JobPoller
 
+TOTAL_COST = "total_cost"
+CURRENCY_CODE = "currency_code"
+COST = "cost"
+
 
 class ClassiqExecutionResultError(ClassiqError):
     def __init__(self, primitive: str) -> None:
@@ -37,6 +45,42 @@ class ClassiqExecutionResultError(ClassiqError):
         )
 
 
+@dataclass
+class ExecutionJobFilters:
+    """
+    Filter parameters for querying execution jobs.
+
+    All filters are combined using AND logic: only jobs matching all specified filters are returned.
+    Range filters (with _min/_max suffixes) are inclusive.
+    Datetime filters are compared against the job's timestamps.
+    """
+
+    id: str | None = None  # Exact match on job ID
+    session_id: str | None = None  # Exact match on session ID
+    status: JobStatus | None = (
+        None  # Exact match on job status (e.g., "COMPLETED", "FAILED")
+    )
+    name: str | None = None  # Exact match on job name
+    provider: str | None = None  # Exact match on provider name (e.g., "ibm", "aws")
+    backend: str | None = None  # Exact match on backend name
+    program_id: str | None = None  # Exact match on program ID
+    total_cost_min: float | None = None  # Minimum total cost (inclusive)
+    total_cost_max: float | None = None  # Maximum total cost (inclusive)
+    start_time_min: datetime | None = None  # Earliest job start time (inclusive)
+    start_time_max: datetime | None = None  # Latest job start time (inclusive)
+    end_time_min: datetime | None = None  # Earliest job end time (inclusive)
+    end_time_max: datetime | None = None  # Latest job end time (inclusive)
+
+    def format_filters(self) -> dict[str, Any]:
+        """Convert filter fields to API kwargs, excluding None values and converting datetimes."""
+        filter_dict = asdict(self)
+        return {
+            k: (v.isoformat() if isinstance(v, datetime) else v)
+            for k, v in filter_dict.items()
+            if v is not None
+        }
+
+
 class ExecutionJob:
     _details: ExecutionJobDetails
     _result: ResultsCollection | None
@@ -352,10 +396,83 @@ class ExecutionJob:
 
 
 async def get_execution_jobs_async(
-    offset: int = 0, limit: int = 50
+    offset: int = 0,
+    limit: int = 50,
 ) -> list[ExecutionJob]:
-    result = await ApiWrapper().call_query_execution_jobs(offset=offset, limit=limit)
-    return [ExecutionJob(details) for details in result.results]
+    execution_user_jobs = await ApiWrapper.call_query_execution_jobs(
+        offset, limit, http_client=None
+    )
+    return [ExecutionJob(details) for details in execution_user_jobs.results]
+
+
+def get_execution_jobs(
+    offset: int = 0,
+    limit: int = 50,
+) -> list[ExecutionJob]:
+    """Query execution jobs.
+
+    Args:
+        offset: Number of results to skip (default: 0)
+        limit: Maximum number of results to return (default: 50)
+
+    Returns:
+        List of ExecutionJob objects.
+
+    Examples:
+        # Query all jobs:
+        jobs = get_execution_jobs(limit=10)
+    """
+    return syncify_function(get_execution_jobs_async)(offset, limit)
+
+
+def _flatten_cost_field(action_dict: dict[str, Any]) -> dict[str, Any]:
+    cost_obj = action_dict.pop(COST, {}) or {}
+    action_dict[TOTAL_COST] = cost_obj.get(TOTAL_COST, 0)
+    action_dict[CURRENCY_CODE] = cost_obj.get(CURRENCY_CODE)
+    return action_dict
+
+
+async def get_execution_actions_async(
+    offset: int = 0,
+    limit: int = 50,
+    filters: ExecutionJobFilters | None = None,
+) -> "pd.DataFrame":
+    import pandas as pd
+
+    api_kwargs = filters.format_filters() if filters is not None else {}
+    execution_user_actions = await ApiWrapper.call_query_execution_jobs(
+        offset, limit, http_client=None, **api_kwargs
+    )
+    execution_actions = execution_user_actions.results
+
+    if not execution_actions:
+        return pd.DataFrame()
+
+    data = [_flatten_cost_field(action.model_dump()) for action in execution_actions]
+    return pd.DataFrame(data)
+
+
+def get_execution_actions(
+    offset: int = 0, limit: int = 50, filters: ExecutionJobFilters | None = None
+) -> "pd.DataFrame":
+    """Query execution jobs with optional filters.
+
+    Args:
+        offset: Number of results to skip (default: 0)
+        limit: Maximum number of results to return (default: 50)
+        filters: Optional ExecutionJobFilters object containing filter parameters.
+
+    Returns:
+        pandas.DataFrame containing execution job information with columns:
+        id, name, start_time, end_time, provider, backend_name, status,
+        num_shots, program_id, error, cost.
 
+    Examples:
+        # Query all jobs:
+        df = get_execution_actions(limit=10)
 
-get_execution_jobs = syncify_function(get_execution_jobs_async)
+        # Query with filters:
+        filters = ExecutionJobFilters(status="COMPLETED", provider="ibm")
+        df = get_execution_actions(filters=filters, limit=10)
+    """
+    return syncify_function(get_execution_actions_async)(offset, limit, filters)

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

classiq/interface/exceptions.py

@@ -35,14 +35,6 @@ class ClassiqMissingOutputFormatError(ClassiqError):
         super().__init__(message=msg)
 
 
-class ClassiqCombinatorialOptimizationError(ClassiqError):
-    pass
-
-
-class ClassiqOracleError(ClassiqError):
-    pass
-
-
 class ClassiqAnalyzerError(ClassiqError):
     pass
 
@@ -57,10 +49,6 @@ class ClassiqAPIError(ClassiqError):
         super().__init__(message)
 
 
-class ClassiqVersionError(ClassiqError):
-    pass
-
-
 class ClassiqValueError(ClassiqError, ValueError):
     pass
 
@@ -77,10 +65,6 @@ class ClassiqIndexError(ClassiqError, IndexError):
     pass
 
 
-class ClassiqWiringError(ClassiqValueError):
-    pass
-
-
 class ClassiqControlError(ClassiqError):
     def __init__(self) -> None:
         message = "Repeated control names, please rename the control states"
@@ -91,10 +75,6 @@ class ClassiqQRegError(ClassiqValueError):
     pass
 
 
-class ClassiqQFuncError(ClassiqValueError):
-    pass
-
-
 class ClassiqQNNError(ClassiqValueError):
     pass
 
@@ -103,10 +83,6 @@ class ClassiqTorchError(ClassiqQNNError):
     pass
 
 
-class ClassiqChemistryError(ClassiqError):
-    pass
-
-
 class ClassiqAuthenticationError(ClassiqError):
     pass
 
@@ -115,22 +91,10 @@ class ClassiqExpiredTokenError(ClassiqAuthenticationError):
     pass
 
 
-class ClassiqFileNotFoundError(FileNotFoundError):
-    pass
-
-
-class ClassiqStateInitializationError(ClassiqError):
-    pass
-
-
 class ClassiqPasswordManagerSelectionError(ClassiqError):
     pass
 
 
-class ClassiqMismatchIOsError(ClassiqError):
-    pass
-
-
 class ClassiqNotImplementedError(ClassiqError, NotImplementedError):
     pass
 
@@ -171,12 +135,6 @@ class ClassiqCombOptNotSupportedProblemError(ClassiqCombOptError):
     pass
 
 
-class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
-
-    def __init__(self) -> None:
-        super().__init__("Invalid hamiltonian")
-
-
 class ClassiqDeprecationWarning(FutureWarning):
     pass
 

classiq/interface/executor/execution_request.py

@@ -58,6 +58,7 @@ class JobCost(BaseModel):
 class ExecutionJobDetails(VersionedModel):
     id: str
 
+    session_id: str | None = Field(default=None)
     name: str | None = Field(default=None)
     start_time: datetime
     end_time: datetime | None = Field(default=None)

classiq/interface/executor/quantum_code.py

@@ -11,7 +11,6 @@ from classiq.interface.backend.ionq.ionq_quantum_program import IonqQuantumCircu
 from classiq.interface.backend.pydantic_backend import PydanticArgumentNameType
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
-from classiq.interface.executor.register_initialization import RegisterInitialization
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
@@ -19,7 +18,6 @@ from classiq.interface.generator.synthesis_metadata.synthesis_execution_data imp
 Arguments = dict[PydanticArgumentNameType, Any]
 MultipleArguments = tuple[Arguments, ...]
 CodeType = str
-RegistersInitialization = dict[str, RegisterInitialization]
 Qubits = tuple[int, ...]
 OutputQubitsMap = dict[str, Qubits]
 
@@ -57,10 +55,6 @@ class QuantumCode(QuantumBaseCode):
         default_factory=dict,
         description="The map of outputs to their qubits in the circuit.",
     )
-    registers_initialization: RegistersInitialization | None = pydantic.Field(
-        default=None,
-        description="Initial conditions for the different registers in the circuit.",
-    )
     synthesis_execution_data: ExecutionData | None = pydantic.Field(default=None)
     synthesis_execution_arguments: Arguments = pydantic.Field(default_factory=dict)
     model_config = ConfigDict(validate_assignment=True)

classiq/interface/generator/generation_request.py

@@ -1,12 +1,17 @@
 from datetime import datetime
 
-from pydantic import Field
+from pydantic import ConfigDict, Field
 
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.jobs import JobStatus
 
 
-class SynthesisJobDetails(VersionedModel):
+class SynthesisActionDetails(VersionedModel):
+    """
+    Details of a synthesis user action.
+    """
+
+    model_config = ConfigDict(frozen=True)
     id: str
 
     name: str | None = Field(default=None)
@@ -31,5 +36,5 @@ class SynthesisJobDetails(VersionedModel):
     max_gate_count: int | None = Field(default=None)
 
 
-class SynthesisJobsQueryResults(VersionedModel):
-    results: list[SynthesisJobDetails]
+class SynthesisActionsQueryResults(VersionedModel):
+    results: list[SynthesisActionDetails]