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

classiq/open_library/functions/state_preparation.py

@@ -13,8 +13,8 @@ from classiq.open_library.functions.utility_functions import (
 from classiq.qmod.builtins.functions import (
     CX,
     IDENTITY,
-    PHASE,
     RY,
+    RZ,
     H,
     X,
     free,
@@ -28,6 +28,7 @@ from classiq.qmod.builtins.operations import (
     inplace_add,
     inplace_xor,
     invert,
+    phase,
     repeat,
     within_apply,
 )
@@ -337,10 +338,12 @@ def apply_phase_table(
     for i in range(1, len(alphas) - 1):
         gray = _graycode(i)
         next_gray = _graycode(i + 1)
-        PHASE(alphas[gray], target[_msb(gray)])
+        RZ(alphas[gray], target[_msb(gray)])
         CX(target[_control_qubit(i)], target[_msb(next_gray)])
 
-    PHASE(alphas[_graycode(len(phases) - 1)], target[target.len - 1])
+    RZ(alphas[_graycode(len(phases) - 1)], target[target.len - 1])
+    # fix the global phase:
+    phase(-0.5 * alphas[0])
 
 
 @qfunc
@@ -393,7 +396,7 @@ def _dicke_split_cycle_shift(k: int, qvar: QArray[QBit]) -> None:
     internal function, assumes the input is in the form |11..100..0> with up to k ones.
     transforms the state to: sqrt(1/n)*|11..100..0> + sqrt((n-1)/n)*|01..110..0>.
     """
-    for i in range(k):
+    for i in range(min(k, qvar.len - 1)):
         within_apply(
             lambda i=i: CX(qvar[i + 1], qvar[0]),  # type: ignore[misc]
             lambda i=i: (  # type: ignore[misc]
@@ -415,7 +418,7 @@ def prepare_dicke_state_unary_input(max_k: int, qvar: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
 
-    Prepares a Dicke state with a variable number of excitations based on an unary-encoded input.
+    Prepares a Dicke state with a variable number of excitations based on a unary-encoded input.
 
     The Dicke state is defined to be:
 
@@ -430,9 +433,12 @@ def prepare_dicke_state_unary_input(max_k: int, qvar: QArray[QBit]) -> None:
         max_k: The maximum number of allowed excitations (upper bound for k).
         qvar: Unary-encoded quantum input register of length >= max_k. Must be pre-initialized.
     """
-    if qvar.len > max(1, max_k):
+    if qvar.len >= max(1, max_k):
         _dicke_split_cycle_shift(max_k, qvar)
-        prepare_dicke_state_unary_input(min(max_k, qvar.len - 2), qvar[1 : qvar.len])
+        if qvar.len > 2:
+            prepare_dicke_state_unary_input(
+                min(max_k, qvar.len - 2), qvar[1 : qvar.len]
+            )
 
 
 @qfunc

classiq/open_library/functions/utility_functions.py

@@ -4,13 +4,13 @@ from typing import Annotated
 from classiq.interface.exceptions import ClassiqDeprecationWarning
 
 from classiq.open_library.functions.qft_functions import qft
-from classiq.qmod.builtins.functions.standard_gates import PHASE, H
+from classiq.qmod.builtins.functions.standard_gates import PHASE, SWAP, H
 from classiq.qmod.builtins.operations import bind, repeat, within_apply
 from classiq.qmod.cparam import CInt
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
 from classiq.qmod.qmod_variable import QArray, QBit, QCallable, QNum
 from classiq.qmod.quantum_callable import QCallableList
-from classiq.qmod.symbolic import pi
+from classiq.qmod.symbolic import min, pi
 
 
 @qfunc
@@ -50,6 +50,25 @@ def hadamard_transform(target: QArray[QBit]) -> None:
     repeat(target.len, lambda index: H(target[index]))
 
 
+@qperm
+def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Swaps the qubit states between two arrays.
+    Qubits of respective indices are swapped, and additional qubits in the longer array are left unchanged.
+
+    Args:
+        x: The first array
+        y: The second array
+
+    """
+    repeat(
+        count=min(x.len, y.len),
+        iteration=lambda index: SWAP(x[index], y[index]),
+    )
+
+
 @qfunc
 def switch(selector: CInt, cases: QCallableList) -> None:
     cases[selector]()

classiq/qmod/builtins/functions/exponentiation.py

@@ -218,10 +218,10 @@ def sparse_suzuki_trotter(
 
 @qfunc(external=True)
 def qdrift(
-    pauli_operator: SparsePauliOp,  # FIXME: Rename to hamiltonian (CLS-4347)
+    pauli_operator: SparsePauliOp,
     evolution_coefficient: CReal,
     num_qdrift: CInt,
-    qbv: QArray[QBit],  # FIXME: Add length expr (CLS-4347)
+    qbv: QArray[QBit, Literal["pauli_operator.num_qubits"]],
 ) -> None:
     """
     [Qmod core-library function]

classiq/qmod/builtins/operations.py

@@ -30,7 +30,7 @@ from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.control import Control
-from classiq.interface.model.invert import Invert
+from classiq.interface.model.invert import BlockKind, Invert
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
@@ -49,6 +49,7 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.skip_control import SkipControl
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
+from classiq.interface.source_reference import SourceReference
 
 from classiq.qmod.builtins.functions import H, S
 from classiq.qmod.generative import is_generative_mode
@@ -552,7 +553,7 @@ def power(
 
 @suppress_return_value
 @qmod_statement
-def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
+def invert(stmt_block: QCallable | Callable[[], Statements]) -> Callable | None:
     """
     Apply the inverse of a quantum gate.
 
@@ -574,11 +575,35 @@ def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
             invert(qft(x))
         ```
     """
-    _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(2))
+
+    if (
+        isinstance(stmt_block, QCallable)
+        and len(stmt_block.func_decl.positional_arg_declarations) > 0
+    ):
+        return lambda *args, **kwargs: _invert(
+            lambda: stmt_block(  # type:ignore[call-arg]
+                *args, **kwargs, _source_ref=source_ref
+            ),
+            source_ref,
+            BlockKind.SingleCall,
+        )
+    _invert(stmt_block, source_ref, BlockKind.Compound)
+    return None
+
+
+def _invert(
+    stmt_block: Callable[[], Statements],
+    source_ref: SourceReference,
+    block_kind: BlockKind,
+) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    _validate_operand(stmt_block)
     invert_stmt = Invert(
-        body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref
+        body=_operand_to_body(stmt_block, "stmt_block"),
+        block_kind=block_kind,
+        source_ref=source_ref,
     )
     if is_generative_mode():
         invert_stmt.set_generative_block("body", stmt_block)

classiq/qmod/native/pretty_printer.py

@@ -42,7 +42,7 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
-from classiq.interface.model.invert import Invert
+from classiq.interface.model.invert import BlockKind, Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
@@ -367,9 +367,20 @@ class DSLPrettyPrinter(ModelVisitor):
         return power_code
 
     def visit_Invert(self, invert: Invert) -> str:
-        invert_code = f"{self._indent}invert {{\n"
-        invert_code += self._visit_body(invert.body)
-        invert_code += f"{self._indent}}}\n"
+        match invert.block_kind:
+            case BlockKind.SingleCall:
+                if len(invert.body) != 1 or not isinstance(
+                    invert.body[0], QuantumFunctionCall
+                ):
+                    raise ClassiqInternalError("Malformed single-call invert")
+                invert_code = f"{self._indent}invert "
+                invert_code += self.visit(invert.body[0]).lstrip()
+            case BlockKind.Compound:
+                invert_code = f"{self._indent}invert {{\n"
+                invert_code += self._visit_body(invert.body)
+                invert_code += f"{self._indent}}}\n"
+            case _:
+                raise ClassiqInternalError("Unknown block type")
         return invert_code
 
     def visit_Block(self, block: Block) -> str:

classiq/qmod/pretty_print/pretty_printer.py

@@ -45,7 +45,7 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
-from classiq.interface.model.invert import Invert
+from classiq.interface.model.invert import BlockKind, Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
@@ -509,7 +509,19 @@ class PythonPrettyPrinter(ModelVisitor):
 
     def visit_Invert(self, invert: Invert) -> str:
         self._imports["invert"] = 1
-        return f"{self._indent}invert({self._visit_body(invert.body)})\n"
+        match invert.block_kind:
+            case BlockKind.SingleCall:
+                if len(invert.body) != 1 or not isinstance(
+                    invert.body[0], QuantumFunctionCall
+                ):
+                    raise ClassiqInternalError("Malformed single-call invert")
+                call_str = self.visit(invert.body[0])
+                call_str = call_str.replace("(", ")(", 1)
+                return f"{self._indent}invert({call_str}\n"
+            case BlockKind.Compound:
+                return f"{self._indent}invert({self._visit_body(invert.body)})\n"
+            case _:
+                raise ClassiqInternalError("Unknown block type")
 
     def visit_Block(self, block: Block) -> str:
         self._imports["block"] = 1

classiq/qmod/qmod_variable.py

@@ -274,7 +274,7 @@ class QScalar(QVar, SymbolicExpr):
 
     def __iand__(self, other: Any) -> NoReturn:
         raise ClassiqNotImplementedError(
-            f"{self.get_qmod_type().raw_qmod_type_name} does not support '-='"
+            f"{self.get_qmod_type().raw_qmod_type_name} does not support '&='"
         )
 
     def __ifloordiv__(self, other: Any) -> NoReturn:

classiq/qmod/quantum_callable.py

@@ -46,9 +46,15 @@ class QCallable(Generic[P], ABC):
     FRAME_DEPTH = 1
 
     @suppress_return_value
-    def __call__(self, *args: Any, **kwargs: Any) -> None:
+    def __call__(
+        self, *args: Any, _source_ref: SourceReference | None = None, **kwargs: Any
+    ) -> None:
         assert QCallable.CURRENT_EXPANDABLE is not None
-        source_ref = get_source_ref(sys._getframe(self.FRAME_DEPTH))
+        source_ref = (
+            get_source_ref(sys._getframe(self.FRAME_DEPTH))
+            if _source_ref is None
+            else _source_ref
+        )
         QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
             self.create_quantum_function_call(source_ref, *args, **kwargs)
         )

classiq/qmod/quantum_expandable.py

@@ -388,7 +388,9 @@ def prepare_arg(
                 qlambda.set_py_callable(val._py_callable)
             return qlambda
 
-        if isinstance(val, QExpandable):
+        if isinstance(val, QExpandable) and (
+            get_global_declarative_switch() or not is_generative_mode()
+        ):
             val.expand()
         elif isinstance(val, QTerminalCallable):
             return val.get_arg()

classiq/qmod/quantum_function.py

@@ -162,7 +162,8 @@ class QFunc(BaseQFunc):
             not get_global_declarative_switch()
             and len(self._qmodule.generative_functions) > 0
         ):
-            return self._create_generative_model(model)
+            model = self._create_generative_model(model)
+        model.compress_debug_info()
         return model
 
     def _create_generative_model(self, model_stub: Model) -> Model:

classiq/qmod/semantics/error_manager.py

@@ -20,6 +20,7 @@ class ErrorManager:
         self._current_refs_stack: list[SourceReference | None] = []
         self._call_stack: list[str] = []
         self._ignore_errors: bool = False
+        self._treat_warnings_as_errors: bool = False
 
     @property
     def _current_source_ref(self) -> SourceReference | None:
@@ -36,6 +37,15 @@ class ErrorManager:
         finally:
             self._ignore_errors = previous
 
+    @contextmanager
+    def treat_warnings_as_errors_context(self, value: bool) -> Iterator[None]:
+        previous = self._treat_warnings_as_errors
+        self._treat_warnings_as_errors = value
+        try:
+            yield
+        finally:
+            self._treat_warnings_as_errors = previous
+
     @property
     def annotated_errors(self) -> list[str]:
         return [str(error) for error in self._errors]
@@ -62,7 +72,7 @@ class ErrorManager:
             ),
             function=(function if function is not None else self.current_function),
         )
-        if warning:
+        if warning and not self._treat_warnings_as_errors:
             self._warnings.append(source_ref_error)
         else:
             self._errors.append(source_ref_error)

classiq/qmod/utilities.py

@@ -11,6 +11,7 @@ from typing import (
     Any,
     ForwardRef,
     Literal,
+    TypeVar,
     Union,
     get_args,
     get_origin,
@@ -156,18 +157,20 @@ def varname(depth: int) -> str | None:
     return var_name
 
 
+ReturnType = TypeVar("ReturnType")
 Params = ParamSpec("Params")
 
 
-def suppress_return_value(func: Callable[Params, None]) -> Callable[Params, None]:
+def suppress_return_value(
+    func: Callable[Params, ReturnType],
+) -> Callable[Params, ReturnType]:
     # An empty decorator suppresses mypy's func-returns-value error when assigning the
     # return value of a None-returning function
     return func
 
 
-Statements = Union[
-    None, list[Union[None, "QVar", "CParam"]], tuple[Union[None, "QVar", "CParam"], ...]
-]
+Statement = Union[None, Callable, "QVar", "CParam"]
+Statements = Union[Statement, list[Statement], tuple[Statement, ...]]
 
 
 def _eval_qnum(val: int, size: int, is_signed: bool, fraction_digits: int) -> float:

classiq/synthesis_action/__init__.py

@@ -0,0 +1,20 @@
+from classiq.interface.generator.generation_request import (
+    SynthesisActionDetails,
+)
+
+from .actions import (
+    SynthesisActionFilters,
+    get_synthesis_actions,
+    get_synthesis_actions_async,
+)
+
+__all__ = [
+    "SynthesisActionDetails",
+    "SynthesisActionFilters",
+    "get_synthesis_actions",
+    "get_synthesis_actions_async",
+]
+
+
+def __dir__() -> list[str]:
+    return __all__

classiq/synthesis_action/actions.py

@@ -0,0 +1,106 @@
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from classiq.interface.jobs import JobStatus
+
+from classiq._internals.api_wrapper import ApiWrapper
+from classiq._internals.async_utils import syncify_function
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+@dataclass
+class SynthesisActionFilters:
+    """
+    Filter parameters for querying synthesis actions.
+
+    All filters are combined using AND logic: only actions matching all specified filters are returned.
+    Range filters (with _min/_max suffixes) are inclusive.
+    Datetime filters are compared against the job's timestamps.
+    """
+
+    status: JobStatus | None = None
+    target_backend: str | None = None
+    optimization_level: str | None = None
+    program_id: str | None = None
+    backend_name: str | None = None
+    optimization_parameter: str | None = None
+    random_seed: int | None = None
+    max_width: int | None = None
+    max_gate_count: int | None = None
+    total_cost_min: float | None = None
+    total_cost_max: float | None = None
+    start_time_min: datetime | None = None
+    start_time_max: datetime | None = None
+    end_time_min: datetime | None = None
+    end_time_max: datetime | None = None
+
+    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
+        }
+
+
+async def get_synthesis_actions_async(
+    offset: int = 0,
+    limit: int = 50,
+    filters: SynthesisActionFilters | None = None,
+) -> "pd.DataFrame":
+    """Query synthesis actions with optional filters.
+    Args:
+        offset: Number of results to skip (default: 0)
+        limit: Maximum number of results to return (default: 50)
+        filters: Optional SynthesisActionFilters object containing filter parameters.
+
+    Returns:
+        A pandas DataFrame containing synthesis actions matching the filters.
+        Each row represents a synthesis action with columns for all fields
+        from SynthesisActionDetails (id, name, start_time, end_time, status, etc.).
+    """
+    import pandas as pd
+
+    api_kwargs = filters.format_filters() if filters is not None else {}
+
+    result = await ApiWrapper().call_query_synthesis_actions(
+        offset, limit, http_client=None, **api_kwargs
+    )
+
+    if not result.results:
+        return pd.DataFrame()
+
+    return pd.DataFrame(action.model_dump() for action in result.results)
+
+
+def get_synthesis_actions(
+    offset: int = 0,
+    limit: int = 50,
+    filters: SynthesisActionFilters | None = None,
+) -> "pd.DataFrame":
+    """Query synthesis actions with optional filters.
+
+    Args:
+        offset: Number of results to skip (default: 0)
+        limit: Maximum number of results to return (default: 50)
+        filters: Optional SynthesisActionFilters object containing filter parameters.
+
+    Returns:
+        A pandas DataFrame containing synthesis actions matching the filters.
+        Each row represents a synthesis action with columns for all fields
+        from SynthesisActionDetails (id, name, start_time, end_time, status, etc.).
+
+    Examples:
+        # Query all actions:
+        df = get_synthesis_actions(limit=10)
+
+        # Query with filters:
+        filters = SynthesisActionFilters(status="COMPLETED", target_backend="ibm")
+        df = get_synthesis_actions(filters=filters, limit=10)
+    """
+
+    return syncify_function(get_synthesis_actions_async)(offset, limit, filters)

{classiq-0.99.0.dist-info → classiq-0.102.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classiq
-Version: 0.99.0
+Version: 0.102.0
 Summary: Classiq's Python SDK for quantum computing
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
 Author: Classiq Technologies