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

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

@@ -1,5 +1,6 @@
 import ast
 import functools
+import inspect
 import warnings
 from abc import abstractmethod
 from collections.abc import Callable
@@ -8,7 +9,11 @@ from enum import EnumMeta
 from inspect import isclass
 from typing import Any, get_origin
 
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqError
+from classiq.interface.exceptions import (
+    ClassiqDeprecationWarning,
+    ClassiqError,
+    ClassiqExpansionError,
+)
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -162,7 +167,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:
@@ -275,10 +281,16 @@ class ExternalQFunc(QTerminalCallable):
                 ClassiqDeprecationWarning,
                 stacklevel=2,
             )
-        if (
-            self._py_callable.__name__ == "suzuki_trotter"
-            and len(args) > 0
-            and isinstance(args[0], (list, CParamList))
+        if self._py_callable.__name__ == "suzuki_trotter" and (
+            (
+                "pauli_operator" not in kwargs
+                and len(args) > 0
+                and isinstance(args[0], (list, CParamList))
+            )
+            or (
+                "pauli_operator" in kwargs
+                and isinstance(kwargs["pauli_operator"], (list, CParamList))
+            )
         ):
             warnings.warn(
                 (
@@ -319,6 +331,19 @@ class ExternalQFunc(QTerminalCallable):
                 ClassiqDeprecationWarning,
                 stacklevel=2,
             )
+        if (
+            self._py_callable.__name__ == "unscheduled_suzuki_trotter"
+        ):  # FIXME: remove (CLS-5391)
+            warnings.warn(
+                (
+                    "Function 'unscheduled_suzuki_trotter' was renamed to "
+                    "'sequential_suzuki_trotter'. 'unscheduled_suzuki_trotter' is "
+                    "deprecated and will no longer be supported starting on 2026-02-02 "
+                    "at the earliest."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
         super().__call__(*args, **kwargs)
 
 
@@ -347,14 +372,26 @@ class GenerativeQFunc(BaseQFunc):
         return self._inferred_func_decl
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
+        from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
+
         if get_global_declarative_switch():
             return QFunc(
                 self._py_callable,
                 self.compilation_metadata,
                 permutation=self.permutation,
             )(*args, **kwargs)
-        if self.func_decl.name not in self._qmodule.generative_functions:
-            self._qmodule.generative_functions[self.func_decl.name] = self
+        frame = inspect.currentframe()
+        caller_frame = frame.f_back if frame is not None else None
+        module = inspect.getmodule(caller_frame)
+        func_name = self.func_decl.name
+        if func_name in BUILTIN_FUNCTION_DECLARATIONS and (
+            module is None or not module.__name__.startswith("model.function_library")
+        ):
+            raise ClassiqExpansionError(
+                f"Cannot redefine built-in function {func_name!r}"
+            )
+        if func_name not in self._qmodule.generative_functions:
+            self._qmodule.generative_functions[func_name] = self
             if self._func_decl is None:
                 self._inferred_func_decl = infer_func_decl(
                     self._py_callable, self._qmodule, permutation=self.permutation

classiq/qmod/semantics/validation/function_name_collisions_validation.py

@@ -1,13 +1,16 @@
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.model import Model
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
 
-from classiq.qmod.builtins.functions import CORE_LIB_DECLS
 
-
-def check_function_name_collisions(model: Model) -> None:
+def check_function_name_collisions(
+    model: Model, builtin_functions: list[NamedParamsQuantumFunctionDeclaration]
+) -> None:
     redefined_functions = [
         function.name
-        for function in CORE_LIB_DECLS
+        for function in builtin_functions
         if function.name in model.function_dict
     ]
     if len(redefined_functions) == 1:

classiq/qmod/semantics/validation/model_validation.py

@@ -1,4 +1,7 @@
 from classiq.interface.model.model import Model
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
 
 from classiq.qmod.semantics.validation.constants_validation import (
     check_duplicate_constants,
@@ -14,7 +17,9 @@ from classiq.qmod.semantics.validation.types_validation import (
 )
 
 
-def validate_model(model: Model) -> None:
+def validate_model(
+    model: Model, builtin_functions: list[NamedParamsQuantumFunctionDeclaration]
+) -> None:
     check_duplicate_types([*model.enums, *model.types, *model.qstructs])
     check_duplicate_constants(model.constants)
     for qstruct in model.qstructs:
@@ -22,4 +27,4 @@ def validate_model(model: Model) -> None:
     for cstruct in model.types:
         validate_cstruct(cstruct)
     validate_main_function(model.main_func)
-    check_function_name_collisions(model)
+    check_function_name_collisions(model, builtin_functions)

classiq/qmod/symbolic_type.py

@@ -1,6 +1,8 @@
 from typing import Union, get_args, get_origin
 
-from classiq.qmod.symbolic_expr import SymbolicExpr
+from classiq.qmod.symbolic_expr import Symbolic
 
-SymbolicTypes = Union[SymbolicExpr, int, float, bool, tuple["SymbolicTypes", ...]]
+SymbolicTypes = Union[
+    Symbolic, int, float, bool, tuple["SymbolicTypes", ...], list["SymbolicTypes"]
+]
 SYMBOLIC_TYPES = tuple(get_origin(t) or t for t in get_args(SymbolicTypes))

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.100.0.dist-info → classiq-0.104.0.dist-info}/METADATA

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