classiq 0.65.4__py3-none-any.whl → 0.66.1__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -13,8 +13,11 @@ 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,
 )
@@ -445,3 +448,43 @@ class ApiWrapper:
             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)

classiq/applications/qnn/qlayer.py

@@ -1,12 +1,16 @@
 import functools
-from typing import Any, Callable, Optional, Union
+import inspect
+import typing
+from typing import Any, Callable, Optional, Union, overload
 
+import more_itertools
 import torch
 import torch.nn as nn
 from torch import Tensor
 from torch.nn.parameter import Parameter
 
 from classiq.interface.exceptions import ClassiqQNNError, ClassiqTorchError
+from classiq.interface.executor.execution_result import ResultsCollection
 
 from classiq.applications.qnn.circuit_utils import (
     extract_parameters,
@@ -29,6 +33,8 @@ from classiq.applications.qnn.types import (
     MultipleArguments,
     PostProcessFunction,
 )
+from classiq.execution import ExecutionSession
+from classiq.execution.qnn import _MAX_ARGUMENTS_SIZE, _execute_qnn_sample
 from classiq.synthesis import SerializedQuantumProgram
 
 
@@ -146,6 +152,7 @@ def calc_num_out_features_single_output(
 # Todo: extend the input to allow for multiple `qcode` - one for each output
 #   thus allowing (something X n) instead of (something X 1) output
 class QLayer(nn.Module):
+    @overload
     def __init__(
         self,
         quantum_program: SerializedQuantumProgram,
@@ -156,12 +163,56 @@ class QLayer(nn.Module):
         # Experimental parameters:
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
         epsilon: float = EPSILON,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        quantum_program: SerializedQuantumProgram,
+        post_process: PostProcessFunction,
+        /,
+        # Optional parameters:
+        head_start: Union[float, Tensor, None] = None,
+        # Experimental parameters:
+        calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
+        epsilon: float = EPSILON,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        quantum_program: SerializedQuantumProgram,
+        *args: Any,
+        **kwargs: Any,
     ) -> None:
         circuit = Circuit.model_validate_json(quantum_program)
         validate_circuit(circuit)
 
         super().__init__()
 
+        arg_list = list(args)
+
+        if "execute" in kwargs:
+            execute = kwargs.pop("execute")
+            typing.cast(ExecuteFunction, execute)
+        # Check if the next argument is the post-process function (which means the QLayer is constructed without an execute)
+        elif inspect.signature(arg_list[0]).return_annotation is Tensor:
+            execute = self._make_execute(quantum_program)
+        else:
+            execute = arg_list.pop(0)
+
+        self._initialize(quantum_program, circuit, execute, *arg_list, **kwargs)
+        self._initialize_parameters()
+
+    def _initialize(
+        self,
+        quantum_program: SerializedQuantumProgram,
+        circuit: Circuit,
+        execute: ExecuteFunction,
+        post_process: PostProcessFunction,
+        head_start: Union[float, Tensor, None] = None,
+        calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
+        epsilon: float = EPSILON,
+    ) -> None:
         self._execute = execute
         self._post_process = post_process
         self._head_start = head_start
@@ -173,8 +224,6 @@ class QLayer(nn.Module):
         self.in_features: int = len(weights)
         self.out_features: int = calc_num_out_features(quantum_program)
 
-        self._initialize_parameters()
-
     def _initialize_parameters(self) -> None:
         shape: tuple[int, ...] = (
             (self.out_features, self.in_features)
@@ -195,6 +244,19 @@ class QLayer(nn.Module):
 
         self.weight = Parameter(value)
 
+    @staticmethod
+    def _make_execute(quantum_program: SerializedQuantumProgram) -> ExecuteFunction:
+        session = ExecutionSession(quantum_program)
+
+        def execute(_ignored: Any, arguments: MultipleArguments) -> ResultsCollection:
+            result: ResultsCollection = []
+            for chunk in more_itertools.chunked(arguments, _MAX_ARGUMENTS_SIZE):
+                chunk_result = _execute_qnn_sample(session, chunk)
+                result.extend(chunk_result)
+            return result
+
+        return execute
+
     def forward(self, x: Tensor) -> Tensor:
         return QLayerFunction.apply(
             x,

classiq/execution/execution_session.py

@@ -352,8 +352,6 @@ class ExecutionSession:
         condition: Callable,
     ) -> None:
         """
-        EXPERIMENTAL
-
         When simulating on a statevector simulator, emulate the behavior of postprocessing
         by discarding amplitudes for which their states are "undesirable".
 

classiq/execution/iqcc.py

@@ -2,12 +2,49 @@ import time
 import webbrowser
 
 from classiq.interface.exceptions import ClassiqError
-from classiq.interface.execution.iqcc import IQCCInitAuthData, IQCCProbeAuthData
+from classiq.interface.execution.iqcc import (
+    IQCCAuthItemDetails,
+    IQCCInitAuthData,
+    IQCCListAuthMethods,
+    IQCCListAuthTargets,
+    IQCCProbeAuthData,
+)
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
 
 
+async def list_iqcc_auth_scopes_async() -> list[IQCCAuthItemDetails]:
+    """List available authentication scopes in IQCC Bounday.
+
+    Returns:
+        The available authentication scopes.
+    """
+    response = await ApiWrapper().call_iqcc_list_auth_scopes()
+    return response.items
+
+
+list_iqcc_auth_scopes = syncify_function(list_iqcc_auth_scopes_async)
+
+
+async def list_iqcc_auth_methods_async(auth_scope_id: str) -> list[IQCCAuthItemDetails]:
+    """List available authentication methods in IQCC Bounday for a specific scope.
+
+    Args:
+        auth_scope_id: The ID of the IQCC Boundary authentication scope.
+
+    Returns:
+        The available authentication methods.
+    """
+    response = await ApiWrapper().call_iqcc_list_auth_methods(
+        IQCCListAuthMethods(auth_scope_id=auth_scope_id)
+    )
+    return response.items
+
+
+list_iqcc_auth_methods = syncify_function(list_iqcc_auth_methods_async)
+
+
 async def generate_iqcc_token_async(
     auth_scope_id: str,
     auth_method_id: str,
@@ -61,3 +98,31 @@ async def generate_iqcc_token_async(
 
 
 generate_iqcc_token = syncify_function(generate_iqcc_token_async)
+
+
+async def list_iqcc_auth_targets_async(
+    auth_scope_id: str,
+    auth_method_id: str,
+    auth_token: str,
+) -> list[IQCCAuthItemDetails]:
+    """List available authentication targets in IQCC Boundary for the user.
+
+    Args:
+        auth_scope_id: The ID of the IQCC Boundary authentication scope.
+        auth_method_id: The ID of the IQCC Boundary authentication method.
+        auth_token: The authentication token string returned from `generate_iqcc_token_async`.
+
+    Returns:
+        The available authentication targets.
+    """
+    response = await ApiWrapper().call_iqcc_list_auth_targets(
+        IQCCListAuthTargets(
+            auth_scope_id=auth_scope_id,
+            auth_method_id=auth_method_id,
+            auth_token=auth_token,
+        )
+    )
+    return response.items
+
+
+list_iqcc_auth_target = syncify_function(list_iqcc_auth_targets_async)

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

classiq/interface/ast_node.py

@@ -1,15 +1,29 @@
-from typing import Optional
+from typing import Optional, TypeVar
+from uuid import UUID
 
 import pydantic
+from typing_extensions import Self
 
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 from classiq.interface.source_reference import SourceReference
 
+ASTNodeType = TypeVar("ASTNodeType", bound="ASTNode")
+
 
 class ASTNode(HashablePydanticBaseModel):
     source_ref: Optional[SourceReference] = pydantic.Field(default=None)
+    back_ref: Optional[UUID] = pydantic.Field(default=None)
+
+    def _as_back_ref(self: Self) -> Self:
+        return self
+
+
+def without_statement_blocks(
+    ast_node: ASTNodeType, statement_block_fields: list[str]
+) -> ASTNodeType:
+    return ast_node.model_copy(update={field: [] for field in statement_block_fields})
 
 
 class HashableASTNode(ASTNode, HashablePydanticBaseModel):

classiq/interface/backend/backend_preferences.py

@@ -161,20 +161,6 @@ class ClassiqBackendPreferences(BackendPreferences):
     def is_nvidia_backend(self) -> bool:
         return self.backend_name in list(ClassiqNvidiaBackendNames)
 
-    # CAD-25390
-    @pydantic.field_validator("backend_name")
-    @classmethod
-    def _validate_nvidia_name_backwards_compatibility(cls, backend_name: str) -> str:
-        if backend_name == "nvidia_state_vector_simulator":
-            warnings.warn(
-                "The name 'nvidia_state_vector_simulator' is deprecated and "
-                "will be removed soon, no earlier than January 12th 2025. "
-                "Please use ClassiqNvidiaBackendNames.SIMULATOR instead",
-                ClassiqDeprecationWarning,
-                stacklevel=2,
-            )
-        return backend_name
-
 
 class AwsBackendPreferences(BackendPreferences):
     """

classiq/interface/debug_info/debug_info.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.generated_circuit_data import (
     FunctionDebugInfoInterface,
     OperationLevel,
 )
+from classiq.interface.model.statement_block import ConcreteQuantumStatement
 
 ParameterValue = Union[float, int, str, None]
 
@@ -32,6 +33,7 @@ class FunctionDebugInfo(BaseModel):
     is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
+    node: Optional[ConcreteQuantumStatement] = None
 
     @staticmethod
     def param_controller(value: Any) -> str:

classiq/interface/execution/iqcc.py

@@ -1,3 +1,7 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 
@@ -17,3 +21,24 @@ class IQCCProbeAuthData(IQCCInitAuthData):
 
 class IQCCProbeAuthResponse(VersionedModel):
     auth_token: str
+
+
+class IQCCAuthItemDetails(BaseModel):
+    id: str
+    name: str
+    description: str
+    scope_id: Optional[str] = Field(default=None)
+
+
+class IQCCAuthItemsDetails(VersionedModel):
+    items: list[IQCCAuthItemDetails]
+
+
+class IQCCListAuthMethods(VersionedModel):
+    auth_scope_id: str
+
+
+class IQCCListAuthTargets(VersionedModel):
+    auth_scope_id: str
+    auth_method_id: str
+    auth_token: str

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -3,10 +3,7 @@ from typing import TYPE_CHECKING, Any, Union
 
 from sympy import Integer
 
-from classiq.interface.exceptions import (
-    ClassiqInternalExpansionError,
-    ClassiqValueError,
-)
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
@@ -45,9 +42,6 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
     def _get_subscript(self, index: Union[int, Integer]) -> "QmodSizedProxy":
         if isinstance(index, Integer):
             index = int(index)
-        if index < 0 or index >= self._length:
-            raise ClassiqInternalExpansionError
-
         return self._element_type.get_proxy(
             SubscriptHandleBinding(
                 base_handle=self.handle,
@@ -64,12 +58,6 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
             slice_ = slice(slice_.start, int(slice_.stop))
         if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
             raise ClassiqValueError(ILLEGAL_SLICE_MSG)
-        if (
-            slice_.start >= slice_.stop
-            or slice_.start < 0
-            or slice_.stop > self._length
-        ):
-            raise ClassiqInternalExpansionError
 
         return QmodQArrayProxy(
             SlicedHandleBinding(

classiq/interface/generator/visitor.py

@@ -1,5 +1,6 @@
 from collections import abc, defaultdict
 from collections.abc import Collection, Mapping, Sequence
+from functools import partial
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -90,12 +91,14 @@ class Transformer(Visitor):
     ) -> defaultdict[Key, RetType]:
         new_default_factory: Callable[[], RetType] | None = None
         if (default_factory := node.default_factory) is not None:
-
-            def new_default_factory() -> RetType:
-                return self.visit(default_factory())  # type: ignore[misc]
-
+            new_default_factory = partial(
+                self._new_default_factory, default_factory=default_factory
+            )
         return defaultdict(new_default_factory, self.visit_dict(node))
 
+    def _new_default_factory(self, default_factory: Callable[[], NodeType]) -> RetType:
+        return self.visit(default_factory())
+
     def visit_tuple(self, node: tuple[NodeType, ...]) -> tuple[RetType, ...]:
         return tuple(self.visit(value) for value in node)
 

classiq/interface/model/classical_if.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
+from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -13,3 +14,6 @@ class ClassicalIf(QuantumOperation):
     condition: Expression
     then: "StatementBlock"
     else_: "StatementBlock"
+
+    def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
+        return without_statement_blocks(self, ["then", "else_"])

classiq/interface/model/control.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Literal, Optional
 
 import pydantic
 
+from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
@@ -43,3 +44,6 @@ class Control(QuantumExpressionOperation):
         self._result_type = compute_arithmetic_result_type(
             self.expression.expr, var_types, machine_precision
         )
+
+    def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
+        return without_statement_blocks(self, ["body", "else_block"])

classiq/interface/model/invert.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
+from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -10,3 +11,6 @@ class Invert(QuantumOperation):
     kind: Literal["Invert"]
 
     body: "StatementBlock"
+
+    def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
+        return without_statement_blocks(self, ["body"])

classiq/interface/model/model.py

@@ -1,6 +1,6 @@
 from collections import Counter
 from collections.abc import Mapping
-from typing import Any, Literal, NewType
+from typing import Any, Literal, NewType, Optional
 
 import pydantic
 
@@ -9,6 +9,7 @@ from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -102,6 +103,7 @@ class Model(VersionedModel, ASTNode):
     functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
         default_factory=dict
     )
+    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = None
 
     @property
     def main_func(self) -> NativeFunctionDefinition:

classiq/interface/model/model_visitor.py

@@ -0,0 +1,14 @@
+from classiq.interface.debug_info.debug_info import DebugInfoCollection
+from classiq.interface.generator.visitor import Transformer, Visitor
+
+
+class ModelVisitor(Visitor):
+    def visit_DebugInfoCollection(self, debug_info: DebugInfoCollection) -> None:
+        return
+
+
+class ModelTransformer(Transformer):
+    def visit_DebugInfoCollection(
+        self, debug_info: DebugInfoCollection
+    ) -> DebugInfoCollection:
+        return debug_info

classiq/interface/model/power.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
+from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -12,3 +13,6 @@ class Power(QuantumOperation):
 
     power: Expression
     body: "StatementBlock"
+
+    def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
+        return without_statement_blocks(self, ["body"])

classiq/interface/model/quantum_statement.py

@@ -17,6 +17,9 @@ from classiq.interface.model.handle_binding import (
 class QuantumStatement(ASTNode):
     kind: str
     model_config = ConfigDict(extra="forbid")
+    uuid: UUID = pydantic.Field(
+        description="A unique identifier for this operation", default_factory=uuid4
+    )
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -31,9 +34,6 @@ class HandleMetadata:
 
 
 class QuantumOperation(QuantumStatement):
-    uuid: UUID = pydantic.Field(
-        description="A unique identifier for this operation", default_factory=uuid4
-    )
     _generative_blocks: dict[str, Callable] = pydantic.PrivateAttr(default_factory=dict)
 
     @property

classiq/interface/model/repeat.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
+from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -13,3 +14,6 @@ class Repeat(QuantumOperation):
     iter_var: str
     count: Expression
     body: "StatementBlock"
+
+    def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
+        return without_statement_blocks(self, ["body"])

classiq/interface/model/within_apply_operation.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
+from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -11,3 +12,6 @@ class WithinApply(QuantumOperation):
 
     compute: "StatementBlock"
     action: "StatementBlock"
+
+    def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
+        return without_statement_blocks(self, ["compute", "action"])

classiq/interface/server/routes.py

@@ -82,3 +82,9 @@ IQCC_INIT_AUTH_SUFFIX = "/init_auth"
 IQCC_INIT_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_INIT_AUTH_SUFFIX
 IQCC_PROBE_AUTH_SUFFIX = "/probe_auth"
 IQCC_PROBE_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_PROBE_AUTH_SUFFIX
+IQCC_LIST_AUTH_SCOPES_SUFFIX = "/auth_scopes"
+IQCC_LIST_AUTH_SCOPES_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_SCOPES_SUFFIX
+IQCC_LIST_AUTH_METHODS_SUFFIX = "/auth_methods"
+IQCC_LIST_AUTH_METHODS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_METHODS_SUFFIX
+IQCC_LIST_AUTH_TARGETS_SUFFIX = "/auth_targets"
+IQCC_LIST_AUTH_TARGETS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_TARGETS_SUFFIX

classiq/model_expansions/closure.py

@@ -17,7 +17,6 @@ from classiq.interface.model.quantum_lambda_function import QuantumCallable
 from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.capturing.captured_vars import CapturedVars
-from classiq.model_expansions.expression_renamer import ExpressionRenamer
 from classiq.model_expansions.scope import (
     Evaluated,
     QuantumSymbol,
@@ -84,20 +83,10 @@ class FunctionClosure(Closure):
         scope: Scope,
         body: Optional[Sequence[QuantumStatement]] = None,
         positional_arg_declarations: Sequence[PositionalArg] = tuple(),
-        expr_renamer: Optional[ExpressionRenamer] = None,
         is_lambda: bool = False,
         is_atomic: bool = False,
         **kwargs: Any,
     ) -> Self:
-        if expr_renamer:
-            positional_arg_declarations = (
-                expr_renamer.rename_positional_arg_declarations(
-                    positional_arg_declarations
-                )
-            )
-            if body is not None:
-                body = expr_renamer.visit(body)
-
         blocks = {"body": body} if body is not None else {}
         return cls(
             name,